Adianti Studio

ADIANTI STUDIO PROFESSIONAL
Versão 7.0 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 Registro da base de dados..........................................................................................17
2.4 Editor de consultas......................................................................................................18
2.5 Criação das classes modelo........................................................................................20
2.6 Conversão de UML para SQL......................................................................................22
2.7 Conversão de UML para PHP.....................................................................................26
3 Criação de Páginas.................................................................................................................29
3.1 Páginas com HTML.......................................................................................................29
3.2 Cortina lateral...............................................................................................................30
3.3 Página com PDF............................................................................................................30
3.4 Página com conteúdo externo...................................................................................31
3.5 Página com vídeo embarcado....................................................................................32
3.6 Janela com HTML..........................................................................................................32
3.7 Janela com PDF.............................................................................................................33
3.8 Janela com conteúdo externo....................................................................................33
4 Criação de Formulários.........................................................................................................34
4.1 Formulários de cadastro.............................................................................................34
4.2 Formulários de consulta.............................................................................................37
4.3 Formulários de cadastro auxiliar...............................................................................40
4.4 Formulário vetorial......................................................................................................43
4.5 Formulário mestre/detalhe........................................................................................45
4.6 Formulário mestre/detalhe vetorial..........................................................................49
4.7 Formulário mestre/detalhe consulta........................................................................53
5 Criação de Listagens..............................................................................................................57
Adianti Studio Professional 3
5.1 Listagens de registros..................................................................................................57
5.2 Listagem com auto filtro.............................................................................................61
5.3 Relatório tabular..........................................................................................................65
5.4 Relatório de consulta...................................................................................................68
5.5 Lista de seleção de registros......................................................................................69
5.6 Lista de edição de registros........................................................................................73
5.7 Lista de exclusão de registros....................................................................................77
6 REST Services..........................................................................................................................81
6.1 Habilitando o servidor REST.......................................................................................81
6.2 Criando uma classe de serviço REST.........................................................................81
6.3 Consumindo um serviço REST....................................................................................82
7 Studio PDF Designer..............................................................................................................84

7.1 Visão geral.....................................................................................................................84
7.2 Formas e textos............................................................................................................87
7.3 Relatórios......................................................................................................................91
7.4 Nota fiscal......................................................................................................................93
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
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
Adianti Studio Pro. Veja a seguir, o significado de cada item:
B Barra de ferramentas padrão: contém as principais funcionalidades da ferra-

menta, 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 agilizam
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.
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

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

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

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-
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

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

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, é preciso que 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

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”.
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 Registro 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.
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 Editor de consultas

O editor de consultas é uma ferramenta de montagem de consultas SQL. Ele possui
um montador visual e permite gerar consultas (queries) que posteriormente podem
ser usadas para montagem de relatórios.
Figura 18 Meu para acionar o editor de consultas
No botão a seguir, podemos ver o montador de consultas e um SQL gerado.
Figura 19 Editor de consultas

O montador de consultas permite adicionarmos tabelas (botão “Adicionar tabela”) e
conectarmos elas. Se o banco tiver integridade referencial (chaves primárias e estran-
geiras declaradas), então as ligações serão estabelecidas automaticamente. De outra
forma, será necessário relacionar as tabelas manualmente (clicando e arrastando a
coluna de chave estrangeira sobre a coluna de chave primária).
Figura 20 Montador de consultas
Ao relacionarmos as tabelas e estabelecermos as ligações, podemos clicar no botão

“Aplicar “ do editor de consultas. Ele gerará uma consulta SQL em uma variável PHP,
que pode ser utilizada para consultas ao banco de dados.
Caso você queira montar relatórios, no menu “Listagens”, existe um gerador que uti-
liza este mesmo montador de consultas SQL, mas que gera o código PHP necessário
para a montagem do relatório.
Figura 21 Consulta gerada

2.5 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 22 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
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 23 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 24 Assistente de geração de modelos – definição de relacionamentos
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.6 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 25 Menu Converter UML para SQL
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 26 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 27 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
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 28 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 29 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.
Figura 30 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(

name TEXT );
CREATE TABLE customer(

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.
2.7 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 31 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 32 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 cha-
ve estrangeira que relacionam as tabelas no banco de dados;
❏ Tipo de modelo: código-fonte resumido (padrão) ou completo.
Figura 33 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 34 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.
Figura 35 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 gerará
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 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_sample.html');
// replace the main section variables

$this->html->enableSection('main');
parent::add($this->html);
}
}
3.2 Cortina lateral
Esta opção (menu Páginas → Página com HTML) demonstra a criação de uma pági Cortina Lateral) demonstra a criação de uma página
que será aberta em um painel lateral (cortina), que se abrirá automaticamente quan-
do o usuário acionar esta página pelo menu da aplicação. Neste caso, cabe ao desen-
volvedor definir o conteúdo do HTML no arquivo page_sample.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 (Sin-
glePageView) e salvá-la com o mesmo nome da classe na pasta app/control, para
ser posteriormente acessada pela aplicação.
Arquivo gerado
<?php
class SidePageView extends TPage
{
{
parent::setTargetContainer('adianti_right_panel');
// create the HTML Renderer

$this->html = new THtmlRenderer('app/resources/page_sample.html');
// replace the main section variables

}
}
3.3 Página com PDF

Esta opção (menu Páginas → Página com HTML) demonstra a criação de uma pági Página com PDF) demonstra como embutir um PDF
em uma página da aplicação. Quando acionada, solicitará ao desenvolvedor preen-
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 36 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
{
{
$object = new TElement('object');

$object->data = 'app/documents/document.pdf';
$object->type = 'application/pdf';
$object->style = "width: 100%; height:600px";
parent::add($object);
}
}
3.4 Página com conteúdo externo

