adianti framework

Prévia do material em texto

ADIANTI STUDIO PROFESSIONAL
Versão 5.5 ou superior
PABLO DALL'OGLIO
Sumário
1 Introdução..................................................................................................................................7
1.1 Organização da interface...............................................................................................7
1.2 Visão geral dos menus....................................................................................................8
1.3 Preferências...................................................................................................................11
1.4 Gerenciamento de projetos.........................................................................................11
1.5 Gerenciamento de bancos de dados.........................................................................13
2 Criação do projeto..................................................................................................................15
2.1 Visão geral......................................................................................................................15
2.2 Cadastro do projeto......................................................................................................16
2.3 Cadastro da base de dados.........................................................................................17
2.4 Criação das classes modelo.........................................................................................18
2.5 Conversão de UML para SQL.......................................................................................20
2.6 Conversão de UML para PHP......................................................................................24
3 Criação de Páginas..................................................................................................................27
3.1 Páginas com HTML........................................................................................................27
3.2 Páginas com PDF...........................................................................................................27
3.3 Páginas com conteúdo externo..................................................................................28
3.4 Janela com HTML...........................................................................................................29
3.5 Janela com PDF..............................................................................................................29
3.6 Janela com conteúdo externo.....................................................................................30
4 Criação de Formulários..........................................................................................................31
4.1 Formulários de cadastro..............................................................................................31
4.2 Formulários de consulta..............................................................................................34
4.3 Formulários de cadastro auxiliar................................................................................36
4.4 Formulário vetorial.......................................................................................................39
4.5 Formulário mestre/detalhe.........................................................................................42
4.6 Formulário consulta mestre/detalhe.........................................................................45
5 Criação de Listagens...............................................................................................................49
5.1 Listagens de registros...................................................................................................49
5.2 Relatório tabular...........................................................................................................52
5.3 Lista de seleção de registros.......................................................................................55
5.4 Lista de edição de registros.........................................................................................58
Adianti Studio Professional 3
6 REST Services...........................................................................................................................63
6.1 Habilitando o servidor REST........................................................................................63
6.2 Criando uma classe de serviço REST..........................................................................63
6.3 Consumindo um serviço REST.....................................................................................64
7 Studio Form Designer.............................................................................................................66
7.1 Visão Geral.....................................................................................................................66
7.2 Criando controladores.................................................................................................73
7.3 Integrando com banco de dados................................................................................86
8 Studio PDF Designer...............................................................................................................96
8.1 Visão geral......................................................................................................................96
8.2 Formas e textos.............................................................................................................99
8.3 Relatórios.....................................................................................................................103
8.4 Nota fiscal....................................................................................................................105
Dedicatória
Dedico esta obra a todos aqueles que acreditam no meu trabalho e me motivam a
continuar criando soluções e escrevendo livros. Obrigado do fundo do coração. Eu
respondo e guardo cada e-mail de vocês com muita felicidade.
Mensagem
Este manual cobre somente o Adianti Studio. Para o Adianti Framework, não deixe
de conferir o livro completo sobre a obra: www.adianti.com.br/bkframe 
http://www.adianti.com.br/bkframe
Agradecimentos
Agradeço primeiramente a Deus, que tem me dado força todos os dias para cumprir
minha missão pessoal, que eu acredito ser construir e ensinar. Nesse sentido, tenho
me empenhado em construir ferramentas que possam não apenas auxiliar em meus
projetos, mas que também possam auxiliar pessoas como você. Em segundo lugar,
agradeço a minha esposa por compreender minha atuação profissional e minhas
madrugadas de programação; por me amar incondicionalmente. Também agradeço
aos meus pais e meus avós pela educação e por apostarem em mim, e minha irmã
por estar sempre ao meu lado. E aos meus amigos, que não são muitos, mas são ver-
dadeiros irmãos pois sei que sempre posso contar com eles.
Apresentação
Ao utilizarmos um framework para desenvolvimento de sistemas, ganhamos unifor-
midade no código-fonte, maior qualidade e padronização. Para agilizar ainda mais o
desenvolvimento de aplicações foi desenvolvida a ferramenta Adianti Studio Pro, uma
IDE para desenvolvimento de sistemas que automatiza a criação do código-fonte vol-
tado ao Adianti Framework, tornando muito mais ágil o desenvolvimento de novos
sistemas.
1 INTRODUÇÃO
CAPÍTULO 1
Introdução
Neste capítulo conheceremos a interface do Adianti Studio, bem como suas
funções básicas de edição.
1.1 Organização da interface
O Adianti Studio é uma IDE multiplataforma para desenvolvimento de sistemas que
conta com uma série de características, dentre as quais podem ser destacadas: auto-
complete para PHP e para os métodos de classes do projeto, sintaxe colorida, compa-
ração gráfica de arquivos, bookmarks, possibilidade de criação de plugins, integração
com subversion, dentre outras. Na figura a seguir podemos conferir a tela inicial do
AdiantiStudio Pro. Veja a seguir, o significado de cada item:
B Barra de ferramentas padrão: contém as principais funcionalidades da fer-
ramenta, tais como: novo, abrir, salvar, identar, aplicar plugin, sair, etc;
C Barra de ferramentas Adianti: contém as funções da versão “pro”, que agili-
zam o processo de criação de novas aplicações;
D Barra de plugins: disponibiliza os plugins criados na ferramenta para aplica-
ção rápida sobre o arquivo e/ou projeto que está aberto;
E Barra de favoritos: permite abrir rapidamente um arquivo favorito, bem
como acrescentar um arquivo na barra de favoritos;
F Árvore do projeto: área de navegação, onde são listadas as pastas e arquivos
do projeto para abertura. Na segunda aba, temos uma lista de métodos da
classe ativa; e na terceira, uma lista de bases de dados cadastradas;
G Área de edição: área de edição do arquivo, contendo uma aba por arquivo.
Adianti Studio Professional 8
Figura 1 Tela inicial do Adianti Studio Pro
1.2 Visão geral dos menus
Como pode ser visto na figura a seguir, no menu “Arquivo”, temos opções tradicionais
para a manipulação de arquivos. Na opção “Novo”, temos a possibilidade de criar um
arquivo vazio PHP, um novo “Projeto de desenvolvimento” genérico em PHP, ou uma
“Conexão de banco de dados”. Em seguida, temos opções como: “Abrir”, “Salvar” e
“Salvar como”. Neste menu, também temos a opção “Comparar”, que permite compa-
rar graficamente o arquivo aberto com um outro arquivo, “Exportar para PDF”, que
exporta o código-fonte em PDF e “Salvar Área de Trabalho”, que memoriza os arqui-
vos abertos.
Figura 2 Menu Arquivo do Adianti Studio Pro
Adianti Studio Professional 9
No menu “Editar” temos as opções tradicionais de edição, como “Desfazer”, “Refazer”,
“Recortar”, “Copiar” e “Colar”, bem como suas respectivas teclas de atalho. Também
temos as opções: “Apagar linha”, que exclui a linha atual; “Excluir modo colunas”, que
exclui blocos verticais de texto; “Mesclar linhas”, que mescla a linha atual com a se-
guinte; “Encontra chaves”, que encontra as chaves correspondentes; opções de co-
mentário de código e de indentação como: “Aumentar recuo” e “Diminuir o recuo”.
Figura 3 Menu Editar do Adianti Studio Pro
O menu “Procurar” disponibiliza opções como: “Localizar”, que localiza uma palavra
no arquivo; “Localizar próximo”, que localiza a próxima ocorrência; “Localizar ante-
rior”, que localiza a ocorrência anterior; “Localizar e substituir” que substitui as ocor-
rências de um termo. A opção “Localizar arquivos” localizará arquivos com determi-
nado nome e “Localizar em arquivos”, irá busca um termo nos arquivos do projeto.
Figura 4 Menu Procurar do Adianti Studio Pro
Adianti Studio Professional 10
O menu “Exibir” possui opções como: “Tela cheia”, que esconde algumas barras e co-
loca o editor ocupando toda a tela; “Árvore de arquivos”, que exibe/esconde a árvore
de arquivos; e várias opções utilizadas para exibir/esconder sua respectiva barra de
ferramentas como: “Barra de ferramentas”, “Barra de ferramentas Adianti”, “Barra de
plugins” e “Barra de favoritos”. Ainda temos opções para navegação entre abas.
Figura 5 Menu Exibir do Adianti Studio Pro
O menu “Ferramentas” possui opções como: “Preferências”, que permite configurar
as preferências do ambiente; “Projetos de desenvolvimento”, que cadastrará os proje-
tos a serem abertos na árvore de navegação; “Conexões de banco de dados”, que per-
mitirá cadastrarmos bases de dados para navegação. Também temos utilitários como
captura de cores, calendário, editor de anotações e um verificador de sintaxe, que
apontará possíveis erros antes da aplicação rodar em produção.
Figura 6 Menu Ferramentas do Adianti Studio Pro
Adianti Studio Professional 11
1.3 Preferências
Na janela de preferências, que pode ser vista na figura a seguir, podemos configurar
algumas características de uso do Adianti Studio. Na seção “Visualização”, pode-se
configurar: a exibição ou não da numeração em frente das linhas; o destaque ou não
do fundo da linha na qual está o cursor; o destaque de parêntesis correspondentes,
como em expressões lógicas; a exibição de uma linha representando a margem direi-
ta na edição; o idioma da interface, que é alterado após reinicialização do Studio; e
também a posição da árvore de arquivos (esquerda ou direita) em relação à área de
edição de arquivos.
Na seção “Editor”, podemos habilitar ou desabilitar itens como: indentação auto-
mática, que ocorre ao inicializarmos novas linhas após abertura de chaves; a inserção
de espaços em branco no lugar de tabulações; o autocomplete durante a digitação
(sem a necessidade de teclar CTRL+Space); e o fechamento automático de chaves
durante a abertura das mesmas. Além disso, é possível configurar a fonte do editor, o
tamanho das tabulações (em espaços), e a quantidade de níveis da opção “Desfazer”.
Na seção programas, é importante configurar o caminho onde o binário do PHP
está instalado. Este caminho é utilizado pela opção de verificação de sintaxe.
Figura 7 Janela de preferências do Adianti Studio Pro
1.4 Gerenciamento de projetos
Na janela de gerenciamento de projetos, que pode ser acessada por meio do menu
“Ferramentas”, podemos editar ou excluir os projetos de desenvolvimento existentes,
bem como criar novos. Como podemos ver na figura a seguir, inicialmente a janela
de projetos permite-nos listar os projetos existentes. A partir desta janela, pode-se cri-
Adianti Studio Professional 12
ar um projeto por meio do botão “Novo”; editar um projeto existente, por meio do
botão “Editar”; e excluir um projeto, por meio do botão “Excluir”. Ao criarmos um
projeto, deveremos preencher seu nome, sua localização e as pastas nas quais estão
localizadas as classes do sistema. O Studio utilizará estas pastas para varrer a estrutu-
ra do projeto e armazenar a sua estrutura em memória (banco de dados sqlite),
para permitir posterior autocomplete durante a digitação de métodos e classes.
Obs: O botão “Interpretar código” permite atualizar a estrutura do projeto (classes e méto-
dos) em memória. Esta estrutura também é salva após a alteração de um arquivo do projeto.
Entretanto, é importante atualizarmos a estrutura do projeto em memória com alterações re-
alizadas por outros desenvolvedores, com alguma periodicidade.
Figura 8 Janela de edição de projetos
Os projetos existentes podem ser acessados por meio da árvore de navegação, em
destaque na figura a seguir. Ao selecionarmos um projeto, seus arquivos e diretórios
são carregados na árvore para edição.
Figura 9 Menu de seleção de projetos
Adianti Studio Professional 13
1.5 Gerenciamento de bancos de dados
Na janela de gerenciamento de bancos de dados, que pode ser acessada por meio do
menu “Ferramentas”, podemos editar ou excluir conexões de bancos de dados. Como
podemos ver na figura a seguir, inicialmente a janela permite-nos listar os bancos de
dados existentes. A partir desta janela, pode-se criar uma conexão com um banco de
dados por meio do botão “Novo”, editar uma conexão existente por meio do botão
“Editar”, excluir uma conexão por meio do botão “Excluir”, ou testar a conexão com
um banco já cadastrado por meio do botão “Testar”. A seguir, podemos visualizar o
formulário de registro de uma nova conexão com a base de dados.
Figura 10 Janela de edição de bancos de dados
Os bancos de dados existentes são exibidos em uma lista na área de navegação (ter-
ceira aba). Após, selecionarmos uma base de dados a partir da lista, o Studio exibirá
as tabelas da base de dados na forma de uma lista para seleção.
Figura 11 Área de navegação de bancos de dados
Adianti Studio Professional 14
A partir do momento em que o usuário clicar sobre o nome de uma tabela, será
aberta uma janela de edição, como pode ser visto na figura a seguir. Nesta janela, po-
deremos realizar filtros sobre os registros da tabela, por meio do botão “Procurar”,
bem como editar os registros da tabela, simplesmente clicando sobre os mesmos.
Para que seja possível editarmos os registros de uma tabela, é precisoque a mesma
tenha as chaves primárias registradas no banco de dados. Também podemos excluir
registros, bem como criar registros na tabela.
Figura 12 Janela de navegação de tabela
2 CRIAÇÃO DO PROJETO
CAPÍTULO 2
Criação do Projeto
Neste capítulo abordaremos como se dá a criação de um projeto novo utili-
zando o Adianti Framework.
2.1 Visão geral
O Adianti Studio Pro adiciona um conjunto de funcionalidades em relação ao Adi-
anti Studio Standard. Estas funcionalidades são voltadas a dar maior agilidade no
desenvolvimento de aplicações desenvolvidas para o Adianti Framework. Na figura a
seguir, podemos ver em destaque a barra de ferramentas Adianti. Esta barra de ferra-
mentas contém algumas funcionalidades voltadas para agilizar a criação de aplica-
ções Adianti Framework. Dentre as funcionalidades, podem ser destacadas a geração
automática das classes de modelo e de páginas, baseadas em wizards.
Figura 13 Barra de ferramentas de geração de código no Adianti Studio Pro
Adianti Studio Professional 16
2.2 Cadastro do projeto
Para iniciar um novo projeto, podemos utilizar o menu “Projeto”, da barra de ferra-
mentas Adianti. Este menu possui as opções: “Novo Projeto Adianti”, que permite a
criação de um novo projeto de aplicação usando o Adianti Framework, e “Novo Pro-
jeto Genérico”, que permite a criação de um projeto qualquer em PHP. A opção “Ge-
renciar projetos” aciona a janela de gerenciamento (lista) de projetos.
Figura 14 Menu de opções para criação de novos projetos
Quando acessada a opção “Novo Projeto Adianti”, uma nova janela será exibida, tal
qual representada na próxima figura. Por meio dessa janela, podemos criar projetos
dentro do Studio. Para criar um projeto basta preencher seu nome, responder se dese-
ja copiar a estrutura do framework para dentro da pasta do projeto, escolher a base
de código para criação do projeto (Framework puro, Template 1, 2, 3 ou 4) e selecio-
nar a pasta do projeto (que poderá ser criada neste momento).
Figura 15 Janela de criação de novo projeto Adianti Framework
Obs: Você pode usar esse diálogo para registrar projetos já existentes. Nestes casos, basta des-
ligar a opção “Copiar estrutura do framework”.
Adianti Studio Professional 17
A partir da seleção da pasta, a ferramenta já sugere e preenche automaticamente o
campo “Pasta das classes”, com os caminhos padronizados, utilizados pelo Adianti
Framework. A partir deste momento, o Studio irá ler os diretórios do projeto para
“conhecer” a estrutura das classes envolvidas. Mesmo que no início só tenhamos
classes do framework, o Studio memorizará estas estruturas para autocomplete.
2.3 Cadastro da base de dados
A partir do momento em que criamos o projeto, o mesmo deverá ser exibido na lista
de projetos, localizada na área de navegação de arquivos. Então, é o momento regis-
trarmos uma base de dados existente. Conforme pode ser visto na figura a seguir, na
barra de ferramentas Adianti temos a opção “Registrar uma base de dados”, que nos
permite criar um arquivo de configuração para acessar uma base de dados existente.
Figura 16 Menu de opções para registro de uma nova base de dados
Ao acessarmos esta opção, será aberta uma janela com os parâmetros para conexão
com a base de dados. Basta preenchermos, escolhendo o tipo de banco de dados
(postgres, mysql, sqlite, etc.), ao final. No momento em que clicarmos sobre o botão
“Salvar”, será gerado um arquivo de conexão com a base de dados. Ao final, basta sal-
varmos o arquivo gerado na pasta app/config, com o nome desejado da conexão.
Figura 17 Janela para registro de um novo banco de dados
A seguir, o resultado gerado. É importante lembrar que o arquivo gerado deve ser sal-
vo na pasta app/config, com a extensão .ini, para ser acessado pela aplicação.
Adianti Studio Professional 18
app/config/teste.ini
host = 127.0.0.1
port = 5432 
name = exemplos 
user = postgres 
pass = teste 
type = pgsql 
Obs: É importante que o nome do arquivo de conexão com a base de dados tenha sentido,
uma vez que utilizaremos o mesmo dentro da aplicação, sempre que precisarmos abrir uma
transação com a base de dados.
2.4 Criação das classes modelo
Classes de modelo são classes que representam as entidades da aplicação. Analisando
de modo simplista, teremos uma classe de modelo para cada tabela. Mas isto não é
uma regra, visto que é comum uma classe gerenciar mais de uma tabela ao mesmo
tempo em relacionamentos como composição, agregação, e herança.
O Adianti Studio Pro permite a geração automática das classes de modelo da aplica-
ção por meio de um assistente. Este assistente pode ser acessado pela opção “Criar
classe para entidade”. Esta opção abre um assistente passo a passo que permite o
usuário gerar a classe de modelo de maneira automatizada, cadastrando os relacio-
namentos entre as classes por meio da interface. 
Figura 18 Menu de opções para criação de novo modelo a partir de assistente
Ao acionarmos a opção “Criar classe para entidade”, a janela do assistente será exibi-
da na tela. A partir desse momento, o usuário deverá selecionar a base de dados do
projeto sobre a qual ele deseja criar a classe, bem como a tabela que será manipulada
pela classe, a partir de uma lista de tabelas daquela base de dados. Então, deverá ser
selecionado qual o campo de chave primária (neste exemplo id), e definir o nome da
classe que será gerada (que é automaticamente recomendado).
Ao final, deverá ser selecionado o tipo de geração de chaves, o tipo de modelo (pa-
drão ou completo) e o padrão das chaves estrangeiras. O padrão das chaves estrangei-
ras define como serão nomeados os campos criados para relacionar as tabelas a par-
tir dos relacionamentos do modelo de classes. Já o gerador de chaves define como o
Adianti Studio Professional 19
campo de chave primária será incrementado, a partir de um novo registro. Neste caso,
temos duas opções:
❏ Max: obtém o último ID e incrementa em uma unidade;
❏ Serial: não informa o ID na inserção, deixando a base de dados utilizar o va-
lor default.
Figura 19 Assistente de geração de modelos – Definição de parâmetros
Após a primeira tela do assistente para criação de modelos, ao clicarmos no botão
“Próxima página” prosseguimos para a tela representada na figura a seguir. Nesta ja-
nela, podemos cadastrar vários relacionamentos entre a classe que estamos criando e
outras classes do sistema. Podemos registrar relacionamentos de Associação, Agrega-
ção e Composição entre as classes.
Figura 20 Assistente de geração de modelos – definição de relacionamentos
Adianti Studio Professional 20
A partir do momento em que cadastramos os relacionamentos entre as classes, pode-
mos clicar no botão “Salvar”. Assim, o Studio gerará o código-fonte completo da clas-
se modelo. No exemplo a seguir, foi copiada somente a estrutura dos métodos gera-
dos por esse exemplo, não o código completo. Neste caso, o Studio gerou métodos de
associação como set_category(), agregação como addSkill() e também sobre-
carregou métodos como store(), load(), e delete().
Estrutura da classe de modelo gerada
<?php 
class Book extends TRecord 
{ 
 const TABLENAME = 'book'; 
 const PRIMARYKEY= 'id'; 
 const IDPOLICY = 'max'; // {max, serial} 
 private $category; 
 private $skills; 
 private $contacts; 
 public function set_category(Category $object) 
 public function get_category() 
 public function addSkill(Skill $object) 
 public function getSkills() 
 public function addContact(Contact $object) 
 public function getContacts()
 public function load($id) 
 public function store() 
 public function delete($id = NULL) 
}
2.5 Conversão de UML para SQL
O Studio oferece uma ferramenta que cria o banco de dados automaticamente a par-
tir do modelo UML (formato XMI). Dentro do menu “Dados” da barra de ferramen-
tas Adianti, temos a opção “Converter UML para SQL”, que nos permite criar um
modelo relacional por meio da linguagem SQL, a partir de um modelo de classes.
Figura 21 Menu Converter UMLpara SQL
Adianti Studio Professional 21
Modelos de classe são armazenados em arquivos do tipo XMI (XML Metadata Inter-
change), que são arquivos XML utilizados para representar modelos de projeto de
software orientados a objetos. Arquivos XMI podem ser gerados por ferramentas de
modelagem conhecidas como: ArgoUML, Astah, Rational Rose, StarUML, Umbrello,
dentre outros. Na figura a seguir, temos a representação de um modelo de classes
dentro da ferramenta StarUML. Este modelo, pode ser exportado para o formato
XMI e posteriormente importando pelo Adianti Studio Pro para a criação da base.
Figura 22 Modelo de classes na ferramenta StarUML
A partir do momento em que clicamos sobre o botão “Converter UML para SQL” do
menu “Dados”, um diálogo de seleção de arquivos é aberto. Então, podemos selecio-
nar o arquivo no formato XMI para a criação do banco de dados, conforme pode ser
visto na figura a seguir.
Figura 23 Conversão do modelo XMI em SQL – Localização do arquivo
A partir do momento em que selecionamos o arquivo XMI e clicamos em “Abrir”,
uma nova janela será aberta. Nesta janela, podemos definir o padrão a ser utilizado
para a criação dos campos de chave estrangeira, cujo padrão é id_<class>. Além
Adianti Studio Professional 22
disso, selecionamos o tipo de banco de dados destino (PostgreSQL, MySQL, SQLite,
etc), bem como o tipo de chave primária gerada (MAX, SERIAL). A escolha do banco
de dados influenciará as instruções SQL geradas para a criação da base de dados
(CREATE TABLE), uma vez que cada banco de dados tem as suas peculiaridades. A
partir do preenchimento das definições, podemos clicar no botão “Próxima página”,
para seguir com o procedimento.
Figura 24 Conversão do modelo XMI em SQL – Configurações gerais
Na etapa seguinte, da importação do arquivo XMI, o Studio detecta as classes pre-
sentes no modelo e solicita quais desejamos importar para SQL.
Figura 25 Conversão do modelo XMI em SQL – Escolha das classes
Na etapa seguinte da importação do arquivo XMI, o Studio detecta os tipos de dados
do modelo de objetos e solicita o tipo correspondente no modelo SQL. Este mapea-
mento é importante, uma vez que no modelo orientado a objetos, os tipos de dados
são relativos à linguagem de programação, e não à base de dados. Nesta tela, algumas
sugestões são realizadas. Devemos ter certeza que a segunda coluna contenha tipos
de dados válidos para o banco de dados utilizado.
Adianti Studio Professional 23
Figura 26 Conversão do modelo XMI em SQL – Conversões de tipo
A partir do momento em que realizamos o correto mapeamento dos tipos de dados
encontrados no modelo de objetos em relação ao banco de dados, podemos clicar no
botão “Salvar”. A partir deste momento, o Studio gerará as instruções SQL necessárias
para criar a base de dados, conforme o modelo XMI. No arquivo a seguir, temos um
pequeno trecho representando um arquivo SQL, resultante deste processo.
Obs: O Studio gera todas as chaves primárias e estrangeiras, bem como tabelas associativas
necessárias para representar os relacionamentos do modelo orientado a objetos.
arquivo.sql
CREATE TABLE category( 
 id INTEGER PRIMARY KEY NOT NULL, 
 name TEXT );
