Documente Academic
Documente Profesional
Documente Cultură
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
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
CAPÍTULO 1
Introdução
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.
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.
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.
CAPÍTULO 2
Criação do Projeto
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).
Obs: Você pode usar esse diálogo para registrar projetos já existentes. Nestes casos, basta des-
ligar a opção “Copiar estrutura do framework”.
Adianti Studio Professional 17
A partir da seleção da pasta, a ferramenta já sugere e preenche automaticamente o
campo “Pasta das classes”, com os caminhos padronizados, utilizados pelo Adianti
Framework. A partir deste momento, o Studio irá ler os diretórios do projeto para
“conhecer” a estrutura das classes envolvidas. Mesmo que no início só tenhamos
classes do framework, o Studio memorizará estas estruturas para autocomplete.
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.
A seguir, o resultado gerado. É importante lembrar que o arquivo gerado deve ser sal-
vo na pasta app/config, com a extensão .ini, para ser acessado pela aplicação.
Adianti Studio Professional 18
app/config/teste.ini
host = 127.0.0.1
port = 5432
name = exemplos
user = postgres
pass = teste
type = pgsql
Obs: É importante que o nome do arquivo de conexão com a base de dados tenha sentido,
uma vez que utilizaremos o mesmo dentro da aplicação, sempre que precisarmos abrir uma
transação com a base de dados.
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.
Adianti Studio Professional 21
private $category;
private $skills;
private $contacts;
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.
Adianti Studio Professional 23
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.
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 );
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.
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.
Adianti Studio Professional 27
Em seguida, o Studio identificará quais são as classes presentes no modelo XMI e so-
licitar quais desejamos importar.
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
Arquivo gerado
<?php
class SinglePageView extends TPage
{
public function __construct()
{
parent::__construct();
parent::add($this->html);
}
}
Adianti Studio Professional 30
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
{
public function __construct()
{
parent::__construct();
parent::setTargetContainer('adianti_right_panel');
parent::add($this->html);
}
}
parent::add($object);
}
}
Arquivo gerado
<?php
class ExternalPageView extends TPage
{
public function __construct()
{
parent::__construct();
parent::add($iframe);
Adianti Studio Professional 32
}
}
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
{
public function __construct()
{
parent::__construct();
parent::add($object);
}
}
Arquivo gerado
<?php
class ContainerWindowView extends TWindow
{
private $form;
function __construct()
{
parent::__construct();
parent::setTitle('Window');
parent::setSize(500, null); // use 0.6, 0.4 (for relative sizes 60%, 40%)
parent::add($this->html);
}
}
Obs: O método setSize() define o tamanho da janela. O tamanho pode ser definido em pi-
xels (500), em percentual (0.5), ou null para se auto ajustar ao conteúdo.
Adianti Studio Professional 33
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
{
public function __construct()
{
parent::__construct();
parent::setTitle('WindowPDFView');
parent::setSize(0.8,0.8);
parent::add($object);
}
}
Arquivo gerado
class ExternalSystemWindowView extends TWindow
{
public function __construct()
{
parent::__construct();
parent::setTitle('ExternalSystemWindowView');
parent::setSize(0.8, 650);
parent::add($iframe);
}
}
4 CRIAÇÃO DE FORMULÁRIOS
CAPÍTULO 4
Criação de Formulários
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 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
Adianti Studio Professional 37
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.
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:
❏ 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.
Adianti Studio Professional 41
❏ 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);
❏ Tipo de apresentação: se o formulário será 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).
Ao acessarmos a opção “Novo formulário vetorial”, o assistente será aberto. Nesta pri-
meira 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 apresentação: se o formulário será abrirá no conteúdo da página
(TPage), como janela (TWindow), ou em cortina lateral.
Adianti Studio Professional 44
CAPÍTULO 5
Criação de Listagens
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.
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;
❏ Modelo: classe de modelo (TRecord) que representa a tabela que será mani-
pulada pela listagem;
❏ Chave primária: definir qual é o campo de chave primária da tabela;
❏ Nome da lista: nome da classe de controle que será criada;
❏ Açã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.
Após a definição de quais colunas farão parte do relatório, surge o momento de defi-
nir quais serão os campos utilizados para a filtragem do mesmo, bem como quais os
operadores (=, like) serão utilizados para cada campo. Nesta tela, basta eliminarmos
quais campos não desejamos utilizar como filtro, e para cada campo utilizado, alterar
o seu operador.
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
ou em algum subdiretório, com o nome da classe acrescido de .php.
Adianti Studio Professional 69
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.'%';
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.
Após a definição de quais colunas farão parte da listagem, surge o momento de defi-
nir quais serão os campos utilizados para a filtragem da mesma, bem como quais os
operadores (=, like) serão utilizados para cada campo. Nesta tela, basta eliminarmos
quais campos não serão utilizados como filtro, e para cada campo, definir o operador.
Após a definição de quais colunas farão parte da listagem, surge o momento de defi-
nir quais serão os campos utilizados para a filtragem da mesma, bem como quais os
operadores (=, like) serão utilizados para cada campo. Nesta tela, basta eliminarmos
quais campos não serão utilizados como filtro, e para cada campo, definir o operador.
CAPÍTULO 6
REST Services
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.
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.
CAPÍTULO 7
Obs: Documentos criados pelo Adianti PDF Designer podem ser facilmente complementa-
dos com dados via programação, o que será visto em seguida.
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.
Figura 126 Desenho com formas e textos criado no Studio PDF Designer
app/control/Presentation/Report/PDFDesignShapesView.class.php
<?php
class PDFDesignShapesView extends TPage
{
private $form;
function __construct()
{
parent::__construct();
$save_button=new TButton('generate');
$save_button->setAction(new TAction(array($this, 'onGenerate')), 'Generate');
$save_button->setImage('ico_save.png');
parent::add($this->form);
}
$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);
}
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
Adianti Studio Professional 92
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() {
...
}
function onGenerate()
{
try
{
TTransaction::open('samples'); // abre transação
$data = $this->form->getData();
$this->form->validate();
$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
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
Adianti Studio Professional 95
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() {
...
}
function onGenerate()
{
try
{
$designer = new TPDFDesigner;
$designer->fromXml('app/reports/nfe.pdf.xml'); // lê o arquivo
$designer->generate(); // gera o documento em memória