Esta opção (menu Páginas → Página com HTML) demonstra a criação de uma pági 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 37 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-
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
{
{
$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.5 Página com vídeo embarcado
Esta opção (menu Páginas → Página com HTML) demonstra a criação de uma pági Página com vídeo externo) demonstra como embutir
um vídeo (Ex: Youtube) em uma página da aplicação. Quando acionada, solicitará
ao desenvolvedor preencher a localização do vídeo externo (Ex: Youtube embed).
Neste caso, foi utilizada uma página de um vídeo embarcado do Youtube.
Arquivo gerado
<?php
class EmbeddedVideoView extends TPage
{
{
$object = new TElement('iframe');

$object->width = '100%';
$object->height = '600px';
$object->src = 'https://www.youtube.com/embed/9G0rByRA5j4';
$object->frameborder = '0';
$object->allow = 'accelerometer; autoplay; encrypted-media; gyroscope;
picture-in-picture';
}
}
3.6 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::setTitle('Window');
parent::setSize(500, null); // use 0.6, 0.4 (for relative sizes 60%, 40%)
$this->html = new THtmlRenderer('app/resources/page.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.7 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%
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
{
{
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)";
}
}
3.8 Janela com conteúdo externo

Esta opção (menu Páginas → Página com HTML) demonstra a criação de uma pági 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
{
{
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 38 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:
❏ Banco 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;
❏ 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);
❏ Tipo de apresentação: se o formulário abrirá no conteúdo da página (TPage),
como janela (TWindow), ou em cortina lateral.
❏ Orientação dos campos: se os rótulos dos campos estarão à esquerda (hori-
zontal) ou acima deles (vertical).
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 39 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 “Aplicar”.
Figura 40 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 “Aplicar” 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 (CustomerForm.php).
Figura 41 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.
Figura 42 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 também utiliza a classe BootstrapFormBuilder para a montagem
de formulários, juntamente com a classe TTextDisplay para exibir os conteúdos dos
campos do banco. Como pode ser visto na figura a seguir, por meio do menu “For-
mulários”, localizado na barra de ferramentas Adianti, temos a opção para criação de
formulários de consulta.
Figura 43 Menu para criação de formulário de consulta
Ao acessarmos a opção “Novo formulário de consulta”, o assistente será aberto. Nesta

❏ Nome do formulário de edição: classe utilizada para edição dos dados.
❏ Tipo de apresentação: se o formulário será abrirá no conteúdo da página
(TPage), como janela (TWindow), ou em cortina lateral.

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 44 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 45 Formulários de consulta – definição de campos
Após clicarmos no botão “Aplicar”, 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 (ProductFormView.php).
Figura 46 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 47 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”.
Figura 48 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:
❏ Nome do formulário: nome da classe de controle que será criada.
❏ 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);
❏ Orientação dos campos: se os rótulos dos campos estarão à esquerda (hori-
zontal) ou acima deles (vertical).
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.
Figura 49 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 50 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 “Aplicar” 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.
Figura 51 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 possui a fun-
cionalidade para excluir um registro.
Figura 52 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”.
Figura 53 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:

geração de um formulário vetorial. A partir do momento em que todas definições
Figura 54 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
de dados. Nesta tela, podemos confirmar os campos que farão parte do formulário,
alterar seus rótulos de apresentação em tela, o tamanho de cada campo, o compo-
nente utilizado (TEntry, TDate, TText), etc.
Figura 55 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 “Aplicar” para gerar o código da página. A partir deste mo-
algum subdiretório, com o nome da classe acrescido de .php.
Figura 56 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.
Figura 57 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 58 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:
❏ 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;
Figura 59 Formulário mestre/detalhe– definição de propriedades

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,
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 60 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.
Figura 61 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 “Aplicar” 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.
Figura 62 Formulário mestre/detalhe– código gerado

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.
Figura 63 Formulário mestre/detalhe – programa em execução
4.6 Formulário mestre/detalhe vetorial

O Adianti Studio Pro permite a criação de formulários mestre/detalhe vetoriais 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 vetorial”. Um formulário de mestre/detalhe
vetorial apresenta um registro mestre e seus vários registros detalhe, com botões para
adicionar novas linhas nos registros de detalhe por meio da duplicação da última li-
nha. Também possui botão para remover a linha de detalhe.
Figura 64 Menu para criação de formulário mestre/detalhe vetorial
Ao acessarmos a opção “Novo formulário mestre/detalhe vetorial”, o assistente será

aberto. Nesta primeira etapa, é necessário realizar algumas definições:
geração de um formulário mestre/detalhe vetorial. 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 65 Formulário mestre/detalhe vetorial – definição de propriedades
Na etapa seguinte do assistente de criação de formulários mestre/detalhe vetorial, 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, componentes, dentre outros.
Figura 66 Formulário mestre/detalhe–vetorial definição dos campos mestre
Na etapa seguinte do assistente de criação de formulários mestre/detalhe vetorial, o

Studio nos apresenta uma lista com os campos da tabela detalhe, buscados direta-
parte do formulário detalhe, e alterar seus rótulos, componentes, tamanho, obrigato-
riedade, dentre outras características.
Figura 67 Formulário mestre/detalhe vetorial– definição dos campos detalhe
A partir das definições realizadas no assistente de criação de formulário mestre/deta-

lhe vetorial, podemos clicar no botão “Aplicar” para gerar o código da página. A partir
ções realizadas. Então, basta salvarmos o arquivo na pasta app/control ou em al-
gum subdiretório, com o nome da classe acrescido de .php.
Figura 68 Formulário mestre/detalhe vetorial – código gerado

funcional, sendo que o formulário permite o cadastro de vendas (registro mestre),
bem como os seus itens (registro detalhe). Para iniciar um novo registro, basta acessar
index.php?class=SaleForm&method=onClear
Figura 69 Formulário mestre/detalhe vetorial – programa em execução
4.7 Formulário mestre/detalhe consulta

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 mestre/detalhe consulta”. 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.
Figura 70 Menu para criação de formulário mestre/detalhe consulta
Ao acessarmos a opção “Novo formulário mestre/detalhe consulta”, o assistente será

aberto. Nesta primeira etapa, é necessário realizar algumas definições:
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 71 Formulário consulta mestre/detalhe– definição de propriedades
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-
parte do formulário mestre, e alterar seus rótulos de apresentação em tela.
Figura 72 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-
parte do formulário detalhe, e alterar seus rótulos de apresentação em tela.
Figura 73 Formulário consulta mestre/detalhe– definição dos campos detalhe
A partir das definições realizadas no assistente de criação de formulário consulta

mestre/detalhe, podemos clicar no botão “Aplicar” 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
Figura 74 Formulário consulta mestre/detalhe– código gerado

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 75 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 “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 76 Menu para criação de listagem de consulta
Ao acessarmos a opção “Listagem de registros”, o assistente será aberto. Nesta primei-

ra etapa, é necessário realizar algumas definições:
❏ Banco de dados: base de dados que será utilizada pela listagem;
pulada pela listagem;
❏ Nome da lista: nome da classe de controle que será criada;
❏ 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);
❏ Registros por página: Quantos registros serão exibidos por página;
❏ Ação de edição: formulário de edição, com o qual a listagem estará vinculada.
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
Figura 77 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).
Figura 78 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 79 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 “Aplicar”, para gerar o código da página. A partir deste mo-
Figura 80 Listagem de registros – código gerado

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 81 Listagem de registros – programa em execução