CREATE TABLE city( 
 id INTEGER PRIMARY KEY NOT NULL, 
 name TEXT );
CREATE TABLE customer( 
 id INTEGER PRIMARY KEY NOT NULL, 
 name TEXT, 
 address TEXT, 
 phone TEXT, 
 birthdate DATE, 
 status CHAR(1), 
 email TEXT, 
 gender CHAR(1), 
 category_id INTEGER NOT NULL, 
 city_id INTEGER NOT NULL, 
 FOREIGN KEY(city_id) REFERENCES city(id), 
 FOREIGN KEY(category_id) REFERENCES category(id) 
);
...
Obs: A partir do momento em que temos as instruções SQL necessárias para criação do
banco de dados, basta rodar estas instruções no SGBD, ou mesmo na linha de comando por
meio de utilitários como: psql, mysql ou sqlite3.
Adianti Studio Professional 24
2.6 Conversão de UML para PHP
O Adianti Studio Pro permite também criar todo o código-fonte das classes de mode-
lo a partir de um modelo de classes UML no formato XMI. Para tal, basta utilizarmos
a opção “Converter UML para classes”, presente no menu “Dados” da barra de ferra-
mentas, como pode ser visto na figura a seguir.
Figura 27 Menu Converter UML para Classes
Conforme pode ser visto na figura a seguir, a partir do momento em que seleciona-
mos a opção “A partir de um modelo XMI”, um diálogo de seleção de arquivos será
aberto, para que possamos selecionar o arquivo XMI.
Figura 28 Geração do modelo a partir do XMI – Localização do arquivo
Após localizarmos o arquivo XMI, podemos clicar no botão Abrir. Neste momento,
uma nova janela será aberta, onde o usuário irá preencher basicamente as seguintes
opções:
❏ Gerador de chaves: se as classes utilizarão gerador max ou serial;
❏ Padrão de chave estrangeira: como é o padrão de nome para campos de
chave estrangeira que relacionam as tabelas no banco de dados;
❏ Tipo de modelo: código-fonte resumido (padrão) ou completo.
Adianti Studio Professional 25
Figura 29 Geração do modelo a partir do XMI – Definição de parâmetros
Em seguida, o Studio identificará quais são as classes presentes no modelo XMI e so-
licitar quais desejamos importar.
Figura 30 Geração do modelo a partir do XMI – Escolha das classes
A partir do momento em que clicamos no botão “Salvar”, o Studio procederá com a
leitura do arquivo XMI e, para cada classe nele encontrada, gerará um novo arquivo
de modelo. Se o arquivo XMI tiver várias classes, o Studio abrirá diversas abas em
memória com o conteúdo das classes modelo geradas.
O Studio gerará todo o código necessário para a persistência dos objetos em si, bem
como de seus relacionamentos. Para tal, serão criados métodos para associação, agre-
gação e composição de objetos. Além disso, métodos-padrão como: load(), dele-
te() e store() são sobrecarregados para persistir os relacionamentos juntamente
aos objetos. Após a geração das classes em memória, cada arquivo deve ser salvo indi-
vidualmente na pasta app/model.
Adianti Studio Professional 26
Figura 31 Geração do modelo a partir do XMI – Exemplo de código gerado
Obs: Caso o modelo de classes tenha outros métodos definidos pelo usuário, o Studio gera-
rá a estrutura básica (declaração) destes métodos, conforme o modelo.
3 CRIAÇÃO DE PÁGINAS
CAPÍTULO 3
Criação de Páginas
Neste capítulo abordaremos como se dá a criação de um alguns tipos co-
muns de página.
3.1 Páginas com HTML
Esta opção (menu Páginas Página com HTML) demonstra a criação de uma pági→ -
na com um conteúdo HTML definido por um arquivo externo. Neste caso, cabe ao
desenvolvedor definir o conteúdo do HTML no arquivo page.html. Este arquivo é
lido pela classe THtmlRenderer, cujas funcionalidades são demonstradas no tutor, e
no livro sobre o Framework. Cabe ainda ao desenvolvedor nomear a classe (Single-
PageView) e salvá-la com o mesmo nome da classe na pasta app/control, para ser
posteriormente acessada pela aplicação.
Arquivo gerado
<?php
class SinglePageView extends TPage
{
 public function __construct()
 {
 parent::__construct();
 
 // create the HTML Renderer
 $this->html = new THtmlRenderer('app/resources/page.html');
 
 // replace the main section variables
 $this->html->enableSection('main');
 
 parent::add($this->html);
 }
}
3.2 Páginas com PDF
Esta opção (menu Páginas Página com PDF) demonstra como embutir um PDF→
em uma página da aplicação. Quando acionada, solicitará ao desenvolvedor preen-
Adianti Studio Professional 28
cher a localização do documento em relação ao diretório principal da aplicação. Nes-
te caso, ele está no diretório app/documents.
Figura 32 Página com PDF
No arquivo gerado, o documento é embutido na página por meio da criação de um
objeto TElement para criar uma tag object. O caminho do PDF é definido pelo
atributo data. O objeto é então adicionado à página pelo método add(). Cabe ainda
ao desenvolvedor nomear a classe (EmbeddedPDFView) e salvá-la com o mesmo nome
da classe na pasta app/control,para ser posteriormente acessada pela aplicação.
Arquivo gerado
<?php
class EmbeddedPDFView extends TPage
{
 public function __construct()
 {
 parent::__construct();
 
 $object = new TElement('object');
 $object->data = 'app/documents/document.pdf';
 $object->type = 'application/pdf';
 $object->style = "width: 100%; height:600px";
 
 parent::add($object);
 }
}
3.3 Páginas com conteúdo externo
Esta opção (menu Páginas Página com conteúdo externo) demonstra como em→ -
butir um conteúdo externo (site, sistema) em uma página da aplicação. Quando acio-
nada, solicitará ao desenvolvedor preencher a localização do conteúdo externo (site,
sistema). Neste caso, foi utilizada uma página da Wikipedia.
Figura 33 Página com conteúdo externo
No arquivo gerado, o recurso externo é embutido na página por meio da criação de
um objeto TElement, que cria uma tag iframe. O caminho do recurso externo é de-
Adianti Studio Professional 29
finido pelo atributo src. O objeto $iframe é então adicionado à página pelo méto-
do add(). Cabe ainda ao desenvolvedor nomear a classe (ExternalPageView) e
salvá-la com o mesmo nome da classe na pasta app/control, para ser posteriormen-
te acessada pela aplicação.
Arquivo gerado
<?php
class ExternalPageView extends TPage
{
 public function __construct()
 {
 parent::__construct();
 
 $iframe = new TElement('iframe');
 $iframe->id = "iframe_external";
 $iframe->src = "https://pt.wikipedia.org/wiki/PHP";
 $iframe->frameborder = "0";
 $iframe->scrolling = "yes";
 $iframe->width = "100%";
 $iframe->height = "700px";
 
 parent::add($iframe);
 }
}
3.4 Janela com HTML
Este exemplo é uma variação do anterior (Página com HTML), que cria uma janela
(TWindow) para exibir um conteúdo HTML. Este conteúdo HTML é gerenciado pela
classe THtmlRenderer, amplamente explicada no tutor, e no livro do Framework.
Arquivo gerado
<?php
class ContainerWindowView extends TWindow
{
 private $form;
 