5.2 Listagem com auto filtro
O Studio também possui um gerador de listagens com autofiltro. O autofiltro permi-
te filtrar as colunas por meio de campos posicionados no cabeçalho dos registros. Por
meio da opção “Listagem com auto filtro”, 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, auto filtro e paginação.
Figura 82 Menu para criação de listagem com auto filtro
Ao acessarmos a opção “Listagem com auto filtro”, o assistente será aberto. Nesta pri-
meira etapa, é necessário realizar algumas definições:
❏ Banco de dados: base de dados que será utilizada pela listagem;
pulada pela listagem;
❏ Ação de edição: formulário de edição, com o qual a listagem estará vinculada.
Você pode apontar para um formulário de consulta de registros também.
❏ Registros por página: Quantos registros serão exibidos por página.
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
Figura 83 Listagem de registros com auto filtro – 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).
Figura 84 Listagem de registros com auto filtro – definição de colunas

o seu operador.
Figura 85 Listagem de registros com auto filtro – definição de filtros
A partir das definições realizadas no assistente de criação da listagem de registros,

podemos clicar no botão “Aplicar”, para gerar o código da página. A partir deste mo-
Figura 86 Listagem de registros com auto filtro – código gerado

de listagens com autofiltro. Veja que os campos de filtro ficaram juntamente com os
títulos das colunas. A listagem oferece ainda recurso para exportar os dados em CSV
e PDF. 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 87 Listagem de registros com auto filtro– programa em execução

5.3 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 relatórios tabulares. Como pode ser visto
na figura a seguir, por meio do menu “Listagens”, localizado na barra de ferramentas
Adianti, temos a opção “Relatório tabular”.
Figura 88 Menu para criação de relatório tabular
Ao acessarmos a opção “Relatório tabular”, o assistente será aberto. Nesta primeira

etapa, é necessário realizar algumas definições:
❏ Base de dados: base de dados que será utilizada pelo relatório;
pulada pelo relatório;
❏ Estilo de relatório: escala de cores utilizada (cinza, azul, vermelho);
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 89 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
Figura 90 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
o seu operador.
Figura 91 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 “Aplicar”, 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.
Figura 92 Relatório – código gerado

funcional, sendo que o botão de geração criará o relatório no formato solicitado,
conforme os parâmetros de filtro informados no formulário.
Figura 93 Relatório tabular – programa em execução

5.4 Relatório de consulta

O Adianti Studio Pro permite a criação de relatórios com base em consultas SQL por
meio dos assistentes de criação de relatório de consulta. Como pode ser visto na figu-
ra a seguir, por meio do menu “Listagens”, localizado na barra de ferramentas Adian-
ti, temos a opção “Relatório de consulta”.
Figura 94 Menu para criação de relatório tabular
Ao acessarmos a opção “Relatório de consulta”, o assistente será aberto. Nesta primei-

ra etapa, é necessário entrar com o SELECT, ou usar o “Montador de consultas” para
arrastar visualmente as tabelas. Sempre que for necessário estabelecer um filtro (parâ-
metro digitado pelo usuário), deve-se usar a notação :parametro.
Figura 95 Relatório – definição da consulta SQL
Na etapa seguinte do assistente, o Studio solicita o nome da classe a ser gerada, e gera
o código-fonte em memória. Então, basta salvarmos o arquivo na pasta app/control
Figura 96 Relatório – código gerado

funcional, sendo que o botão de geração criará o relatório no formato solicitado,
conforme os parâmetros de filtro informados no formulário.
Obs: Quando usar o operador like, deve ser concatenado ‘%’ no início e no fim do dado do
formulário. Ex: $filters['nome_cidade'] = '%'.$data->nome_cidade.'%';
Figura 97 Relatório de consulta – programa em execução
5.5 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
Adianti, temos a opção “Lista de seleção de registros”. Uma lista de seleção de regis-
tros permite que o usuário localize e selecione um conjunto de registros para realizar
alguma ação posterior. No código-fonte gerado, o programa irá, ao final, exibir os re-
gistros selecionados ao usuário.
Figura 98 Menu para criação de lista de seleção de registros
Ao acessarmos a opção “Lista de seleção de registros”, o assistente será aberto. Nesta

❏ Banco de dados: base de dados que será utilizada pela lista;
pulada pela lista;
❏ Nome da lista: nome da classe de controle que será criada.

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,
Figura 99 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,
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 100 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 101 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 “Aplicar” para gerar o código da página. A partir deste
Figura 102 Lista de seleção de registros– código gerado

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 (localizado no canto superior direito da datagrid), será aberta
uma nova janela contendo os registros selecionados. A ação desta fase final pode fa-
cilmente ser alterada pelo usuário para que o programa execute uma outra ação, no
lugar de exibir os registros selecionados.
Figura 103 Lista de seleção de registros– programa em execução

5.6 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 “Lista de edição de registros”. Uma lista de edição de registros
permite que o usuário edite registros diretamente na datagrid, por meio de algum
componente de entrada de dados (Ex: TEntry).
Figura 104 Menu para criação de lista de edição de registros
Ao acessarmos a opção “Lista de edição de registros”, o assistente será aberto. Nesta

primeira etapa são necessárias algumas definições:
pulada pela lista;
❏ Campo de edição: campo que será editado diretamente na datagrid;
❏ Componente: componente que será utilizado para edição do campo.

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,
Figura 105 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 106 Lista de edição de registros– definição dos campos

quais campos não serão utilizados como filtro, e para cada campo, definir o operador.
Figura 107 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 “Aplicar” para gerar o código da página. A partir deste
Figura 108 Lista de edição de registros– código gerado

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 109 Lista de edição de registros– programa em execução

5.7 Lista de exclusão de registros

O Adianti Studio Pro permite a criação de listas de exclusão de registros com apenas
alguns cliques, por meio dos assistentes de criação de páginas. Como pode ser visto
Adianti, temos a opção “Lista de exclusão de registros”. Uma lista de exclusão de re-
gistros permite que o usuário selecione diversos registros para excluir de uma vez.
Figura 110 Menu para criação de lista de exclusão de registros
Ao acessarmos a opção “Lista de exclusão de registros”, o assistente será aberto. Nesta

primeira etapa são necessárias algumas definições:
pulada pela lista;
❏ Campo de edição: campo que será editado diretamente na datagrid.

geração de uma lista de exclusão de registros. A partir do momento em que todas de-
finições obrigatórias forem preenchidas, o botão “Próxima página” pode ser aciona-
do, progredindo para o próximo estágio da geração automática.
Figura 111 Lista de exclusã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 112 Lista de exclusão de registros– definição dos campos

quais campos não serão utilizados como filtro, e para cada campo, definir o operador.
Figura 113 Lista de exclusão de registros– definição dos filtros
A partir das definições realizadas no assistente de criação de lista de exclusão de re-

gistros, podemos clicar no botão “Aplicar” para gerar o código da página. A partir
ções realizadas no assistente. Então, basta salvarmos o arquivo na pasta app/control
Figura 114 Lista de exclusão de registros– código gerado

funcional, e permite a localização de registros por meio do formulário superior. A
partir do filtro realizado, será montada uma datagrid as linhas selecionáveis. Após se-
lecionar várias linhas, é possível clicar no botão “Excluir”, localizado no canto superi-
or direito da datagrid, para proceder com a exclusão dos registros.
Figura 115 Lista de exclusã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 116 REST – nova classe de serviço

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 117 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, apenas comentá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 118 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 119 REST – geração de código cliente

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 120 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 121 REST – código cliente gerado

7 STUDIO PDF DESIGNER
CAPÍTULO 7
Studio PDF Designer
Neste capítulo conheceremos a ferramenta de desenho de documentos em

PDF do Adianti Studio.
7.1 Visão geral

No capítulo 4 vimos como gerar relatórios tabulares, o que se demonstrou ser uma
tarefa bastante simples, em virtude de termos um conjunto de classes (TTableWri-
terHTML, TTableWriterPDF, e TTableWriterRTF) que facilitam bastante o trabalho,
abstraindo detalhes das bibliotecas usadas na construção deste tipo de documento.
Entretanto, em algumas situações precisamos lidar com documentos mais complexos
como: diplomas, notas fiscais, recibos, dentre outros, que precisam de um visual mais
elaborado e a utilização de elementos visuais (formas) como retângulos, elipses e um
refinamento maior no posicionamento destes objetos. Pensando na facilidade de cria-
ção de documentos, o Studio Pro disponibiliza o Studio PDF Designer, uma ferra-
menta voltada para o desenho de documentos para o Adianti Framework, que pode
ser acessado por meio do botão “PDF Designer” da barra de ferramentas Adianti,
como pode ser visto na figura a seguir.
Figura 122 Botão para acessar o Studio PDF Designer

A partir do momento em que clicamos no botão “PDF 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 arqui-

vo, configurar página, visualizar impressão, zoom, posicionar objeto (cima e
baixo), copiar, recortar, colar e excluir objeto;
C Painel de componentes: formas que podem ser utilizadas para compor um
PDF como: Retângulo, Elipse, Texto, Imagem, Linha, além de Baseline e Ânco-
ra;
D Área de desenho: área de livre desenho de um PDF;
E Propriedades do objeto: exibe as propriedades do objeto selecionado.
Figura 123 Principais áreas do Studio PDF Designer
Obs: Documentos criados pelo Adianti PDF Designer podem ser facilmente complementa-
dos com dados via programação, o que será visto em seguida.
A barra de ferramentas do Studio PDF Designer contém as funcionalidades básicas