 function __construct()
 {
 parent::__construct();
 parent::setTitle('Window');
 parent::setSize(500, null); // use 0.6, 0.4 (for relative sizes 60%, 40%)
 
 $this->html = new THtmlRenderer('app/resources/page.html');
 $this->html->enableSection('main');
 
 parent::add($this->html);
 }
}
Obs: O método setSize() define o tamanho da janela. O tamanho pode ser definido em pi-
xels (500), em percentual (0.5), ou null para se auto ajustar ao conteúdo.
3.5 Janela com PDF
Este exemplo é uma variação do anterior (Página com PDF), que cria uma janela
(TWindow) para exibir um conteúdo PDF. Neste caso, foi criada uma janela de 80%
Adianti Studio Professional 30
de largura por 80% de altura (0.8,0.8), conforme pode ser visto na chamada do méto-
do setSize(). As demais características continuam iguais ao exemplo anterior.
Arquivo gerado
<?php
class WindowPDFView extends TWindow
{
 public function __construct()
 {
 parent::__construct();
 parent::setTitle('WindowPDFView');
 parent::setSize(0.8,0.8);
 
 $object = new TElement('object');
 $object->data = 'app/documents/document.pdf';
 $object->type = 'application/pdf';
 $object->style = "width: 100%; height:calc(100% - 10px)";
 
 parent::add($object);
 }
}
3.6 Janela com conteúdo externo
Esta opção (menu Páginas Janela com conteúdo externo), que cria uma janela→
(TWindow) para exibir um conteúdo externo (site ou sistema). Neste caso, foi criada
uma janela de 80% (0.8) de largura, com 650 pixels de altura para conter um iframe
com o recurso externo, que neste caso é a página do PHP na Wikipedia.
Arquivo gerado
class ExternalSystemWindowView extends TWindow
{
 public function __construct()
 {
 parent::__construct();
 parent::setTitle('ExternalSystemWindowView');
 parent::setSize(0.8, 650);
 
 $iframe = new TElement('iframe');
 $iframe->id = "iframe_external";
 $iframe->src = "https://pt.wikipedia.org/wiki/PHP";
 $iframe->frameborder = "0";
 $iframe->scrolling = "yes";
 $iframe->width = "100%";
 $iframe->height = "600px";
 
 parent::add($iframe);
 }
}
4 CRIAÇÃO DE FORMULÁRIOS
CAPÍTULO 4
Criação de Formulários
Neste capítulo abordaremos como se dá a criação de formulários de diversos
tipos (cadastro, consulta, mestre detalhe) no Adianti Framework.
4.1 Formulários de cadastro
O Adianti Studio Pro permite a criação de formulários com apenas alguns cliques,
por meio dos assistentes de criação de formulários. Como pode ser visto na figura a
seguir, por meio do menu “Formulários”, localizado na barra de ferramentas Adianti,
temos as opções para criação de formulários. Inicialmente criaremos um formulário,
por meio da primeira opção “Novo formulário de cadastro”. 
Figura 34 Menu para criação de formulário de cadastro
Ao acessarmos a opção “Novo formulário de cadastro”, o assistente será aberto. Nesta
primeira etapa, é necessário realizar algumas definições:
❏ Base de dados: base de dados que será utilizada pelo formulário;
Adianti Studio Professional 32
❏ Modelo: classe de modelo (TRecord) que representa a tabela que será mani-
pulada pelo formulário;
❏ Chave primária: definir qual é o campo de chave primária da tabela;
❏ Tipo de formulário: escolher o tipo de código gerado: completo: cria os mé-
todos (onEdit, onSave) declarados de maneira completa; padrão: utiliza
controladores padrão do framework (AdiantiStandardFormTrait);
❏ Classe pai: se o formulário será filho de TPage, ou de TWindow (abrirá em
uma nova janela).
❏ Nome do formulário: nome da classe de controle que será criada;
A figura a seguir, apresenta de maneira consolidada as definições necessárias para a
geração de um formulário de cadastro. A partir do momento em que todas definições
obrigatórias forem preenchidas, o botão “Próxima página” pode ser acionado, progre-
dindo para o próximo estágio da geração automática.
Figura 35 Formulários de cadastro – definição de propriedades
Obs: Sempre que for importante alterarmos o comportamento padrão do controlador é re-
comendado o “Formulário Completo”, pois neste caso, o código é gerado por completo, ou
seja, com todos os métodos expostos para alteração do programador.
Na etapa seguinte do assistente de criação de formulários, o Studio nos apresenta
uma lista com os campos daquela tabela, buscados diretamente a partir da base de
dados. Nesta tela, podemos confirmar os campos que farão parte do formulário, alte-
rar seus rótulos de apresentação em tela, o tamanho de cada campo, o componente
utilizado (TEntry, TDate, TText), bem como indicar se o campo é obrigatório ou
não. Caso algum campo não deva ser apresentado no formulário, podemos simples-
mente removê-lo desta listagem antes da geração do código. Para gerar o código da
página do formulário, basta clicarmos no botão “Salvar”.
Adianti Studio Professional 33
Figura 36 Formulários de cadastro – definição dos campos
A partir das definições realizadas no assistente de criação de formulário de cadastro,
podemos clicar no botão “Salvar” para gerar o código da página. A partir deste mo-
mento, o código do programa é gerado em memória, respeitando as definições reali-
zadas no assistente. Então, basta salvarmos o arquivo na pasta app/control ou em
algum subdiretório, com o nome da classe acrescido de .php, ou de .class.php.
Figura 37 Formulários de cadastro – código gerado
Na figura a seguir, temos a execução do código gerado. Alguns componentes são pré-
escolhidos, conforme o tipo de dados (Ex: Campos do date usam TDate), mesmo
assim, o usuário ainda pode alterar o componente utilizado para cada campo antes
da geração do código. O programa é totalmente funcional, e os métodos de salva-
mento e edição, bem como o de limpar formulário, já estão presentes.
Adianti Studio Professional34
Figura 38 Formulários de cadastro – programa em execução
4.2 Formulários de consulta
Além de automatizar o processo de criação de formulários de cadastro e edição, o
Studio também permite gerar formulários de consulta de registros. Um formulário
de consulta permite apenas a visualização de dados, não sua alteração. Um formulá-
rio de consultas utiliza um template em HTML e realiza simplesmente substituições
de variáveis por dados vindos do banco de dados. Como pode ser visto na figura a
seguir, por meio do menu “Formulários”, localizado na barra de ferramentas Adianti,
temos a opção para criação de formulários de consulta.
Figura 39 Menu para criação de formulário de consulta
Ao acessarmos a opção “Novo formulário de consulta”, o assistente será aberto. Nesta
primeira etapa, é necessário realizar algumas definições:
❏ Base de dados: base de dados que será utilizada pelo formulário;
❏ Modelo: classe de modelo (TRecord) que representa a tabela que será mani-
pulada pelo formulário;
❏ Chave primária: definir qual é o campo de chave primária da tabela;
❏ Nome do formulário: nome da classe de controle que será criada;
❏ Nome do formulário de edição: classe utilizada para edição dos dados.
Adianti Studio Professional 35
A figura a seguir, apresenta de maneira consolidada as definições necessárias para a
geração de um formulário de consulta. A partir do momento em que todas defini-
ções obrigatórias forem preenchidas, o botão “Próxima página” pode ser acionado,
progredindo para o próximo estágio da geração automática.
Figura 40 Formulários de consulta – definição de propriedades
Na etapa seguinte do assistente de criação de formulários de consulta, o Studio nos
apresenta uma lista com os campos daquela tabela, buscados diretamente a partir da
base de dados. Nesta tela, podemos confirmar os campos que farão parte do formu-
lário de consulta, e alterar os seus rótulos de apresentação em tela. Caso algum cam-
po não deva ser apresentado no formulário de consulta, podemos simplesmente re-
movê-lo desta listagem, antes da geração do código. Para gerar o código da página do
formulário, basta clicarmos no botão “Salvar”.
Figura 41 Formulários de consulta – definição de campos
Adianti Studio Professional 36
Após clicarmos no botão “Salvar”, o código para o formulário é gerado em memória
conforme as definições realizadas. Na figura a seguir, podemos ver um exemplo de
geração de formulário. Neste ponto, basta salvarmos a nova página criada dentro da
pasta app/control. Note que além da classe em si (ProductFormView), também foi
gerado um arquivo de template (productformview.html), que será utilizado para a
apresentação dos dados. O Studio tentará salvar automaticamente o arquivo de tem-
plate na pasta app/resources com um nome padronizado.
Figura 42 Criação de formulários de consulta – código gerado
Na figura a seguir temos a execução do código gerado. O programa é totalmente fun-
cional, porém o conteúdo somente será exibido se a URL acionar o método correto
(index.php?class=ProductFormView&method=onEdit&id=1).
Figura 43 Formulários de consulta – programa em execução
4.3 Formulários de cadastro auxiliar
Além de criar páginas com formulários, também podemos criar páginas com formu-
lários e listagens atuando conjuntamente. Esta abordagem pode ser acessada pela
opção “Novo formulário de cadastro auxiliar” no menu “Formulários”.
Adianti Studio Professional 37
Figura 44 Menu para criação de formulário de cadastro auxiliar
Em uma página deste tipo, a datagrid é usada para apresentar os registros e o formu-
lário para editar os registros da datagrid. Esta abordagem pode ser utilizada para ta-
belas, contendo poucos registros, uma vez que não oferece busca de registros, e o for-
mulário presente na página é utilizado para edição, não para buscas.
Ao acessarmos a opção “Novo formulário de cadastro auxiliar”, o assistente será aber-
to. Nesta primeira etapa, é necessário realizar algumas definições:
❏ Base de dados: base de dados que será utilizada pelo formulário;
❏ Modelo: classe de modelo (TRecord) que representa a tabela que será mani-
pulada pelo formulário;
❏ Chave primária: definir qual é o campo de chave primária da tabela;
❏ Tipo de formulário: escolher o tipo de código gerado: Completo: cria os
métodos (onEdit, onSave) declarados de maneira completa; Padrão: utiliza
controladores padrão do framework (AdiantiStandardFormListTrait);
❏ Classe pai: se o formulário será filho de TPage, ou de TWindow (abrirá em
uma nova janela).
❏ Nome do formulário: nome da classe de controle que será criada.
A figura a seguir apresenta de maneira consolidada as definições necessárias para a
geração de um formulário de cadastro auxiliar. A partir do momento em que todas
definições obrigatórias forem preenchidas, o botão “Próxima página” pode ser acio-
nado, progredindo para o próximo estágio da geração automática.
Adianti Studio Professional 38
Figura 45 Formulário de cadastro auxiliar – definição de propriedades
Na próxima etapa, o Studio carregará os campos da tabela escolhida. Nesta janela,
podemos definir quais serão os campos manipulados pelo formulário e apresenta-
dos pela datagrid. Nesta listagem, podemos definir o nome dos campos, seu rótulo,
tamanho, componente para manipulação do campo e também sua obrigatoriedade.
Figura 46 Formulário de cadastro auxiliar – definição de campos
A partir das definições realizadas no assistente de criação de formulário de cadastro
auxiliar, podemos clicar no botão “Salvar” para gerar o código da página. A partir
deste momento, o código do programa é gerado em memória, respeitando as defini-
ções realizadas no assistente. Então, basta salvarmos o arquivo na pasta app/control
ou em algum subdiretório, com o nome da classe acrescido de .php, ou de
.class.php.
Adianti Studio Professional 39
Figura 47 Formulário de cadastro auxiliar – código gerado
Na figura a seguir, temos a execução do programa gerado pelo assistente de criação
de formulário de cadastro auxiliar. Veja que a página possui um formulário para a
edição dos dados acima, e a datagrid para listagem abaixo. Sempre que o usuário cli-
car no botão editar, os dados são carregados no formulário. A datagrid ainda possui a
funcionalidade para excluir um registro.
Figura 48 Formulário de cadastro auxiliar – programa em execução
4.4 Formulário vetorial
O Adianti Studio Pro permite a criação de formulários vetoriais, que nada mais são
do que formulários com campos criados em forma de vetor, possibilitando a inserção
de vários registros de uma só vez. Como pode ser visto na figura a seguir, por meio
do menu “Formulários”, localizado na barra de ferramentas Adianti, temos a opção
“Novo formulário vetorial”.
Adianti Studio Professional 40
Figura 49 Menu para criação de formulário vetorial
Ao acessarmos a opção “Novo formulário vetorial”, o assistente será aberto. Nesta pri-
meira etapa, é necessário realizar algumas definições:
❏ Base de dados: base de dados que será utilizada pelo formulário;
❏ Modelo: classe de modelo (TRecord) que representa a tabela que será mani-
pulada pelo formulário;
❏ Chave primária: definir qual é o campo de chave primária da tabela;
❏ Classe pai: se o formulário será filho de TPage, ou de TWindow (abrirá em
uma nova janela).
❏ Nome do formulário: nome da classe de controle que será criada;
A figura a seguir, apresenta de maneira consolidada as definições necessárias para a
geração de um formulário vetorial. A partir do momento em que todas definições
obrigatórias forem preenchidas, o botão “Próxima página” pode ser acionado, progre-
dindo para o próximo estágio da geração automática.
Figura 50 Formulário vetorial– definição de propriedades
Na etapa seguinte do assistente de criação de formulários vetoriais, o Studio nos
apresenta uma lista com os campos da tabela, buscados diretamente a partir da base
Adianti Studio Professional 41
de dados. Nesta tela, podemos confirmar os campos que farão parte do formulário,
alterar seus rótulos de apresentaçãoem tela, o tamanho de cada campo, o compo-
nente utilizado (TEntry, TDate, TText), etc.
Figura 51 Formulário vetorial– definição de campos
A partir das definições realizadas no assistente de criação de formulário vetorial, po-
demos clicar no botão “Salvar” para gerar o código da página. A partir deste momen-
to, o código do programa é gerado em memória, respeitando as definições realizadas
no assistente. Então, basta salvarmos o arquivo na pasta app/control ou em algum
subdiretório, com o nome da classe acrescido de .php, ou de .class.php.
Figura 52 Formulário vetorial– código gerado
Na figura a seguir, temos a execução do código gerado. O programa é totalmente
funcional, sendo que o formulário permite o cadastramento vários produtos de uma
só vez. Para acionar o formulário, basta acessar index.php?class=ProductForm.
Adianti Studio Professional 42
Figura 53 Formulário vetorial– execução
4.5 Formulário mestre/detalhe
O Adianti Studio Pro permite a criação de formulários de edição mestre/detalhe por
meio dos assistentes de criação de páginas. Como pode ser visto na figura a seguir,
por meio do menu “Formulários”, localizado na barra de ferramentas Adianti, temos
a opção “Novo formulário mestre/detalhe”.
Figura 54 Menu para criação de formulário mestre/detalhe
Ao acessarmos a opção “Novo formulário mestre/detalhe”, o assistente será aberto.
Nesta primeira etapa, é necessário realizar algumas definições:
❏ Base de dados: base de dados que será utilizada pelo formulário;
❏ Modelo mestre: classe de modelo (TRecord) que representa a tabela que
será manipulada pelo formulário como registro mestre;
❏ Chave primária mestre: definir o campo chave primária da tabela mestre;
❏ Modelo detalhe: classe de modelo (TRecord) que representa a tabela que
será manipulada pelo formulário como registro detalhe;
❏ Chave primária detalhe: definir o campo chave primária da tabela detalhe;
❏ Campo de ligação: definir qual é a chave estrangeira da tabela de detalhe
que estabelece o vínculo com a tabela mestre;
❏ Nome do formulário: nome da classe de controle que será criada.
A figura a seguir, apresenta de maneira consolidada as definições necessárias para a
geração de um formulário mestre/detalhe. A partir do momento em que todas defini-
ções obrigatórias forem preenchidas, o botão “Próxima página” pode ser acionado,
progredindo para o próximo estágio da geração automática.
Adianti Studio Professional 43
Figura 55 Formulário mestre/detalhe– definição de propriedades
Na etapa seguinte do assistente de criação de formulários mestre/detalhe, o Studio
nos apresenta uma lista com os campos da tabela mestre, buscados diretamente a
partir da base de dados. Nesta tela, podemos confirmar os campos que farão parte
do formulário mestre, alterar seus rótulos de apresentação em tela, o tamanho de
cada campo, o componente utilizado (TEntry, TDate, TText), bem como indicar se o
campo é obrigatório ou não.
Figura 56 Formulário mestre/detalhe– definição dos campos mestre
Na etapa seguinte do assistente de criação de formulários mestre/detalhe, o Studio
nos apresenta uma lista com os campos da tabela detalhe, buscados diretamente a
partir da base de dados. Nesta tela, podemos confirmar os campos que farão parte
do formulário detalhe, alterar seus rótulos de apresentação em tela, o tamanho de
cada campo, o componente utilizado (TEntry, TDate, TText), bem como indicar se o
campo é obrigatório ou não.
Adianti Studio Professional 44
Figura 57 Formulário mestre/detalhe– definição dos campos detalhe
A partir das definições realizadas no assistente de criação de formulário mestre/deta-
lhe, podemos clicar no botão “Salvar” para gerar o código da página. A partir deste
momento, o código do programa é gerado em memória, respeitando as definições re-
alizadas no assistente. Então, basta salvarmos o arquivo na pasta app/control ou
em algum subdiretório, com o nome da classe acrescido de .php, ou de .class.php.
Figura 58 Formulário mestre/detalhe– código gerado
Na figura a seguir, temos a execução do código gerado. O programa é totalmente
funcional, sendo que o formulário permite o cadastramento de vendas (registro mes-
tre), bem como os seus itens (registro detalhe). O formulário também permite a edi-
ção de registros de vendas, sendo que neste caso, os registros de detalhe também se-
rão carregados para edição. Para acionar a edição da venda, basta acessar in-
dex.php?class=SaleForm&method=onEdit&key=1. A listagem de itens possui funci-
onalidades de edição e exclusão de itens.
Adianti Studio Professional 45
Figura 59 Formulário mestre/detalhe – programa em execução
4.6 Formulário consulta mestre/detalhe
O Adianti Studio Pro permite a criação de formulários de consulta mestre/detalhe
por meio dos assistentes de criação de páginas. Como pode ser visto na figura a se-
guir, por meio do menu “Formulários”, localizado na barra de ferramentas Adianti,
temos a opção “Novo formulário consulta mestre/detalhe”. Um formulário de con-
sulta mestre/detalhe apresenta um registro mestre e seus vários registros detalhe, po-
rém sem permitir a sua edição. Pode ser muito útil como ação imediata de detalha-
mento de registros em uma datagrid. A partir do formulário de consulta, pode ser
acionado o formulário de edição mestre/detalhe, apresentado anteriormente.
Adianti Studio Professional 46
Figura 60 Menu para criação de formulário consulta mestre/detalhe
Ao acessarmos a opção “Novo formulário consulta mestre/detalhe”, o assistente será
aberto. Nesta primeira etapa, é necessário realizar algumas definições:
❏ Base de dados: base de dados que será utilizada pelo formulário;
❏ Modelo mestre: classe de modelo (TRecord) que representa a tabela que
será manipulada pelo formulário como registro mestre;
❏ Chave primária mestre: definir o campo chave primária da tabela mestre;
❏ Modelo detalhe: classe de modelo (TRecord) que representa a tabela que
será manipulada pelo formulário como registro detalhe;
❏ Chave primária detalhe: definir o campo chave primária da tabela detalhe;
❏ Campo de ligação: definir qual é a chave estrangeira da tabela de detalhe
que estabelece o vínculo com a tabela mestre;
❏ Nome do formulário: nome da classe de controle que será criada.
A figura a seguir, apresenta de maneira consolidada as definições necessárias para a
geração de um formulário consulta mestre/detalhe. A partir do momento em que to-
das definições obrigatórias forem preenchidas, o botão “Próxima página” pode ser
acionado, progredindo para o próximo estágio da geração automática.
Figura 61 Formulário consulta mestre/detalhe– definição de propriedades
Adianti Studio Professional 47
Na etapa seguinte do assistente de criação de formulários consulta mestre/detalhe, o
Studio nos apresenta uma lista com os campos da tabela mestre, buscados direta-
mente a partir da base de dados. Nesta tela, podemos confirmar os campos que farão
parte do formulário mestre, e alterar seus rótulos de apresentação em tela.
Figura 62 Formulário consulta mestre/detalhe– definição dos campos mestre
Na etapa seguinte do assistente de criação de formulários consulta mestre/detalhe, o
Studio nos apresenta uma lista com os campos da tabela detalhe, buscados direta-
mente a partir da base de dados. Nesta tela, podemos confirmar os campos que farão
parte do formulário detalhe, e alterar seus rótulos de apresentação em tela.
Figura 63 Formulário consulta mestre/detalhe– definição dos campos detalhe
Adianti Studio Professional 48
A partir das definições realizadas no assistente de criação de formulário consulta
mestre/detalhe, podemos clicar no botão “Salvar” para gerar o código da página. A
partir deste momento, o código do programa é gerado em memória, respeitando as
definições realizadas. Então, basta salvarmos o arquivo na pasta app/control ou em
algum subdiretório, com o nome da classe acrescido de .php, ou de .class.php.
Figura 64 Formulário consulta mestre/detalhe– código gerado
Na figura a seguir, temos a execução do código gerado. O programa étotalmente
funcional, sendo que o formulário permite a consulta de vendas (registro mestre),
bem como os seus itens (registro detalhe). Para consulta a edição da venda, basta
acessar index.php?class=SaleFormView&method=onEdit&key=1.
Figura 65 Formulário consulta mestre/detalhe – programa em execução
5 CRIAÇÃO DE LISTAGENS
CAPÍTULO 5
Criação de Listagens
Neste capítulo abordaremos como se dá a criação de listagens no Adianti Fra-
mework.
5.1 Listagens de registros
Além de automatizar o processo de criação de formulários, podemos também criar
listagens de maneira ágil. Por meio da opção “Nova listagem de registros”, presente no
menu “Listagens” da barra de ferramentas Adianti.
As listagens geradas por meio do assistente são totalmente funcionais e apresentam
funções como: edição de registros (redirecionamento para formulário); exclusão de
registros; ordenamento de campos, filtragem e paginação.
Figura 66 Menu para criação de listagem de consulta
Ao acessarmos a opção “Nova listagem de registros”, o assistente será aberto. Nesta
primeira etapa, é necessário realizar algumas definições:
❏ Base de dados: base de dados que será utilizada pela listagem;
❏ Modelo: classe de modelo (TRecord) que representa a tabela que será mani-
pulada pela listagem;
Adianti Studio Professional 50
❏ Chave primária: definir qual é o campo de chave primária da tabela;
❏ Tipo de lista: escolher o tipo de código gerado: Completo: cria os métodos
(onDelete, onReload) declarados de maneira completa; Padrão: utiliza
controladores padrão do framework (AdiantiStandardListTrait);
❏ Ação de exclusão: se a listagem terá exclusão individual de registros, em lote,
om ambos os tipos;
❏ Nome da lista: nome da classe de controle que será criada;
❏ Ação de edição: formulário de edição, com o qual a listagem estará vincula-
da. Você pode apontar para um formulário de consulta de registros também.
A figura a seguir, apresenta de maneira consolidada as definições necessárias para ge-
ração de uma listagem de registros. A partir do momento em que todas definições
obrigatórias forem preenchidas, o botão “Próxima página” pode ser acionado, progre-
dindo para o próximo estágio da geração automática.
Figura 67 Listagem de registros – definição de propriedades
Após as definições da primeira etapa do assistente de criação de listagens, é exibida a
etapa de definição de colunas. Na segunda etapa, que pode ser vista na próxima figu-
ra, são exibidas as colunas da tabela escolhida, lidas diretamente a partir da tabela
da base de dados.
Na listagem de campos devemos excluir as colunas que não desejamos que sejam
exibidas na datagrid. Para as colunas que serão exibidas, devemos definir o seu rótu-
lo correto (título da coluna), o alinhamento da coluna (esquerda, centro, direita), se a
coluna é ordenável, se a coluna é editável (edição inline), e se ela possui um modifi-
cador (Ex: formatação de data, exibir como imagem, exibir como valor monetário,
exibir como barra de progresso, exibir como maiúsculo).
Adianti Studio Professional 51
Figura 68 Listagem de registros – definição de colunas
Após a definição de quais colunas farão parte da listagem, surge o momento de defi-
nir quais serão os campos utilizados para a filtragem da mesma, bem como quais os
operadores (=, like) serão utilizados para cada campo. Nesta tela, basta eliminarmos
quais campos não desejamos utilizar como filtro, e para cada campo utilizado, alterar
o seu operador. 
Figura 69 Listagem de registros – definição de filtros
A partir das definições realizadas no assistente de criação da listagem de registros,
podemos clicar no botão “Salvar”, para gerar o código da página. A partir deste mo-
mento, o código do programa é gerado em memória, respeitando as definições reali-
zadas no assistente. Então, basta salvarmos o arquivo na pasta app/control ou em
algum subdiretório, com o nome da classe acrescido de .php, ou de .class.php.
Adianti Studio Professional 52
Figura 70 Listagem de registros – código gerado
Na figura a seguir, temos a execução do programa gerado pelo assistente de criação
de listagens. Veja que a página possui um formulário de buscas com o campo que in-
dicamos na primeira etapa do assistente. A listagem é gerada com as opções de edi-
ção (que redireciona para a página de formulário) e exclusão. Além disso, as colunas
configuradas para serem ordenadas possuem este recurso, bastando clicar sobre o tí-
tulo da coluna, sendo que também é criado um navegador de páginas.
Figura 71 Listagem de registros – programa em execução
5.2 Relatório tabular
O Adianti Studio Pro permite a criação de relatórios tabulares com apenas alguns cli-
ques, por meio dos assistentes de criação de páginas. Como pode ser visto na figura a
Adianti Studio Professional 53
seguir, por meio do menu “Listagens”, localizado na barra de ferramentas Adianti, te-
mos a opção “Novo relatório tabular”.
Figura 72 Menu para criação de relatório tabular
Ao acessarmos a opção “Novo relatório tabular”, o assistente será aberto. Nesta pri-
meira etapa, é necessário realizar algumas definições:
❏ Base de dados: base de dados que será utilizada pelo relatório;
❏ Modelo: classe de modelo (TRecord) que representa a tabela que será mani-
pulada pelo relatório;
❏ Estilo de relatório: escala de cores utilizada (cinza, azul, vermelho);
❏ Nome do formulário: nome da classe de controle que será criada.
A figura a seguir, apresenta de maneira consolidada as definições necessárias para a
geração de um relatório tabular. A partir do momento em que todas definições obri-
gatórias forem preenchidas, o botão “Próxima página” pode ser acionado, progredin-
do para o próximo estágio da geração automática.
Figura 73 Relatório – definição de propriedades
Na etapa seguinte do assistente, o Studio nos apresenta uma lista com os campos da-
quela tabela, buscados diretamente a partir da base de dados. Nesta tela, podemos
confirmar os campos que farão parte do relatório, alterar seus rótulos de apresenta-
ção em tela, o tamanho de cada campo, bem como o alinhamento
Adianti Studio Professional 54
Figura 74 Relatório – definição das colunas
Após a definição de quais colunas farão parte do relatório, surge o momento de defi-
nir quais serão os campos utilizados para a filtragem do mesmo, bem como quais os
operadores (=, like) serão utilizados para cada campo. Nesta tela, basta eliminarmos
quais campos não desejamos utilizar como filtro, e para cada campo utilizado, alterar
o seu operador. 
Figura 75 Relatório – definição dos filtros
A partir das definições realizadas no assistente de criação de relatórios, podemos cli-
car no botão “Salvar”, para gerar o código da página. A partir deste momento, o códi-
go do programa é gerado em memória, respeitando as definições realizadas no assis-
tente. Então, basta salvarmos o arquivo na pasta app/control ou em algum subdire-
tório, com o nome da classe acrescido de .php, ou de .class.php.
Adianti Studio Professional 55
Figura 76 Relatório – código gerado
Na figura a seguir, temos a execução do código gerado. O programa é totalmente
funcional, sendo que o botão de geração criará o relatório no formato solicitado, con-
forme os parâmetros de filtro informados no formulário.
Figura 77 Relatório tabular – programa em execução
5.3 Lista de seleção de registros
O Adianti Studio Pro permite a criação de listas de seleção de registros com apenas
alguns cliques, por meio dos assistentes de criação de páginas. Como pode ser visto
na figura a seguir, por meio do menu “Listagens”, localizado na barra de ferramentas
Adianti, temos a opção “Nova lista de seleção de registros”. Uma lista de seleção de
registros permite que o usuário localize e selecione um conjunto de registros para re-
alizar alguma ação posterior. No código-fonte gerado, o programa irá, ao final, exibir
os registros selecionados ao usuário.
Adianti Studio Professional 56
Figura 78 Menu para criação de lista de seleção de registros
Ao acessarmos a opção “Nova lista de seleção deregistros”, o assistente será aberto.
Nesta primeira etapa, é necessário realizar algumas definições:
❏ Base de dados: base de dados que será utilizada pela lista;
❏ Modelo: classe de modelo (TRecord) que representa a tabela que será mani-
pulada pela lista;
❏ Chave primária: definir qual é o campo de chave primária da tabela;
❏ Nome da lista: nome da classe de controle que será criada.
A figura a seguir, apresenta de maneira consolidada as definições necessárias para a
geração de uma lista de seleção de registros. A partir do momento em que todas defi-
nições obrigatórias forem preenchidas, o botão “Próxima página” pode ser acionado,
progredindo para o próximo estágio da geração automática.
Figura 79 Lista de seleção de registros – definição de propriedades
Após as definições da primeira etapa do assistente de criação de listas de seleção, é
exibida a etapa de definição de colunas. Na segunda etapa, que pode ser vista na
próxima figura, são exibidas as colunas da tabela escolhida, lidas diretamente a par-
tir da tabela da base de dados. Na listagem de campos devemos excluir as colunas
que não desejamos que sejam exibidas na lista. Para as colunas que serão exibidas,
Adianti Studio Professional 57
devemos definir o seu rótulo correto (título da coluna), o alinhamento da coluna (es-
querda, centro, direita), se a coluna é ordenável, e se a coluna é editável (inline).
Figura 80 Lista de seleção de registros– definição dos campos
Após a definição de quais colunas farão parte da listagem, é necessário definir quais
serão os campos utilizados para a filtragem da mesma, bem como quais os operado-
res (=, like) serão utilizados para cada campo. Nesta tela, basta eliminarmos quais
campos não desejamos utilizar como filtro, e para cada campo, escolher o operador. 
Figura 81 Lista de seleção de registros– definição dos filtros
A partir das definições realizadas no assistente de criação de lista de seleção de regis-
tros, podemos clicar no botão “Salvar” para gerar o código da página. A partir deste
momento, o código do programa é gerado em memória, respeitando as definições re-
alizadas no assistente. Então, basta salvarmos o arquivo na pasta app/control ou
em algum subdiretório, com o nome da classe acrescido de .php, ou de .class.php.
Adianti Studio Professional 58
Figura 82 Lista de seleção de registros– código gerado
Na figura a seguir, temos a execução do código gerado. O programa é totalmente
funcional, e permite a localização de registros por meio do formulário superior. Na
medida em que o usuário clica sobre os registros, estará selecionando-os. Os registros
selecionados ficam armazenados na sessão. Quando o usuário clicar no botão para
mostrar resultados, será aberta uma nova janela contendo os registros selecionados. A
ação desta fase final pode facilmente ser alterada pelo usuário para que o programa
execute uma outra ação, no lugar de exibir os registros selecionados.
Figura 83 Lista de seleção de registros– programa em execução
5.4 Lista de edição de registros
O Adianti Studio Pro permite a criação de listas de edição de registros com apenas al-
guns cliques, por meio dos assistentes de criação de páginas. Como pode ser visto na
figura a seguir, por meio do menu “Listagens”, localizado na barra de ferramentas
Adianti, temos a opção “Nova lista de edição de registros”. Uma lista de edição de re-
Adianti Studio Professional 59
gistros permite que o usuário edite registros diretamente na datagrid, por meio de al-
gum componente de entrada de dados (Ex: TEntry).
Figura 84 Menu para criação de lista de edição de registros
Ao acessarmos a opção “Nova lista de edição de registros”, o assistente será aberto.
Nesta primeira etapa são necessárias algumas definições:
❏ Base de dados: base de dados que será utilizada pela lista;
❏ Modelo: classe de modelo (TRecord) que representa a tabela que será mani-
pulada pela lista;
❏ Chave primária: definir qual é o campo de chave primária da tabela;
❏ Nome da lista: nome da classe de controle que será criada;
❏ Campo de edição: campo que será editado diretamente na datagrid;
❏ Componente: componente que será utilizado para edição do campo.
A figura a seguir, apresenta de maneira consolidada as definições necessárias para a
geração de uma lista de edição de registros. A partir do momento em que todas defi-
nições obrigatórias forem preenchidas, o botão “Próxima página” pode ser acionado,
progredindo para o próximo estágio da geração automática.
Adianti Studio Professional 60
Figura 85 Lista de edição de registros – definição de propriedades
Após as definições da primeira etapa do assistente, é exibida a etapa de definição de
colunas. Na segunda etapa, que pode ser vista na próxima figura, são exibidas as co-
lunas da tabela escolhida, lidas diretamente a partir da tabela da base de dados. Na
listagem de campos, devemos excluir as colunas que não desejamos que sejam exibi-
das na lista de edição. Para as colunas que serão exibidas, devemos definir o seu ró-
tulo correto (título da coluna), o alinhamento da coluna (esquerda, centro, direita), se
a coluna é ordenável, e se a coluna é editável (inline).
Figura 86 Lista de edição de registros– definição dos campos
Adianti Studio Professional 61
Após a definição de quais colunas farão parte da listagem, surge o momento de defi-
nir quais serão os campos utilizados para a filtragem da mesma, bem como quais os
operadores (=, like) serão utilizados para cada campo. Nesta tela, basta eliminarmos
quais campos não serão utilizados como filtro, e para cada campo, definir o operador.
Figura 87 Lista de edição de registros– definição dos filtros
A partir das definições realizadas no assistente de criação de lista de edição de regis-
tros, podemos clicar no botão “Salvar” para gerar o código da página. A partir deste
momento, o código do programa é gerado em memória, respeitando as definições re-
alizadas no assistente. Então, basta salvarmos o arquivo na pasta app/control ou
em algum subdiretório, com o nome da classe acrescido de .php, ou de .class.php.
Figura 88 Lista de edição de registros– código gerado
Adianti Studio Professional 62
Na figura a seguir, temos a execução do código gerado. O programa é totalmente
funcional, e permite a localização de registros por meio do formulário superior. A
partir do filtro realizado, será montada uma datagrid com um campo editável. Para a
coluna selecionada para edição (preço neste caso), será exibido o componente esco-
lhido em cada uma das linhas da datagrid (Ex: TEntry). A alteração na base de da-
dos é realizada no momento em que o botão de salvar é acionado.
Figura 89 Lista de edição de registros– programa em execução
6 REST SERVICES
CAPÍTULO 6
REST Services
Neste capítulo aprenderemos a construir um serviço REST no Adianti Fra-
mework.
6.1 Habilitando o servidor REST
Uma aplicação baseada no Template, já acompanha o arquivo rest.php.dist no di-
retório raiz. Para habilitar o servidor REST, basta renomear o arquivo para rest.php.
O servidor REST estará habilitado.
Obs: Aqui não trataremos da implementação da segurança das requisições, não deixe de
acompanhar o livro sobre o Framework e também nosso fórum para artigos sobre isto.
6.2 Criando uma classe de serviço REST
O Adianti Studio oferece a funcionalidade de criar uma classe de serviço REST, que é
uma classe que disponibiliza funções de uma classe de modelo (Active Record) para
o mundo externo. Para criar uma classe de serviço REST, podemos acionar o menu
“REST”, opção “Nova classe de serviço”. 
Figura 90 REST – nova classe de serviço
Adianti Studio Professional 64
Na próxima etapa, o Studio solicitará a base de dados e a classe de modelo sobre a
qual o serviço REST será construído.
Figura 91 REST – parâmetros da classe de serviço
A partir das seleções realizadas, é gerada uma classe para serviço REST. Esta classe
possui, em seu início, a definição da base de dados, e da classe de modelo que serão
servidas. Você perceberá que não há código fonte nesta classe, apenascomentários.
Estes comentários explicam quais são os métodos disponíveis, que por sua vez são
herdados da classe pai AdiantiRecordService.
Figura 92 REST – código da classe de serviço
6.3 Consumindo um serviço REST
Para consumir um serviço REST, é necessário conhecer a API. Para simplificar este
processo, o Studio gera também um arquivo contendo exemplos de chamadas REST.
São chamadas que vão explicam desde a manipulação de registros individuais ou co-
leção de registros.
Figura 93 REST – geração de código cliente
Adianti Studio Professional 65
Ao selecionar a opção para geração de código de exemplo REST, o Studio solicitará a
URL em que o sistema está rodando, bem como a classe de modelo.
Figura 94 REST – parâmetros para geração de código cliente
A partir da seleção realizada, será gerado o código-fonte com exemplos de chamada
REST para várias operações como: carregar registro, salvar registro, alterar registro, ex-
cluir registro, carregar vários registros baseado em um filtro, e excluir vários registros
baseado em um filtro.
Figura 95 REST – código cliente gerado
7 STUDIO FORM DESIGNER
CAPÍTULO 7
Studio Form Designer
Neste capítulo conheceremos a ferramenta de desenho de formulários do
Adianti Studio.
7.1 Visão Geral
Não bastasse as facilidades geradas pelos assistentes de criação de páginas, o Studio
Pro disponibiliza o Studio Form Designer, uma ferramenta voltada para o desenho
de interfaces para o Adianti Framework, que pode ser acessado por meio do botão
“Form Designer” da barra de ferramentas Adianti, como pode ser visto na figura a se-
guir.
Figura 96 Botão para acessar o Studio Form Designer
A partir do momento em que clicamos no botão “Form Designer”, a janela do Desig-
ner é aberta, conforme a figura a seguir. Veja o significado de cada item:
B Barra de ferramentas: funcionalidades básicas como novo, abrir e salvar ar-
quivo, recortar, copiar, colar, desfazer, refazer e gerar código;
C Painel de componentes: containers e widgets a serem usados no formulário;
D Área de desenho: área de livre desenho de um formulário;
E Propriedades do objeto: exibe as propriedades do objeto selecionado.
Adianti Studio Professional 67
Figura 97 Principais áreas do Studio Form Designer
A barra de ferramentas do Studio Designer contém as funcionalidades básicas para
operação de um formulário, conforme pode ser visto na figura a seguir.
Figura 98 Botões da barra de ferramentas
As funcionalidades enumeradas pela figura são:
B Novo: cria um novo formulário;
C Abrir: permite abrir um formulário existente na extensão .form.xml;
D Salvar: salva o formulário atual na extensão .form.xml;
E Selecionar: permite selecionar um objeto na tela ou movê-lo;
F Excluir: permite excluir um objeto do formulário;
G Recortar: permite selecionar um objeto para ser recortado para a memória;
H Copiar: permite selecionar um objeto para ser copiado para a memória;
I Colar: permite selecionar uma região para colar o objeto que está na memó-
ria;
J Desfazer: desfaz a última operação;
K Refazer: refaz a última operação desfeita;
L Exibir grade: exibe ou esconde o fundo em forma de grade;
Adianti Studio Professional 68
M Exportar para PNG: permite exportar o formulário como imagem;
N Gerar código-fonte: gera o código-fonte PHP que irá controlar e exibir o for-
mulário desenhado.
Na figura a seguir, podemos visualizar os principais containers e widgets que podem
ser utilizados na construção de um formulário.
Figura 99 Containers e widgets disponíveis
Os containers e widgets enumerados pela figura são:
B Notebook: permite acrescentar um container do tipo TNotebook ao formulá-
rio. O container poderá ter várias abas, basta clicar 2x sobre o objeto para adi-
cionar uma nova. Para excluir uma aba, basta clicar no botão “x” da aba;
C Frame: permite acrescentar um container do tipo TFrame ao formulário. Um
frame poderá ter um título (definido no painel de propriedades);
D Label: permite acrescentar um rótulo de texto (TLabel) ao formulário. Carac-
terísticas como fonte e estilo (negrito, itálico e sublinhado) podem ser defini-
dos no painel de propriedades;
E Botão: permite acrescentar um botão (TButton) ao formulário. No painel de
propriedades pode ser definido o ícone do botão, o nome do método que o
mesmo executará e também um template (rotina padrão do framework como
salvar);
Adianti Studio Professional 69
F Entry: permite acrescentar um campo de entrada de texto (TEntry) ao formu-
lário. No painel de propriedades podemos definir uma máscara para o campo
e também se o mesmo será editável;
G Caixa de senha: permite acrescentar um campo de entrada de senha
(TPassword) ao formulário. No painel de propriedades podemos definir se o
mesmo será editável;
H Seletor de datas: permite acrescentar um campo de seleção de datas (TDate)
ao formulário. No painel de propriedades podemos definir a máscara (forma-
to) da data. Ex: dd/mm/yyyy;
I Busca de registros: permite acrescentar um botão de seleção de registros
(TSeekbutton) ao formulário. No painel de propriedades, devemos selecionar
o banco de dados (database) e modelo (model) sobre os quais a busca será re-
alizada, bem como o campo a ser exibido (display) e o objeto a receber o re-
torno (receiver);
J Spinner: permite acrescentar um campo de seleção numérica com ajustes
para mais e para menos (TSpinner) ao formulário.
K Slider: permite acrescentar um campo de seleção numérica em forma de
régua com um seletor no centro (TSlider) ao formulário.
L Imagem: permite acrescentar uma imagem (TImage) ao formulário.
M Texto: permite acrescentar um campo de entrada de texto com várias linhas
(TText) ao formulário. No painel de propriedades, definimos seu tamanho;
N Checkbutton: permite acrescentar um campo para seleção não exclusiva de
itens (TCheckGroup) ao formulário. No painel de propriedades, podemos defi-
nir os itens da seleção;
O Checkbutton de BD: permite acrescentar um campo para seleção não exclu-
siva de itens a partir do banco de dados (TDBCheckGroup) ao formulário. No
painel de propriedades, podemos selecionar o banco de dados (database) e
modelo (model) de onde os itens serão carregados, bem como a chave do re-
gistro (key) e o valor a ser exibido ao usuário (display).
P Radiobutton: permite acrescentar um campo para seleção exclusiva de itens
(TRadioGroup) ao formulário. No painel de propriedades, podemos definir os
itens da seleção;
Q Radiobutton de BD: permite acrescentar um campo para seleção exclusiva
de itens a partir do banco de dados (TDBRadioGroup) ao formulário. No pai-
nel de propriedades, podemos selecionar o banco de dados (database) e mo-
delo (model) de onde os itens serão carregados, bem como a chave do registro
(key) e o valor a ser exibido ao usuário (display).
R Combobox: permite acrescentar um campo para seleção exclusiva de itens
em forma de lista (TCombo) ao formulário. No painel de propriedades, pode-
mos definir os itens da seleção;
Adianti Studio Professional 70
S Combobox de BD: permite acrescentar um campo para seleção exclusiva de
items em forma de lista a partir do banco de dados (TDBCombo) ao formulário.
No painel de propriedades, podemos selecionar o banco de dados (database)
e modelo (model) de onde os itens serão carregados, bem como a chave do re-
gistro (key) e o valor a ser exibido ao usuário (display).
T Datagrid: permite acrescentar uma datagrid (TDataGrid) ao formulário. A
datagrid virá vazia. É necessário acrescentar paginador, colunas e ações;
U Paginador de datagrid: permite acrescentar um paginador de datagrid
(TPageNavigation) a uma datagrid. Deve ser clicado sobre a datagrid para
realizar esta ação;
V Coluna de datagrid: permite acrescentar uma coluna (TDataGridColumn) a
uma datagrid . Deve ser clicado sobre a datagrid para realizar esta ação;
W Ação de datagrid: permite acrescentar uma ação (TDataGridAction) a uma
datagrid. Deve ser clicado sobre a datagrid para realizar esta ação.
Na figura a seguir, podemos conferir como posicionar um componente no formulá-
rio.