para operação de um arquivo, conforme pode ser visto na figura a seguir.
Figura 124 Botões da barra de ferramentas
As funcionalidades enumeradas pela figura são:

B Novo: cria um novo desenho;
C Abrir: permite abrir um desenho existente na extensão .pdf.xml;
D Salvar: salva o desenho atual na extensão .pdf.xml;
E Configurar página: permite alterar as propriedades da página, como formato
(A4, A5) e orientação (retrato, paisagem);
F Visualiza impressão: permite visualizar o resultado em PDF;
G Aumenta o zoom: permite aumentar o zoom em 1 nível;
H Diminui o zoom: permite diminuir o zoom em 1 nível;
I Trazer para frente: permite mover o objeto para a frente;
J Enviar para trás: permite enviar o objeto para trás;
K Copiar: permite copiar o objeto selecionado para a memória;
L Recortar: permite recortar o objeto selecionado para a memória;
M Colar: permite colar o objeto selecionado a partir da memória;
N Excluir: permite excluir o objeto selecionado.
Na figura a seguir, podemos visualizar os principais componentes que podem ser

utilizados na construção de um desenho no Adianti PDF Designer.
Figura 125 Componentes disponíveis
Os componentes enumerados pela figura são:
B Seletor: permite selecionar um objeto qualquer;

C Retângulo: permite desenhar um retângulo;
D Elipse: permite desenhar uma elipse;
E Texto: permite escrever um texto qualquer. É importante frisar que os textos
suportam tags básicas do HTML como , e ;
F Imagem: permite inserir uma imagem;
G Linha: permite desenhar uma linha;
H Linha de base: permite criar uma linha imaginária, que permite mover verti-
calmente todos os objetos que se situarem abaixo dela;
I Âncora: permite criar uma âncora. Uma âncora é uma marca no desenho, que
pode ser obtida posteriormente via programação, para que sejam inseridos
elementos dinamicamente, via programação.
Os desenhos feitos pelo Studio PDF Designer são salvos na extensão .pdf.xml, que
é um formato aberto. Estes arquivos podem posteriormente serem lidos por uma
classe disponibilizada pelo framework chamada TPDFDesigner, para construir do-
cumentos PDF.
A classe TPDFDesigner é uma derivação da famosa classe para geração de documen-
tos PDF, a FPDF. Assim, a classe TPDFDesigner provê um conjunto extra de funções
sobre a FPDF. Você ainda pode utilizar as funções da FPDF que sempre utilizou. A
classe TPDFDesigner fornece os métodos adicionais a seguir.
Tabela 1. Métodos da classe TPDFDesigner
Validador Descrição
fromXml Carrega um arquivo desenhado pelo PDF Designer (.pdf.xml).
gotoAnchorXY Posiciona o ponteiro em uma coordenada X,Y de uma âncora.
gotoAnchorX Posiciona o ponteiro em uma coordenada X de uma âncora.
gotoAnchorY Posiciona o ponteiro em uma coordenada Y de uma âncora.
writeAtAnchor Escreve um texto qualquer em uma determinada âncora.
replace Substitui um texto qualquer presente no documento.
setFontColorRGB Define a cor da fonte, no formato RGB.
setFillColorRGB Define a cor de preenchimento, no formato RGB.
setDrawColorRGB Define a cor de desenho das linhas, no formato RGB.
generate Gera o documento em memória, com os elementos desenhados
pelo Studio PDF Designer.
save Salva o documento PDF em disco.
7.2 Formas e textos

A partir do momento em que aprendemos as funcionalidades básicas do Studio PDF
Designer, podemos criar desenhos e integrá-los à nossa aplicação por meio de con-
troladores.
O objetivo do primeiro exemplo construído é justamente demonstrar a utilização de
diversos elementos ao mesmo tempo. Para tal, foi construído o desenho app/re-
ports/forms.pdf.xml. Este exemplo busca combinar o uso de textos, retângulos,
elipses, linhas, elementos com preenchimento, borda e sombra.
Veja na figura a seguir, que alguns textos possuem em seu conteúdo a expressão
{name}. Essa expressão representa uma variável que pode ser substituída em tempo
de execução por um conteúdo dinâmico pelo programa. Além disso, temos a presen-
ça de uma âncora. Como as âncoras são pequenas, foi colocada uma seta no desenho
a seguir para indicar a presença da mesma. Uma âncora possui um nome e é a refe-
rência de uma localização que pode ser substituída por um outro elemento qualquer
em tempo de execução.
Obs: As âncoras representam uma posição (coordenada) no desenho. Posteriormente pode-

mos usar métodos da biblioteca FPDF para desenhar nestas posições.
Figura 126 Desenho com formas e textos criado no Studio PDF Designer
Para demonstrar o primeiro exemplo, vamos criar um formulário. Neste formulário o

usuário digitará um nome qualquer. Este nome será utilizado para substituir a variá-
vel {name} presente no PDF desenhado. Na figura a seguir, podemos conferir o for-
mulário.
Figura 127 Formulário para geração do documento PDF

O código a seguir demonstra como foi criado o formulário. Este formulário basica-
mente possui um campo para digitação de um nome (name) e um botão de ação que
aciona o método onGenerate() sempre que for clicado.
app/control/Presentation/Report/PDFDesignShapesView.class.php
<?php
class PDFDesignShapesView extends TPage
{
private $form;
function __construct()
{
$this->form = new TForm('form_pdf_shapes'); // cria o formulário

$table = new TTable; // cria a tabela
$this->form->add($table); // adiciona a tabela ao formulário
// cria os campos do formulário

$name = new TEntry('name');
$name->addValidation( 'Name', new TRequiredValidator );
$label = new TLabel('Name' . ': ');
$label->setFontColor('red');
$table->addRowSet($label, $name); // adiciona os campos na tabela
$save_button=new TButton('generate');
$save_button->setAction(new TAction(array($this, 'onGenerate')), 'Generate');
$save_button->setImage('ico_save.png');
$table->addRowSet($save_button); // adiciona uma linha para a ação
// define os campos do formulário

$this->form->setFields(array($name,$save_button));
parent::add($this->form);
}
Sempre que o botão “Generate” for clicado, o método onGenerate() é executado.

Este método obtém os dados do formulário, e valida seu preenchimento.
Em seguida, fazemos uso da classe TPDFDesigner. A classe TPDFDesigner faz a lei-
tura do arquivo desenhado forms.pdf.xml por meio do método fromXml(). Além
disso, o método replace() realiza substituição de um determinado texto encontra-
do no documento por uma variável qualquer (neste caso, o conteúdo digitado no for-
mulário). O método generate() por sua vez gera o documento em memória com
base naquilo que foi desenhado no forms.pdf.xml.
Em seguida é utilizado o método gotoAnchorXY(), para posicionar o ponteiro em
uma determinada âncora criada no documento. A partir de então, é alterada a cor da
fonte por meio do método setFontColorRGB() e a fonte por meio do método Set-
Font(). Por fim, naquela posição da âncora é escrito o texto “Dynamic text!”.
Ao final, o PDF gerado é salvo em disco por meio do método save() e aberto em
tela por meio do método openFile().
function onGenerate()
{
try
{
$data = $this->form->getData(); // obtém os dados
$this->form->validate();
$designer = new TPDFDesigner;

$designer->fromXml('app/reports/forms.pdf.xml'); // lê o XML
$designer->replace('{name}', $data->name ); // substitui o texto
$designer->generate(); // gera
$designer->gotoAnchorXY('anchor1'); // posiciona na âncora

$designer->SetFontColorRGB('#FF0000');
$designer->SetFont('Arial', 'B', 18);
$designer->Write(20, 'Dynamic text !'); // escreve o texto
$file = 'app/output/pdf_shapes.pdf';
if (!file_exists($file) OR is_writable($file))
{
$designer->save($file);
parent::openFile($file);
}
else
{
throw new Exception(_t('Permission denied') . ': ' . $file);
}
new TMessage('info', 'Report generated. Please, enable popups...');

}
catch (Exception $e)
{
new TMessage('error', 'Error ' . $e->getMessage());
TTransaction::rollback();
}
}
}
Podemos conferir o resultado em PDF deste programa na figura a seguir.
Figura 128 Documento gerado com formas e textos

7.3 Relatórios
No exemplo anterior, vimos como realizar pequenas substituições de texto, e tam-
bém como produzir novos elementos no PDF, com base na posição das âncoras. O
objetivo deste novo exemplo é construir um relatório com várias linhas de dados,
com base em um cabeçalho desenhado em PDF.
A figura a seguir, demonstra o desenho criado no Studio PDF Designer. Basicamente
construímos um retângulo com um texto em seu interior para o título, e mais alguns
retângulos para determinar os cabeçalhos das colunas. Além disso, criamos uma pe-
quena âncora (apontada pela seta) chamada “details”, que é onde os dados de nosso
relatório começarão a ser exibidos.
Figura 129 Relatório com cabeçalho e títulos em PDF
Para gerar este relatório, faremos um formulário simples, somente com um botão de
ação. Quando este botão for clicado, o método onGenerate() é executado. Vamos
nos concentrar apenas no método onGenerate() neste exemplo. Poderíamos fazer
um formulário mais elaborado, com filtros por vários campos, mas já vimos como fa-
zer isso no exemplo de relatórios do capítulo 4, e para o exemplo não ficar muito ex-
tenso, vamos focar na classe TPDFDesigner.
No método onGenerate(), simplesmente abrimos uma transação com a base de da-
dos, e obtemos todos os clientes da mesma. Em seguida, obtemos os dados do for-
mulário pelo método getData(), e validamos estes pelo método validate(). Após
instanciarmos um objeto da classe TPDFDesigner, o arquivo criado pelo Studio PDF
Designer é lido pelo método fromXml(), e gerado em memória pelo método gene-
rate().
Após gerar o documento em memória, começamos a adicionar conteúdo dinâmico
no documento. Para tal, usamos o método gotoAnchorXY(), para nos posicionarmos
na âncora chamada “details”. Em seguida, definimos a fonte e a cor do texto pelos
métodos SetFont() e setFillColorRGB().
Após definirmos as características do texto, os objetos retornados da base de dados
são percorridos por meio de um foreach. Para cada cliente, posicionamos o pontei-
ro no início da linha pelo método gotoAnchorX(), e usamos o método Cell() da
FPDF para gerar várias células com os dados de clientes. Por fim, o arquivo é salvo
em disco pelo método save().
Obs: Quando os dados estiverem armazenados no formato UTF8 no banco de dados, é ne-
cessário utilizar a função utf8_decode(), sobre estes, no momento da geração.
app/control/Presentation/Report/PDFDesignReportView.class.php
<?php
class PDFDesignReportView extends TPage
{
private $form;
function __construct() {
...
}
{
try
{
TTransaction::open('samples'); // abre transação
$repository = new TRepository('Customer');

$criteria = new TCriteria;
// carrega todos os clientes
$customers = $repository->load($criteria);
$data = $this->form->getData();
$this->form->validate();

$designer->fromXml('app/reports/report.pdf.xml'); // carrega o desenho
$designer->generate(); // gera em memória
$fill = TRUE;
$designer->gotoAnchorXY('details'); // posiciona em uma âncora
$designer->SetFont('Arial', '', 10); // altera a fonte
$designer->setFillColorRGB( '#F9F9FF' ); // altera a cor do texto
if ($customers)
{
foreach ($customers as $customer) // percorre os clientes retornados
{
$designer->gotoAnchorX('details'); // posiciona no eixo X
$designer->Cell( 34, 12, $customer->id, 1, 0, 'C', $fill);
$designer->Cell(160, 12, $customer->name, 1, 0, 'L', $fill);
$designer->Cell(152, 12, $customer->address, 1, 0, 'L', $fill);
$designer->Cell(152, 12, $customer->city_name, 1, 0, 'L', $fill);
$designer->Ln(12); // quebra linha
$fill = !$fill; // alterna o preenchimento

}
}
// define o caminho do arquivo de saída

$file = 'app/output/pdf_report.pdf';
// verifica se é possível escrever o arquivo
{
$designer->save($file); // grava o PDF em disco
parent::openFile($file); // abre o PDF em tela
}
else
{
}
new TMessage('info', 'Report generated...');

TTransaction::close(); // fecha transação
}
catch (Exception $e) // em caso de exceção
{
TTransaction::rollback();
}
}
}
Na figura a seguir, podemos ver o resultado deste programa em PDF.
Figura 130 Relatório em PDF
7.4 Nota fiscal

Para finalizar a demonstração do Studio PDF Designer, vamos criar uma Nota Fiscal,
que é um documento complexo, com vários detalhes, muitos campos de informação
e várias linhas de detalhamento com os produtos vendidos.
Construir uma Nota Fiscal via programação é um tanto quanto trabalhoso, tendo
em vista o posicionamento dos objetos, e a criação de vários retângulos para delinear
as informações. Com o Studio PDF Designer, a criação visual torna-se uma atividade
de desenho muito mais rápida.
Na figura a seguir, podemos ver o modelo construído no Studio PDF Designer (app/
reports/nfe.pdf.xml). Basicamente o modelo é constituído por uma série de re-
tângulos alinhados, e textos, dentro de seus respectivos cantos superiores. Dentro de
cada retângulo, há também uma âncora, que será posteriormente substituída por um
elemento via programação.
Neste exemplo, substituiremos as âncoras por textos fixos. Mas na prática, o conteú-
do deverá vir do banco de dados, de uma tabela que armazene as informações de
uma Nota Fiscal. Mas como aqui o objetivo é ensinar o uso da biblioteca, vamos nos
focar nos aspectos visuais de geração do documento.
Figura 131 Nota Fiscal desenhada no Studio PDF Designer
Para gerar a Nota Fiscal, vamos construir um formulário somente com um botão
para sua geração. Este formulário terá um botão para geração da Nota Fiscal, que
executa o método onGenerate(). Vamos nos concentrar neste método.
Com foi dito anteriormente, neste exemplo não serão coletados dados do banco de
dados, pois a Nota Fiscal será gerada com valores fixos. A seguir, temos o método on-
Generate(), que inicia com a interpretação do modelo da Nota Fiscal, que está ar-
mazenada no arquivo nfe.pdf.xml, o que é realizado por meio do método
fromXml(). Em seguida, usamos o método generate() para gerar a Nota Fiscal em
memória, com base naqueles objetos que foram desenhados no Studio PDF Desig-
ner. Basicamente, o que o método generate() faz, é converter os elementos do ar-
quivo XML em instruções de baixo nível da biblioteca FPDF.
Após gerar o documento em memória, é definida a fonte, por meio do método Set-
Font() e a cor, por meio do método setFontColorRGB(). Em seguida, são realiza-
das várias chamadas ao método writeAtAnchor(), que escreve um determinado
conteúdo de texto em uma certa posição de âncora. O primeiro parâmetro deste mé-
todo identifica a âncora, e o segundo o conteúdo a ser escrito.
Após escrever várias informações do cabeçalho da Nota Fiscal, como os dados do cli-
ente, do endereço, e do transporte, é momento de exibir os itens da Nota. Para tal, é
usado o método gotoAnchorXY() para posicionar o ponteiro na âncora “details”, e
depois é utilizado o método Cell() sucessivas vezes para exibir as colunas com as
informações do item (produto). O segundo produto inicia com a chamada de goto-
AnchorX(), pois é usada somente a posição X, ou seja, a posição “horizontal” da ân-
cora, tendo em vista que o cursor já se desloca dinamicamente na vertical neste pon-
to.
app/control/Presentation/Report/PDFDesignNFEView.class.php
<?php
class PDFDesignNFEView extends TPage
{
private $form;
function __construct() {
...
}
{
try
{
$designer->fromXml('app/reports/nfe.pdf.xml'); // lê o arquivo
$designer->generate(); // gera o documento em memória
// escreve os dados do cabeçalho da Nota nas posições de âncora

$designer->SetFont('Arial', 'B', 8);
$designer->setFontColorRGB( '#4C4491' );
$designer->writeAtAnchor('for_ie', '23234234234');
$designer->writeAtAnchor('for_cnpj', '001.111.222.0001/00');
$designer->writeAtAnchor('nome', 'Cliente demonstração da silva');
$designer->writeAtAnchor('endereco', 'Rua das demonstrações');
$designer->writeAtAnchor('bairro', 'Centro');
...
// escreve os dados do 1o produto, na posição da âncora “details”

$designer->gotoAnchorXY('details');
$designer->SetFont('Arial', '', 8);
$designer->Cell( 62, 10, '12121212', 1, 0, 'C');
$designer->Cell(140, 10, 'Guaraná', 1, 0, 'L');
$designer->Cell( 30, 10, '999', 1, 0, 'C');
...
// escreve os dados de um segundo produto
$designer->Ln(10);
$designer->gotoAnchorX('details'); // posiciona na horizontal cfe a âncora
$designer->Cell( 62, 10, '12121212', 1, 0, 'C');
$designer->Cell(140, 10, 'Chocolate', 1, 0, 'L');
$designer->Cell( 30, 10, '999', 1, 0, 'C');
...
// define o caminho de saída

$file = 'app/output/nfe.pdf';
// verifica se é possível escrever no arquivo

{
$designer->save($file);
parent::openFile($file);
}
else
{
}
new TMessage('info', 'Report generated...');

TTransaction::close(); // fecha a transação
}
catch (Exception $e) // em caso de exceção
{
}
}
}
Na figura a seguir, podemos ver o resultado em PDF deste programa.
Figura 132 Nota Fiscal em PDF

Suporte
No site da Adianti (www.adianti.com.br), você encontra nossa comunidade. Lá, po-

derá interagir por meio de nosso fórum de discussões, e também poderá inscrever-se
em nossa lista de discussões. Além disso, a Adianti oferece serviços de treinamento e
consultoria.
Figura 133 Comunidade no site da Adianti

Treinamento
Devido à demanda por treinamentos a partir de vários pontos do país, a dificuldade

em atender a todos por causa da distância, foi lançado o treinamento completo sobre
o Adianti Framework no formato de videoaulas, que pode ser adquirido diretamente
no site da Adianti, em sua loja virtual (http://www.adianti.com.br/store).
A partir da compra das videoaulas, você recebe um link onde terá acesso exclusivo ao
conteúdo, podendo baixá-lo para seu PC e assistir offline. As aulas foram todas gra-
vadas no formato HD pelo próprio criador do framework. São mais de 16 horas de
curso, onde você aprenderá a criar uma aplicação, passando pela parte de banco de
dados, modelos, persistência, apresentação, integração com banco de dados, criação
de controle de permissões de acesso, alteração de layout, dentre outros. O treinamen-
to em videoaulas, bem como o livro sobre o framework, formam o material mais
completo disponível sobre o Adianti Framework.
Figura 134 Videoaulas sobre o Adianti Framework

Adianti Studio

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Adianti Studio

Enviado por

Direitos autorais:

Formatos disponíveis

ADIANTI STUDIO PROFESSIONAL

Versão 7.0 ou superior

7 Studio PDF Designer..............................................................................................................84

Ao utilizarmos um framework para desenvolvimento de sistemas, ganhamos unifor-

Neste capítulo conheceremos a interface do Adianti Studio, bem como suas

1.1 Organização da interface

B Barra de ferramentas padrão: contém as principais funcionalidades da ferra-

Figura 1 Tela inicial do Adianti Studio Pro

1.2 Visão geral dos menus

Figura 2 Menu Arquivo do Adianti Studio Pro

Figura 3 Menu Editar do Adianti Studio Pro

Figura 4 Menu Procurar do Adianti Studio Pro

Figura 5 Menu Exibir do Adianti Studio Pro

O menu “Ferramentas” possui opções como: “Preferências”, que permite configurar

Figura 6 Menu Ferramentas do Adianti Studio Pro

Figura 7 Janela de preferências do Adianti Studio Pro

1.4 Gerenciamento de projetos

Figura 8 Janela de edição de projetos

Os projetos existentes podem ser acessados por meio da árvore de navegação, em

Figura 9 Menu de seleção de projetos

Figura 10 Janela de edição de bancos de dados

Figura 11 Área de navegação de bancos de dados

Figura 12 Janela de navegação de tabela

Neste capítulo abordaremos como se dá a criação de um projeto novo utili-

2.1 Visão geral

Figura 13 Barra de ferramentas de geração de código no Adianti Studio Pro

Figura 14 Menu de opções para criação de novos projetos

Figura 15 Janela de criação de novo projeto Adianti Framework

2.3 Registro da base de dados

Figura 16 Menu de opções para registro de uma nova base de dados

Figura 17 Janela para registro de um novo banco de dados

2.4 Editor de consultas

Figura 18 Meu para acionar o editor de consultas

No botão a seguir, podemos ver o montador de consultas e um SQL gerado.

Figura 19 Editor de consultas

Figura 20 Montador de consultas

Ao relacionarmos as tabelas e estabelecermos as ligações, podemos clicar no botão

Figura 21 Consulta gerada

Figura 22 Menu de opções para criação de novo modelo a partir de assistente

Figura 23 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

Figura 24 Assistente de geração de modelos – definição de relacionamentos

A partir do momento em que cadastramos os relacionamentos entre as classes, pode-

public function set_category(Category $object)

2.6 Conversão de UML para SQL

Figura 25 Menu Converter UML para SQL

Figura 26 Modelo de classes na ferramenta StarUML

Figura 27 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”,

Figura 28 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-

Figura 29 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

Figura 30 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

CREATE TABLE city(

CREATE TABLE customer(

Figura 31 Menu Converter UML para Classes

Figura 32 Geração do modelo a partir do XMI – Localização do arquivo

Figura 33 Geração do modelo a partir do XMI – Definição de parâmetros

Figura 34 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

Figura 35 Geração do modelo a partir do XMI – Exemplo de código gerado