Oracle Developer 6i Forms

INTERNO
ORACLE DEVELOPER – FORMS6I
Rio de Janeiro, janeiro de 2007.
As informações contidas neste documento pertencem à Value Team Brasil S/C Ltda e ao destinatário do documento. Cópia, publicação ou
distribuição não-autorizada deste material são práticas estritamente proibidas e podem ser ilegais.
Value Team Brasil S/C Ltda Rua da Cadenlária Tel +55 21 2213 9191
VALUE PARTNERS GROUP 60 – 10º andar Fax + 55 21 2213 9190
20091–020 www.valueteam.com
Rio de Janeiro – RJ - Brasil
BRAVT-TREINAM-9F-061220-LFern
CAPÍTULO 1: CONHECENDO A FERRAMENTA ......................................................................................... 1

O PACOTE DEVELOPER 6I ......................................................................................................................................... 1
A FERRAMENTA........................................................................................................................................................... 2
CONSIDERAÇÕES GERAIS......................................................................................................................................... 2
ATIVANDO O FORM BUILDER .................................................................................................................................... 3
O NAVEGADOR DE OBJETOS (OBJECT NAVIGATOR)............................................................................................. 4
EXPANDIR OU CONTRAIR ...............................................................................................................................................................4
CRIAR OU DELETAR.........................................................................................................................................................................5
COPIAR, RECORTAR E COLAR .......................................................................................................................................................5
EXECUTAR E EXECUTAR COM DEPURAÇÃO ...............................................................................................................................5
NOVO, ABRIR E SALVAR..................................................................................................................................................................6
LOCALIZAR ........................................................................................................................................................................................6
NAVEGANDO NA HIERARQUIA........................................................................................................................................................6
PAINÉIS DO NAVEGADOR ...............................................................................................................................................................7
ALTERANDO O NOME DE UM ELEMENTO .....................................................................................................................................7
CRIANDO UMA APLICAÇÃO........................................................................................................................................ 8
EXECUTANDO A APLICAÇÃO CRIADA .................................................................................................................... 11
INCLUSÃO........................................................................................................................................................................................11
CONSULTA ......................................................................................................................................................................................12
ALTERAÇÃO ....................................................................................................................................................................................13
EXCLUSÃO ......................................................................................................................................................................................13
BLOQUEIO .......................................................................................................................................................................................13
NAVEGAÇÃO ...................................................................................................................................................................................14
MENU AJUDA...................................................................................................................................................................................14
SALVA IMPLÍCITA............................................................................................................................................................................14
CONCLUSÕES.................................................................................................................................................................................14
CAPÍTULO 2 : BLOCOS............................................................................................................................... 15
PROPRIEDADES ........................................................................................................................................................ 15
A ÁREA DE BUFFER .................................................................................................................................................. 16
HIERARQUIA FUNCIONAL..............................................................................................................................................................16
CONTROLANDO A SITUAÇÃO DO REGISTRO ........................................................................................................ 16
TIPOS DE BLOCOS .................................................................................................................................................... 17
REVISANDO A SITUAÇÃO DO REGISTRO....................................................................................................................................17
AÇÕES QUE CAUSAM A MENSAGEM...........................................................................................................................................18
NAVEGAÇÃO .............................................................................................................................................................. 19
SEQÜÊNCIA DE NAVEGAÇÃO .......................................................................................................................................................19
ESTILO DE NAVEGAÇÃO ...............................................................................................................................................................19
MODIFICANDO AS CARACTERÍSTICAS DOS REGISTROS .................................................................................... 20
LIGANDO O BLOCO AO DATABASE ......................................................................................................................... 21
CRIANDO UM BLOCO A PARTIR DE UM PROCEDIMENTO.................................................................................... 22
O PACOTE PFUNC ..........................................................................................................................................................................22
DEFININDO UM BLOCO DE DADOS DO TIPO PROCEDIMENTO ................................................................................................24
COMENTÁRIOS RELATIVOS A PROCEDIMENTOS......................................................................................................................28
RESTRIÇÕES RELATIVAS AOS TIPOS DE BLOCOS ...................................................................................................................28
RETORNANDO VALORES ......................................................................................................................................... 28
CAPÍTULO 3: INTERFACE VISUAL ............................................................................................................ 29
ITENS .......................................................................................................................................................................... 30
PROPRIEDADES COMUNS ............................................................................................................................................................30
ITEM DE TEXTO (TEXT ITEM) ........................................................................................................................................................33
ITEM DE EXIBIÇÃO (DISPLAY ITEM) .............................................................................................................................................33
GRUPO DE RÁDIOS (RADIO GROUP) ...........................................................................................................................................33
BOTÃO DE RÁDIO (RADIO BUTTON) ............................................................................................................................................33
ITEM DA LISTA (LIST ITEM)............................................................................................................................................................34
IMAGEM (IMAGE) ............................................................................................................................................................................35
TECLA(PUSH BUTTON) ..................................................................................................................................................................35
ÍNDICE I
CAIXA DE VERIFICAÇÃO (CHECK BOX) .......................................................................................................................................36

DEFININDO PROMPTS .............................................................................................................................................. 37
CAPÍTULO 4: CANVAS E WINDOWS ......................................................................................................... 38
JANELAS (WINDOWS) ............................................................................................................................................... 38
CANVAS...................................................................................................................................................................... 40
CANVAS DE CONTEÚDO (CONTENT)...........................................................................................................................................41
CANVAS BARRA DE FERRAMENTAS (TOOLBAR) .......................................................................................................................41
CANVAS EMPILHADO (STACK)......................................................................................................................................................42
CANVAS TAB (TAB).........................................................................................................................................................................42
CAPÍTULO 5: O EDITOR DE LAYOUT........................................................................................................ 43
QUADRO (FRAME) ..................................................................................................................................................... 43
A JANELA DO EDITOR DE LAYOUT.......................................................................................................................... 45
WORKSPACE...................................................................................................................................................................................45
BARRA DE TÍTULO(TITLE BAR) .....................................................................................................................................................45
RÉGUAS (RULERS).........................................................................................................................................................................45
GUIAS...............................................................................................................................................................................................45
GRID .................................................................................................................................................................................................45
LINHA INDICATIVA DE SITUAÇÃO (STATUS LINE) ......................................................................................................................45
AS BARRAS DE FERRAMENTAS .............................................................................................................................. 46
A BARRA DE FERRAMENTAS HORIZONTAL SUPERIOR ............................................................................................................46
A BARRA DE FERRAMENTAS HORIZONTAL INFERIOR..............................................................................................................47
A BARRA DE FERRAMENTAS VERTICAL OU PALETA DE FERRAMENTAS ..............................................................................48
MANIPULANDO UMA CANVAS NO EDITOR DE LAYOUT........................................................................................ 51
MOSTRAR OU ESCONDER A CANVAS .........................................................................................................................................51
REDIMENSIONAR A CANVAS ........................................................................................................................................................51
MUDAR OS ATRIBUTOS VISUAIS DA CANVAS ............................................................................................................................51
MOSTRAR OU ESCONDER O VIEWPORT ....................................................................................................................................51
MOVER O VIEWPORT.....................................................................................................................................................................51
POSICIONAR CANVAS(EMPILHADA OU TAB) SOBRE CANVAS DE CONTEÚDO .....................................................................51
MANIPULANDO ITENS NO EDITOR DE LAYOUT..................................................................................................... 52
CRIANDO ITENS..............................................................................................................................................................................52
MARCANDO O CONTEXTO PARA UM BLOCO .............................................................................................................................52
MOVER ITENS .................................................................................................................................................................................52
REDIMENSIONANDO OBJETOS NA CANVAS...............................................................................................................................52
ALINHANDO OBJETOS NA CANVAS .............................................................................................................................................53
OBTER AS PROPRIEDADES DE UM ITEM ....................................................................................................................................53
MANIPULANDO BOILERPLATES NO EDITOR DE LAYOUT .................................................................................... 54
BOILERPLATE DE TEXTO ..............................................................................................................................................................54
BOILERPLATE GRÁFICO ................................................................................................................................................................54
AÇÕES COMUNS AOS OBJETOS DE LAYOUT........................................................................................................ 55
ATRIBUINDO FONTE.......................................................................................................................................................................55
MODIFICANDO A LINHA .................................................................................................................................................................55
ALINHAMENTO E ESPACEJAMENTO............................................................................................................................................55
SELEÇÃO DE UM OU VÁRIOS OBJETOS......................................................................................................................................55
OPERAÇÕES ...................................................................................................................................................................................56
ASSOCIAÇÃO PROMPT – ITEM .....................................................................................................................................................56
CAPÍTULO 6: EVENTOS E GATILHOS (TRIGGERS) ................................................................................ 57
CONCEITOS ............................................................................................................................................................... 57
EVENTOS.........................................................................................................................................................................................57
GATILHOS(TRIGGERS)...................................................................................................................................................................57
ESCOPO DE UM GATILHO (TRIGGER) .................................................................................................................... 58
ITEM .................................................................................................................................................................................................58
BLOCO .............................................................................................................................................................................................58
MÓDULO ..........................................................................................................................................................................................58
ORDEM DE EXECUÇÃO .................................................................................................................................................................58
RESTRIÇÕES...................................................................................................................................................................................58
CRIANDO GATILHOS (TRIGGERS) ........................................................................................................................... 59
ÍNDICE II
O EDITOR DE PL/SQL .....................................................................................................................................................................59

CLASSIFICAÇÃO DOS GATILHOS (TRIGGERS) ...................................................................................................... 60
CLASSIFICAÇÃO POR NOME.........................................................................................................................................................60
CLASSIFICAÇÃO POR CATEGORIA FUNCIONAL ........................................................................................................................61
ROTINAS PRÉ-DEFINIDAS .............................................................................................................................................................61
GATILHOS PARA VALIDAÇÃO .......................................................................................................................................................62
GATILHOS PARA PROCESSAMENTO DO BLOCO .......................................................................................................................63
GATILHOS ASSOCIADOS À INTERFACE ......................................................................................................................................64
GATILHOS ASSOCIADOS A UMA CONSULTA ..............................................................................................................................67
GATILHOS ASSOCIADOS À NAVEGAÇÃO....................................................................................................................................68
GATILHOS ASSOCIADOS AO RELACIONAMENTO ENTRE BLOCOS (MASTER-DETAIL) ........................................................69
GATILHOS ASSOCIADOS AO CONTROLE DE MENSAGENS......................................................................................................70
GATILHOS ASSOCIADOS À INTERFACE COM O BANCO DE DADOS .......................................................................................71
PROPRIEDADES DOS GATILHOS (TRIGGERS) ...................................................................................................... 74
FALHA NOS GATILHOS ............................................................................................................................................. 74
EDIÇÃO DE PL/SQL ................................................................................................................................................... 75
INDENTAÇÃO AUTOMÁTICA..........................................................................................................................................................75
INDENTAÇÃO MANUAL ..................................................................................................................................................................75
CORES .............................................................................................................................................................................................75
SELEÇÃO .........................................................................................................................................................................................75
CÓPIA E MOVIMENTAÇÃO DE TEXTOS .......................................................................................................................................75
SPLIT DA ÁREA DE EDIÇÃO ..........................................................................................................................................................76
IMPRESSÃO, EXPORTAÇÃO E IMPORTAÇÃO .............................................................................................................................76
OPÇÃO DESFAZER.........................................................................................................................................................................76
PALETA DE SINTAXE................................................................................................................................................. 76
CAPÍTULO 7: RELACIONAMENTO MASTER-DETAIL .............................................................................. 77
O OBJETO RELAÇÃO (RELATION) ........................................................................................................................... 77
PROPRIEDADES DA RELAÇÃO ................................................................................................................................ 78
OS GATILHOS (TRIGGERS) DE UMA RELAÇÃO ..................................................................................................... 80
GATILHOS ASSOCIADOS AO RELACIONAMENTO ENTRE BLOCOS (MASTER-DETAIL) ........................................................80
CAPÍTULO 8: VARIÁVEIS E ROTINAS....................................................................................................... 81
ROTINAS..................................................................................................................................................................... 82
ROTINAS LOCAIS............................................................................................................................................................................82
ROTINAS ARMAZENADAS NO BANCO DE DADOS......................................................................................................................83
ROTINAS ARMAZENADAS EM BIBLIOTECAS (LIBRARIES) ........................................................................................................85
EMPACOTAMENTO DA LÓGICA ....................................................................................................................................................85
VARIÁVEIS.................................................................................................................................................................. 86
VARIÁVEIS LOCAIS.........................................................................................................................................................................86
ITENS FORA DE CANVAS...............................................................................................................................................................87
VARIÁVEIS DE PACOTE NO FORM ...............................................................................................................................................87
PARÂMETROS.................................................................................................................................................................................88
VARIÁVEIS GLOBAIS ......................................................................................................................................................................89
COMPARANDO AS VARIÁVEIS ......................................................................................................................................................89
VARIÁVEIS DE SISTEMA ................................................................................................................................................................90
DATABASE TRIGGERS.............................................................................................................................................. 91
CAPÍTULO 9: ALERTAS, ATRIB. VISUAIS E EDITORES.......................................................................... 92
ALERTAS .................................................................................................................................................................... 92
ATRIBUTOS VISUAIS (VISUAL ATTRIBUTES).......................................................................................................... 94
EDITORES .................................................................................................................................................................. 95
CAPÍTULO 10 : LOVS E RECORD GROUPS ............................................................................................. 97
LISTA DE VALORES (LIST OF VALUES) - LOVS ...................................................................................................... 97
CRIANDO UMA LOV ........................................................................................................................................................................97
PROPRIEDADES DA LOV ...............................................................................................................................................................99
ASSOCIANDO A LOV A UM ITEM...................................................................................................................................................99
MAPEANDO NA LOV AS COLUNAS DO RECORD GROUP........................................................................................................100
CONTROLANDO A APRESENTAÇÃO DA LOV............................................................................................................................100
ÍNDICE III
RECOMENDAÇÕES A RESPEITO DE LOVS ...............................................................................................................................101

A COLUNA DE PESQUISA ............................................................................................................................................................101
RECORD GROUPS................................................................................................................................................... 101
RECORD GROUPS................................................................................................................................................... 102
QUERY RECORD GROUP ............................................................................................................................................................102
STATIC RECORD GROUP ............................................................................................................................................................103
CRIANDO LOVS A PARTIR DOS RECORD GROUPS .................................................................................................................103
NON-QUERY RECORD GROUP ...................................................................................................................................................103
CAPÍTULO 11 : LOBS E OBJETOS .......................................................................................................... 104
LOBS ......................................................................................................................................................................... 104
OBJETOS.................................................................................................................................................................. 105
CAPÍTULO 12: ÁRVORE HIERÁRQUICA ................................................................................................. 107
CRIANDO UMA ÁRVORE HIERÁRQUICA ............................................................................................................... 107
PREENCHENDO UMA ÁRVORE HIERÁRQUICA.........................................................................................................................108
CAPÍTULO 13: A DEPURAÇÃO DO PL/SQL............................................................................................ 109
A JANELA DE DEPURAÇÃO .................................................................................................................................... 109
MARCANDO UM PONTO DE INTERRUPÇÃO ........................................................................................................ 111
BREAKPOINT.................................................................................................................................................................................111
TRIGGER........................................................................................................................................................................................112
ACOMPANHANDO UMA DEPURAÇÃO ................................................................................................................... 113
DEPURANDO COM UM PONTO DE INTERRUPÇÃO ..................................................................................................................113
DEPURANDO COM UM TRIGGER................................................................................................................................................114
CRIANDO UMA INTERRUPÇÃO ESTÁTICA............................................................................................................ 114
O FORMS RUNTIME DIAGNOSTICS ....................................................................................................................... 115
SINTAXE DE GRAVAÇÃO DAS INFORMAÇÕES .........................................................................................................................115
CONSTRUÇÃO DE UM EXEMPLO ...............................................................................................................................................117
CAPÍTULO 14: PACOTES, VBX, OCX E OLE .......................................................................................... 118
VBX ,OCX E OLE ...................................................................................................................................................... 118
OLE, OCX E VBX NO FORM BUILDER.........................................................................................................................................118
VBX.................................................................................................................................................................................................119
OLE CONTAINER...........................................................................................................................................................................120
OCX (ACTIVEX CONTROL)...........................................................................................................................................................122
PACOTES EMBUTIDOS ........................................................................................................................................... 124
STANDARD EXTENSIONS ............................................................................................................................................................124
DDE ................................................................................................................................................................................................124
DEBUG ...........................................................................................................................................................................................124
OLE2...............................................................................................................................................................................................124
ORA_FFI.........................................................................................................................................................................................124
ORA_NLS .......................................................................................................................................................................................125
ORA_PROF ....................................................................................................................................................................................125
TEXT_IO .........................................................................................................................................................................................126
TOOL_ENV.....................................................................................................................................................................................126
TOOL_ERR.....................................................................................................................................................................................127
TOOL_RES.....................................................................................................................................................................................127
PECS ..............................................................................................................................................................................................127
VBX.................................................................................................................................................................................................127
WEB................................................................................................................................................................................................127
FORMS_OLE..................................................................................................................................................................................127
STANDARD ....................................................................................................................................................................................127
CAPÍTULO 15: CARACTERÍSTICAS GERAIS.......................................................................................... 128
ESTUDANDO O MÓDULO........................................................................................................................................ 128
PREFERÊNCIAS....................................................................................................................................................... 130
PASTA GERAL ...............................................................................................................................................................................130
PASTA ACESSO (SUBCLASS)......................................................................................................................................................132
PASTA ASSISTENTES (WIZARDS) ..............................................................................................................................................133
PASTA RUNTIME...........................................................................................................................................................................133
ÍNDICE IV
OPÇÕES DE EXECUÇÃO .............................................................................................................................................................135

CAPÍTULO 16: REUSO DE CÓDIGO E PADRONIZAÇÃO ...................................................................... 136
TEMPLATE................................................................................................................................................................ 136
CLASSE DE PROPRIEDADES ................................................................................................................................. 137
USANDO O BOTÃO INCLUIR PROPRIEDADE (ADD PROPERTY).............................................................................................137
USANDO O BOTÃO CLASSE DE PROPRIEDADE (PROPERTY CLASS)...................................................................................137
OS BOTÕES COPIAR (COPY PROPERTIES) E COLAR (PASTE PROPERTIES) ......................................................................137
O BOTÃO DELETAR PROPRIEDADE (DELETE PROPERTY).....................................................................................................137
O BOTÃO INTERSEÇÃO/UNIÃO (INTERSECTION/UNION) ........................................................................................................138
O BOTÃO CONGELAR / DESCONGELAR (FREEZE/UNFREEZE)..............................................................................................138
GATILHO EM UMA CLASSE DE PROPRIEDADES ......................................................................................................................138
ATRIBUINDO A CLASSE DE PROPRIEDADES............................................................................................................................138
O BOTÃO HERDAR .......................................................................................................................................................................139
BIBLIOTECA DE OBJETOS...................................................................................................................................... 140
CRIANDO A BIBLIOTECA DE OBJETOS ......................................................................................................................................140
USANDO OBJETOS DA BIBLIOTECA...........................................................................................................................................140
MODIFICANDO OS OBJETOS DE UMA BIBLIOTECA DE OBJETOS .........................................................................................141
SMARTCLASS................................................................................................................................................................................141
COPIANDO DADOS DE OUTRA APLICAÇÃO......................................................................................................... 142
REFERÊNCIA.................................................................................................................................................................................142
CÓPIA.............................................................................................................................................................................................142
GRUPO DE OBJETOS (OBJECT GROUP) .............................................................................................................. 142
CONCLUSÕES ......................................................................................................................................................... 142
CAPÍTULO 17: O MÓDULO LIBRARY ...................................................................................................... 143
CRIANDO UMA BIBLIOTECA (LIBRARY) ................................................................................................................ 143
ASSOCIANDO UMA BIBLIOTECA A UMA APLICAÇÃO .......................................................................................... 143
USO DE VARIÁVEIS EM BIBLIOTECAS .................................................................................................................. 144
CONSIDERAÇÕES SOBRE ARMAZENAMENTO .................................................................................................... 144
CAPITULO 18: O MÓDULO MENU............................................................................................................ 145
OBJETOS DE UM MÓDULO MENU ......................................................................................................................... 145
CRIANDO ITENS DE MENU VIA NAVEGADOR ...................................................................................................... 146
PROPRIEDADES DOS ITENS DE MENU ................................................................................................................ 146
CRIANDO ITENS DE MENU VIA EDITOR................................................................................................................ 147
ASSOCIANDO UM MÓDULO DE MENU A UM FORM............................................................................................. 148
DEMAIS PROPRIEDADES RELATIVAS A MENU.........................................................................................................................148
CALL_FORM X NEW_FORM .........................................................................................................................................................149
CARACTERÍSTICAS PARTICULARES DE ALGUNS ITENS DE MENU .................................................................. 150
CHECK MENU ITEMS....................................................................................................................................................................150
RADIO MENU ITEMS .....................................................................................................................................................................150
RESTRIÇÃO ...................................................................................................................................................................................150
PROPRIEDADES DE UM MENU .............................................................................................................................. 150
PROPRIEDADES DO MÓDULO MENU.................................................................................................................... 151
PARÂMETROS PARA MENU ................................................................................................................................... 152
PARÂMETROS PRÉ DEFINIDOS..................................................................................................................................................152
PARÂMETROS DO USUÁRIO .......................................................................................................................................................152
CAPÍTULO 19: RELATÓRIOS (REPORTS) .............................................................................................. 153
ÍNDICE V
CAPÍTULO 1: CONHECENDO A FERRAMENTA
O Pacote Developer 6i
A ferramenta de desenvolvimento Form Builder 6i faz parte de um pacote de ferramentas para
desenvolvimento chamado Oracle Developer 6i. Este pacote é composto de 8 ferramentas:
• Form Builder – é a ferramenta para a construção de aplicações online para acesso e

atualização de uma base de dados Oracle.
• Report Builder – é a ferramenta para a construção de relatórios que façam acesso a uma
base de dados Oracle.
• Procedure Builder – é a ferramenta que nos auxilia no desenvolvimento de programas

PL/SQL, tanto no ambiente cliente (em bibliotecas de programas compartilhadas por
aplicações Form ou Reports) quanto no ambiente servidor (criação de procedures, functions,
packages e database triggers), permitindo uma depuração passo a passo das aplicações
criadas.
• Graphics Builder – é a ferramenta que permite que visualizamos os dados do banco de

dados de forma gráfica.
• Project Builder – esta é uma ferramenta integradora e organizadora, permitindo que

associemos as diversas aplicações que componham um projeto de desenvolvimento em uma
hierarquia manipulável.
• Query Builder – é uma ferramenta auxiliar na construção de consultas ao banco de dados.

Possui uma interface gráfica e intuitiva que nos permite rápida e facilmente a montagem de
queries para a recuperação de informações.
• Schema Builder – esta ferramenta nos auxilia na criação, cópia, modificação e remoção de
objetos (e relacionamentos) do banco de dados.
• Translation Builder – esta é uma ferramenta para suporte e gerenciamento no processo de

conversão de aplicações Oracle para uma das linguagens suportadas. Suporta a conversão de
arquivos do tipo .fmb, .ogd, .rdf, .res e .msg.
Este pacote contém ferramentas que abrangem todas as áreas necessárias ao desenvolvimento de um
sistema: aplicações online, batch, relatórios, gráficos e, ainda, uma ferramenta para controle do ambiente.
CAPÍTULO 1: CONHECENDO A FERRAMENTA- 1

A Ferramenta
O desenvolvimento de uma aplicação Online envolve diversas etapas, dentre elas: construção da
aplicação, compilação, execução e depuração.
A ferramenta Form Builder é composta de 4 executáveis para cumprimento destas etapas:
• IFBLD60 – Form Builder – Este é o aplicativo para desenvolvimento e compilação individual de

uma aplicação. Gera arquivos de quatro categorias: FMB / FMX (fonte e executável Form),
MMB / MMX (fonte e executável Menu), PLL (PL/SQL Library) e OLB (Object Library).
• IFRUN60 – Form Runtime – Este é o aplicativo para execução das aplicações desenvolvidas
(Form, Menus e Libraries PL/SQL).
• IFCMP60 – Form Compiler – Este aplicativo permite a conversão de aplicações construídas

em Forms 4.5 para Form Builder 5.0 (versão atual), convertendo a PL/SQL versão 1.0 para a
versão 2.3 e, ainda, permite a compilação em batch de lotes de programas.
• IFDBG60 – É acionado indiretamente através do Form Runtime ou do Form Builder para

depuração da aplicação.
Considerações Gerais
A ferramenta Form Builder é capaz de construir quatro tipos de “módulos” diferentes:
Módulo Form – que consiste da aplicação online, contendo lógicas de atualização, telas, botões, itens,
etc. O fonte de um módulo Form possui a extensão FMB e o executável FMX.
Módulo Menu – que consiste de um conjunto de submenus e lógicas para acionamento dos diversos
módulos Form ou de outros submenus, execução de aplicações PL/SQL em batch, acionamento de
gráficos, etc. O fonte de um módulo Menu possui a extensão MMB e o executável MMX.
Módulo PL/SQL Library – que consiste de um conjunto de programas PL/SQL que podem ser
compartilhados por diversas aplicações Form (ou Report) que executam no ambiente. Possui apenas
um tipo de arquivo cuja extensão é PLL.
Object Library – que consiste de um conjunto de objetos internos do Form que podem ser definidos uma
única vez e utilizados em outras aplicações. Esta biblioteca de objetos auxilia o desenvolvedor na
criação de padrões.

Ativando o Form Builder

Para acionarmos a execução do Form Builder, devemos usar o botão Iniciar do Windows, pasta
Programas, pasta Oracle Developer 6i e escolher a opção Form Builder.
Fig. 1 – Bem-Vindo ao Form Builder
A primeira tela apresentada contém:
Um conjunto de opções para a construção de aplicações, sob o grupo Projetando.
Um outro conjunto de opções para apresentação da ferramenta sob o grupo Aprendendo.
Antes da construção da primeira aplicação veremos como navegar na ferramenta.
Por este motivo escolheremos a opção “Desenvolver um novo Form manualmente”.

O Navegador de Objetos (Object Navigator)
Ao aceitarmos o diálogo anterior é apresentada uma janela

chamada de Navegador de Objetos ou Object Navigator,
que nos dá uma visão de todos os componentes da
ferramenta e das aplicações criadas.
Fig. 2 – Navegador de Objetos

Os nós principais do navegador:
Quando um determinado nó aparece com o símbolo – (menos) à esquerda indica que este nó está
expandido. Quando aparece com o símbolo + (mais) indica que o nó está contraído, ou seja, existem
elementos subordinados a este nó que não estão visíveis.
• Forms – subordinado a este nó estarão os módulos de Form que viermos a desenvolver.
• Menus – subordinado a este nó estarão os módulos de Menu que viermos a desenvolver. Na

figura 2 não existe nenhum módulo aberto, portanto o nó está vazio. Não tem nenhum símbolo
preenchendo o nó.
• Bibliotecas PL/SQL – subordinado a este nó estará o módulo Library de PL/SQL que viermos
a desenvolver.
• Bibliotecas de Objetos – subordinado a este nó estará (ou estarão) a biblioteca de objetos

padrões que criarmos e desejamos reutilizar.
• Pacotes Embutidos – subordinado a este nó existem diversos pacotes (packages) contendo

diversas rotinas que usaremos no desenvolvimento de aplicações.
• Objetos do Banco de Dados – subordinado a este nó serão visualizados os diversos objetos

do banco de dados que o usuário ao qual estamos conectados tem acesso. Atualmente o nó
está vazio pois não estabelecemos conexão com o banco.
A seguir veremos as diversas ações que podemos realizar no Navegador de Objetos:
EXPANDIR OU CONTRAIR
Para expandir um nó ou contraí-lo basta que pressionemos o mouse sobre o símbolo ( + ) para
expandi-lo ou sobre o símbolo ( - ) para contrai-lo.
As ações de expansão e contração podem ser feitas com os botões expandir e contrair da barra
de ferramentas.
Fig. 3
A figura 3 apresenta os botões que realizam as ações de expansão e contração na barra de ferramentas.

CRIAR OU DELETAR
A criação de qualquer elemento no Form Builder pode ser feita utilizando-se o botão Criar,
apresentado na figura 4.
Fig. 4
Para realizarmos esta ação basta que selecionemos o nó ou um objeto do mesmo tipo daquele que
desejamos criar e pressionemos o botão Criar.
Para removermos um elemento, devemos selecioná-lo e pressionar a ferramenta Deletar ou pressionar o

botão Del do teclado.
COPIAR, RECORTAR E COLAR

As ações de copiar , recortar e colar presentes na barra de ferramentas se aplicam a elementos
do navegador.
Fig. 5
Com estas ferramentas podemos:
• mover um elemento de um ponto para outro - quando selecionamos um elemento,

pressionamos o botão Recortar, movimentamos o cursor para o destino desejado e
pressionamos o botão Colar.
• copiar um elemento de um ponto para outro - quando selecionamos um elemento,

pressionamos o botão Copiar, movimentamos o cursor para o destino desejado e
pressionamos o botão Colar.
Como restrições temos:
• Os elementos devem ser colados em localização apropriada na hierarquia do módulo. Por

exemplo, um alerta pode ser copiado de um módulo para outro, mas sempre subordinado ao
nó Alerta.
• Somente elementos de mesmo tipo podem ser copiados em conjunto.
EXECUTAR E EXECUTAR COM DEPURAÇÃO

A execução do módulo Form ativo, ou seja, aquele em que temos algum elemento selecionado
ocorre quando pressionamos o botão Executar.
Fig. 6
Na figura 6 apresentamos os três botões ligados à execução da aplicação:
• Botão Executar – aciona o Forms Runtime para execução da aplicação corrente.
• Botão Executar Depuração – aciona o Forms Runtime com o auxílio do depurador que
permitirá que acompanhemos passo a passo cada ação a ser efetuada.
• Botão Executar Form Web – aciona a execução da aplicação em ambiente Web (só
disponível em ambiente WindowsNT).

NOVO, ABRIR E SALVAR

Este último conjunto de botões realiza ações sobre os módulos. A ação se dá de acordo com o
elemento que tivermos selecionado no momento. Por exemplo um módulo Form ou qualquer
elemento subordinado a ele:
• Botão Novo - criaremos um novo módulo Form.

Fig. 7
• Botão Salvar - efetuaremos a salva do módulo corrente.
• Botão Abrir - serão apresentados outros arquivos com extensão FMB (Form) para que
façamos a escolha daquele que desejamos abrir.
Quando salvamos uma aplicação pela primeira vez, o

Form Builder nos apresenta o diálogo da figura 8 para que
determinemos o diretório onde efetuaremos a salva e o
nome desejado para o módulo.
A partir do momento que definirmos o diretório e o nome

do módulo, este diálogo não será mais apresentado.
Fig. 8 - Diálogo Salvar Como
Após a salva, o nome do módulo (no Navegador) é alterado e na parte inferior da janela do Form Builder
aparece não só o nome do módulo ativo como também o nome com que este arquivo está salvo em disco.
LOCALIZAR
Podemos usar o pesquisador do Navegador para
encontrar elementos e nós dentro do Navegador.
Para iniciarmos uma busca devemos digitar a string que

desejamos procurar no campo Localizar.
A cada caracter que digitado o Form Builder movimenta

o cursor para o próximo elemento compatível.
Fig. 9 - Localizar do Navegador de Objetos
Quando necessário podemos utilizar as duas lanternas posicionadas ao lado do campo Localizar para
efetuar uma busca para frente ou para trás.
NAVEGANDO NA HIERARQUIA
Do lado esquerdo da janela do Navegador existe um
campo que apresenta o nome do elemento atualmente
selecionado.
Ao abrirmos a lista deste campo, verificaremos que ele

contém todos os ancestrais hierarquicamente superiores
em relação ao objeto selecionado.
Ele apresenta a árvore de subordinação do elemento

selecionado.
Fig. 10 - Árvore de Subordinação do Navegador
Podemos escolher qualquer elemento desta hierarquia, bastando que façamos a seleção do elemento
desejado, clicando o mouse sobre um dos nomes na lista.

PAINÉIS DO NAVEGADOR
Podemos dividir o navegador em múltiplos painéis
horizontalmente ou verticalmente.
Para tal devemos pressionar e arrastar o mouse sobre

o ponto de divisão horizontal ou vertical mostrado na
figura 11.
Só podemos dividi-lo num sentido (vertical ou

horizontal) de cada vez.
Podemos realizar múltiplas subdivisões, desde que

num mesmo sentido.
Fig. 11 - Painéis do Navegador
ALTERANDO O NOME DE UM ELEMENTO
A modificação do nome de qualquer elemento poderá ser

feita através de sua janela de propriedades, porém esta
ação também pode ser feita no navegador.
Na figura 12 apenas duas letras da palavra Alerta2 estão

selecionadas e parte da palavra foi removida.
Para efetivarmos a modificação basta pressionarmos o

mouse sobre qualquer outro nó para que seja encerrado
o estado de digitação.
Fig. 12 - Alteração de Nome pelo Navegador
O Menu do Form Builder

Muitas das ações realizadas com os botões estão presentes nos menus apresentados pelo Form Builder.
Freqüentemente realizaremos uma ação já conhecida com uma opção de menu em vez do botão
correspondente.

Criando uma Aplicação

Neste tópico construiremos, juntamente com o instrutor, nossa primeira aplicação usando o Form Builder.
Bloco de Dados
O bloco é a estrutura básica e fundamental do Form Builder. É o centro de toda a ação. É em torno dele
que todas as ações se processam.
Podemos dizer que um bloco é um repositório (ou container) de itens.
Um bloco não tem representação visual. Um usuário visualiza itens, pois são eles que são apresentados
em uma tela, porém hierarquicamente os itens estão subordinados a blocos, pertencem a blocos e estão
sujeitos às ações que efetuarmos para o bloco que o contém.
Um bloco pode estar ligado a uma tabela no banco de dados. Quando isto ocorre existe uma paridade
entre bloco e tabela, registro e linha da tabela e entre item e coluna da tabela.
Toda a funcionalidade do Form gira em torno do bloco. Conheceremos esta funcionalidade aos poucos.
Criando o Bloco de Dados de uma Aplicação

Acompanhe o instrutor na criação da aplicação:
1. Escolher a opção Assistente de Bloco de Dados do menu Ferramentas do Form Builder.
2. Um bloco de dados pode se basear em uma tabela (ou view) ou em uma stored procedure.
Escolheremos, a criação de um bloco baseado em uma tabela.
3. No próximo diálogo devemos escolher a tabela ou view na qual desejamos basear o bloco.
4. Para que nos seja apresentada a lista de tabelas ou views disponíveis, devemos pressionar o
botão pesquisar.
5. Caso não tenhamos feito logon no banco de dados até este momento será necessário que o
façamos agora. Neste caso devemos informar o nome do usuário, senha e a string de conexão
com o banco de dados.
6. O próximo diálogo permite o estabelecimento de uma restrição sobre a lista de objetos a ser
apresentada:
• Usuário Atual – Apresenta objetos do banco de dados pertencentes unicamente ao usuário

que estabeleceu a conexão.
• Outros Usuários – Apresenta objetos do banco de dados pertencentes a outros usuários.

Naturalmente o usuário que estabeleceu a conexão deverá ter privilégios de acesso sobre os
objetos a serem selecionados.
• Se simultaneamente marcarmos as duas opções serão apresentados objetos pertencentes ao

usuário atual e aos demais usuários do banco de dados.
• Tabelas – Os objetos apresentados são tabelas.
• Views – Os objetos apresentados são views.
• Sinônimos – Os objetos apresentados são sinônimos de outras tabelas, views ou sinônimos.

• Se simultaneamente marcarmos mais de uma opção, veremos objetos dos tipos marcados.

7. O próximo diálogo apresenta a lista de tabelas presentes no banco de dados e pertencentes ao

usuário atual.
Se a lista de elementos fosse muito grande poderíamos preencher algumas letras da tabela
desejada no campo Loc. (superior) e posteriormente pressionar o botão Loc. para que uma lista
reduzida fosse fornecida.
8. Nosso próximo passo é selecionar a tabela Func e pressionar o botão OK. Retornamos, desta
forma, ao diálogo do passo 3, porém com os campos “Tabela ou view” e “Colunas Disponíveis”
preenchidos.
9. Nosso próximo passo será definir quais as colunas que daremos manutenção nesta aplicação. As
colunas (cd_mat, nm_func, cd_depto, nr_cargo, in_sexo, vl_sal, dt_nasc) devem ser transferidas
para o campo “Itens do Banco de Dados”.
Esta transferência é feita quando selecionamos a coluna no campo à esquerda e pressionamos o

botão ( > ).
Se desejássemos selecionar todas as colunas poderíamos pressionar o botão ( >> ), sem haver
necessidade de selecionar nenhuma coluna.
O botão Renovar presente acima do campo Colunas Disponíveis, reordena a lista de acordo com a
ordem das colunas no banco de dados.
A ordem que as colunas são definidas no campo Itens do Banco de Dados será a ordem default
para a construção da tela, que passaremos a chamar de Canvas.
O último campo da tela “Impor integridade de dados” indica que as regras de integridade presentes
do banco de dados também serão asseguradas a nível de ambiente cliente.
10. É apresentado o último diálogo deste assistente. Neste diálogo podemos acionar o assistente de
layout para construção da Canvas (tela) ou podemos encerrar e posteriormente acioná-lo.
Interromperemos o processo de criação da aplicação para analisar o que aconteceu no Navegador.
A figura 13 apresenta o resultado da geração do bloco.
Existem 3 nós subordinados ao bloco de dados Func: Gatilhos

(Triggers), Itens e Relações (Relations).
No navegador o nó “Itens” não aparece presente na hierarquia

principal. Isto ocorre porque todo e qualquer item deve,
obrigatoriamente, estar subordinado a um bloco. Seja este item
de trabalho, associado a uma coluna do banco de dados, um
botão, etc.
Fig. 13 - Elementos na hierarquia do Navegador
Se expandirmos o nó de um dos itens encontramos novamente o nó Gatilhos (Triggers). Na hierarquia

principal também existe um nó Gatilhos (Triggers).
É subordinado a este tipo de nó que incluiremos os trechos de PL/SQL responsáveis pela lógica de
programação (críticas, movimentação, atribuição, etc).

Criando o Layout de uma Aplicação

Acione o Assistente de Layout através do menu Ferramentas.
1. Após o diálogo inicial, devemos determinar a canvas em que os itens do bloco Func serão criados.
Neste diálogo temos 3 campos para preencher.
• No primeiro (Canvas) devemos selecionar entre uma canvas já existente ou uma nova canvas.
• No segundo campo devemos escolher o tipo de Canvas (tela) que desejamos criar. Nos são
apresentadas 5 opções: Conteúdo (Content), Barra de Ferramentas Vertical (Vertical ToolBar),
Barra de Ferramentas Horizontal (Horizontal ToolBar), Sobreposto (Stack) e Guia (Tab).
• O terceiro campo fica desabilitado quando definimos no segundo campo qualquer opção
diferente de Guia (Tab).
2. No diálogo seguinte escolheremos quais os campos serão visíveis na Canvas. Se pressionarmos o

botão ( >> ) todos os itens serão selecionados.
Ao selecionarmos um elemento do campos “Itens Exibidos” o campo Tipo de Item ficará habilitado,
permitindo que façamos a especificação de como desejamos que o item seja apresentado na
Canvas.
3. No próximo diálogo determinaremos os labels ou prompts a serem usados na construção da

Canvas.
4. Neste diálogo faremos a escolha do tipo de layout mais adequado: Form ou Tabular.
5. No diálogo seguinte devemos definir um título para o conjunto de registros apresentados, a

quantidade de registros apresentados, a distância entre os registros e a presença ou não da barra
de rolagem de registros.
6. O próximo diálogo encerra a preparação do layout.
Quando o Assistente conclui, nos é mostrado o Editor de Layout contendo todos os itens pertencentes ao
bloco Func organizados numa área de tela a que chamamos Canvas.
Retorne agora ao navegador e observe a criação de um objeto subordinado ao nó Canvases.

Executando a aplicação criada

Para que a aplicação seja compilada e entre em execução, devemos pressionar o botão Executar na barra
de ferramentas do Navegador.
Fig. 14 - Janela de Execução
A figura 14 mostra a janela de execução. Observe que foi acionado o Form Runtime (veja o título da janela
principal) para executar a aplicação compilada.
Abra o Windows Explorer e verifique no seu diretório de trabalho que foi criado um arquivo com extensão
FMX com o mesmo nome da sua aplicação (FMB).
As ações presentes na barra de ferramentas existem também no menu apresentado e correspondem às

ações realizadas com mais freqüência.
INCLUSÃO
Quando um Form entra em execução, por default, a ação esperada é a de inclusão, portanto não
precisamos efetuar nenhuma ação adicional para incluir. Basta que façamos o preenchimento dos campos.
Após o preenchimento podemos ou não salvar o registro, isto é, gravá-lo no banco de dados. Para salvar
podemos usar o botão salvar da barra de ferramentas ou usar a opção Salvar do menu Ação.
Faça os seguintes testes :
• Inclua dois registros e salve apenas no fim das duas inclusões.

• Inclua mais um registro(sem salvar) e efetue navegação entre os registros apresentados.
• Inclua um registro com código de departamento "XXX".
• Salve. O que acontece ?

CONSULTA
A consulta pode ser iniciada de duas formas:
• Botão Executar Consulta da barra de ferramentas ou opção Executar do menu Consultar -

faremos a consulta a todas as linhas da tabela Func.
• Botão Entrar com Consulta da barra de ferramentas ou com a opção Entrar do menu
Consultar - será apresenta a tela de execução com os campos vazios para que o usuário
preencha uma restrição às linhas consultadas, na forma: <valor do campo> ou <operador>
<valor> ou [%]<valor> [%].
A navegação entre os registros consultados poderá ser feita:
• Opções: Anterior e Próximo da barra de ferramentas.
• Opções: Anterior e Próximo do menu Gravar.
Outras Opções do Menu Consultar:
• Cancelar – para cancelar uma consulta em andamento. Esta ação fica habilitada quando
estamos no modo de Enter-Query, ou seja utilizamos a opção Entrar Consulta para definir um
critério de pesquisa. Após a execução da consulta não há necessidade de cancelamento.
• Último Critério – para apresentar o último critério de restrição efetuado. Esta opção também é
apresentada quando estamos no modo de Enter-Query.
• Contar Acertos – para apresentar a quantidade de linhas retornadas de acordo com o critério
efetuado, sem que haja necessidade de realizarmos a consulta. Esta opção deve ser acionada
no lugar da Executar Consulta, após termos preenchido o critério de restrição desejado (Enter-
Query).
• Extrair Próximo Conjunto – Esta opção faz uma operação de Fetch de dados. Quando
realizamos uma consulta, o Form Runtime não lê todas as linhas do banco de dados de uma
única vez, ele faz leituras parciais. Conforme navegamos para os registros seguintes, ele vai
ao banco de dados e efetua novas leituras. Esta opção força uma leitura no próximo conjunto
de registros sem que haja necessidade de navegarmos um a um até lermos todos os registros
do conjunto.

ALTERAÇÃO
O Form Runtime considerará alterado todo registro que for lido e posteriormente modificado, ou mais
precisamente, todo registro lido e modificado além de todo registro incluído, gravado (salvo) e modificado
em seguida.
Desta forma após uma consulta qualquer modificação que venhamos a fazer em um registro será
considerada para alteração no banco de dados.
Para desistimos de uma alteração realizada devemos limpar o registro. Esta ação terá o efeito de cancelar
a atualização prevista para ele.
Para efetuarmos a cópia de uma informação de um registro para outro podemos:
• Usar os botões Recortar, Copiar e Colar (da Barra de Ferramentas) ou estas opções presentes
no menu Editar.
• Usar a opção Duplicar do menu Gravar (com a qual duplicaremos todo o registro).
• Usar a opção Duplicar do menu Campo (com a qual duplicaremos apenas o item em foco).
Outras opções do menu Editar:
• Editar – esta opção apresenta um editor com o conteúdo do campo que tiver o foco, isto é, do
campo que o cursor estiver posicionado. Esta opção é útil quando a coluna correspondente no
banco de dados é muito grande para ser mostrada integralmente na tela. Quando acionamos o
editor podemos visualizar todo o conteúdo do campo. A edição está limitada ao tamanho do
item.
• Exibir Lista – Esta opção exibe a lista de valores para o campo que tiver o foco, se a este
campo tivermos associado uma lista de valores.
EXCLUSÃO
Para que o Form considere uma ação de exclusão no banco de dados deveremos ter consultado um
determinado registro e em seguida o excluído.
A ação de exclusão pode ser acionada na barra de ferramentas ou através da opção Remover do menu
Gravar.
BLOQUEIO
O Form quando faz um consulta e apresenta os registros para o usuário não efetua bloqueio ( Lock ) nas
linhas consultadas.
Esta ação só é realizada se o usuário efetuar alguma modificação na linha ou pressionar o botão de
Remover.
Tão logo uma destas ações ocorra, o Form dispara um bloqueio para o registro corrente. Isto ocorre antes
da ação de salva.
Se desejarmos bloquear uma linha mesmo antes dela ser modificada, podemos realizar esta ação usando
o botão Bloquear Registro ou a opção Travar do menu Gravar.

NAVEGAÇÃO
A navegação de uma aplicação Form ocorre:
• Entre Itens - podemos pressionar a tecla Tab (navegação para frente), Tab+Shift (navegação
para trás) ou podemos utilizar as opções Anterior e Próximo do menu Campo.
• Entre Registros - pode ser feita através dos botões da barra de ferramentas, através da barra
de rolagem, através das opções Anterior e Próximo do menu Gravar (Registro) e, ainda, com
as teclas Seta para Cima e Seta para Baixo do teclado, se o cursor estiver posicionado sobre
um campo do registro.
• Entre Blocos - pode ser feita com os botões da barra de ferramentas ( Bloco Anterior e
Próximo Bloco ) ou com as opções Anterior e Próximo do menu Bloco. Para que esta ação
tenha efeito devemos ter criado mais de um bloco na aplicação.
MENU AJUDA
No menu Ajuda aparecem três opções:
• Ajuda – esta opção apresenta uma tela contendo as propriedades atuais do item que tiver o
foco (de onde o cursor estiver posicionado).
• Teclas – esta opção apresenta uma tela contendo de um lado uma ação e do outro a tecla a
ser acionada para efetuarmos aquela ação. A lista de ações se refere ao conjunto de ações
que realizamos com o menu e com a barra de ferramentas. A tela apresentada é sensível ao
contexto, isto é, haverá uma variação de acordo com a ação em execução (consulta, inclusão,
etc).
• Erro de Exibição – esta opção apresenta a sintaxe do comando de SQL disparado pelo Form
que deu erro de sintaxe e ainda a mensagem recebida do banco de dados.
A mensagem apresentada neste quadro é diferente da mensagem apresentada na linha de rodapé da

página. Isto ocorre porque o Forms, em diversas situações, modifica a mensagem recebida do banco de
dados e exibe sua própria mensagem.
SALVA IMPLÍCITA
O Form Runtime tem controle sobre as modificações que efetuamos sobre os registros. Este controle se
dá a nível de bloco e de Form (aplicação).
Quando precisamos limpar o bloco (ou Form, isto é, todos

os blocos de uma aplicação) e efetuamos modificações
não salvas previamente, o Form Runtime percebe que
existem informações não enviadas para o banco de dados
e apresenta um diálogo questionando se desejamos ou
não efetuar uma salva dos dados modificados.
Fig. 15 - Salva Implícita
A figura 15 apresenta este diálogo. Se pressionarmos Sim é efetuada uma Salva (Commit). Se
pressionarmos Não, todas as modificações são descartadas. Se pressionarmos Cancelar a ação
comandada não é efetuada.
Este diálogo pode aparecer quando efetuamos as ações: Limpar Bloco, Limpar Tudo (Form), Executar
Consulta, Entrar Consulta ou Sair da Aplicação.
CONCLUSÕES
Até o momento não escrevemos uma linha sequer de código, no entanto, a ferramenta já foi capaz de
realizar as operações básicas de inclusão, exclusão, alteração, consulta e navegação.
Nossa tarefa ao longo deste estudo será perceber como modificar esta funcionalidade básica de acordo
com a nossa vontade.

CAPÍTULO 2 : BLOCOS
Neste capítulo trataremos dos blocos e analisaremos a funcionalidade implícita do Form, ou seja, como
ocorre a decisão de uma inclusão, alteração ou exclusão e como este processamento é realizado.
Propriedades
Cada objeto criado em nossa aplicação possui um conjunto
de propriedades que determinam suas características
básicas.
Para termos acesso às propriedades de um bloco ou de

qualquer outro objeto devemos selecionar o objeto no
navegador e pressionar o botão direito do mouse.
Será mostrada uma lista de opções, dentre elas aquela que

ativa a paleta de propriedades.
Nesta paleta existem grupos que relacionam propriedades

associadas a um mesmo assunto.
Na figura 16 mostramos a paleta de propriedades de um

bloco.
Observe que no grupo Geral existem propriedades aplicáveis

Fig. 16 - Propriedades dos Blocos
a todos os objetos: Nome, Subclasses e Comentários.
Quando selecionamos uma das propriedades (basta clicar com o mouse sobre a linha), seu valor torna-se
disponível para modificação e no rodapé da paleta aparece uma pequena explicação sobre a propriedade
selecionada.
Isto facilita bastante o entendimento do conjunto de propriedades, que é bem extenso.
CAPÍTULO 2: BLOCOS - 15
A área de Buffer
Quando criamos um bloco, podemos determinar o tamanho da área de memória reservada para a leitura
das linhas de dados associadas a ele.
Isto é feito através da propriedade Número de Registros Armazenados no Buffer (Number of Records
Buffered).
Esta área contém diversos registros (um para cada linha lida), os quais armazenam os dados relativos a
cada um dos itens pertencentes ao bloco.
HIERARQUIA FUNCIONAL
Desta forma podemos dizer que um item está subordinado a um registro, que por
sua vez está subordinado a um bloco.
Esta hierarquia, que está representada na figura 17 é chamada de Hierarquia

Funcional, pois está associada à forma como o Form Runtime trabalha.
Todos os itens de um determinado bloco estão sujeitos à funcionalidade do bloco.
Por exemplo para incluirmos linhas na tabela Func (exemplo do tópico anterior),
preenchemos os itens.
Estes dados vão sendo armazenados na área de Buffer (registros) até que
pressionamos o botão Salvar. Fig. 17
Neste momento esta área de Buffer é lida e enviada ao banco de dados para inclusão.
Estas ações são possíveis devido à ligação dos itens com os registros e destes com o bloco.
Controlando a situação do Registro

Cada registro associado a um bloco possui uma propriedade Status que indica a situação atual do registro.
Quando iniciamos a aplicação, por default, o Form Runtime assume que estamos pretendendo criar
registros, desta forma cria um registro vazio para que iniciemos a etapa de digitação.
O estado deste registro inicial é NEW. Quando modificamos alguma informação em um dos itens
pertencentes a este registro, seu estado passa para INSERT.
Quando realizamos uma consulta e carregamos a área de buffer com linhas vindas da tabela de dados, o
estados dos registros deste bloco é QUERY. Ao efetuarmos alguma modificação em um item deste
registro, seu estado passa para CHANGED.
É desta forma que o Form Runtime controla o que deve ser feito quando comandamos uma ação de
Salvar. O status indica qual ação deve ser feita com cada registro de cada bloco. Em torno deste controle
giram todas as ações realizadas pela ferramenta.
Como um registro não possui representação gráfica na ferramenta, sua propriedade só pode ser obtida ou
modificada por programação, através das rotinas Set_Record_Property e Get_Record_Property.
Tipos de Blocos
Um Bloco no Form pode ser de dois tipos:
• Data Block (Bloco de Dados) - está associado a dados oriundos do banco de dados seja
através de uma tabela (ou view) ou através de rotinas armazenadas no banco de dados. Este
tipo de bloco possui uma funcionalidade padrão implícita, que garante a inclusão, exclusão,
alteração e consulta sem que tenhamos de escrever uma única linha de código.
• Control Block (Bloco de Controle) - não está associado ao banco de dados e, portanto, não
possui qualquer funcionalidade implícita. São usados freqüentemente para a criação de
botões, itens de cálculo, áreas de trabalho, itens para entrada de valores requeridas pela
aplicação, etc.
Os itens subordinados a cada um destes blocos também possuem tipos que os caracterizam.
• Itens em Blocos de Dados - podemos ter itens associados ao banco de dados ou itens de
controle (ou seja, itens não associados ao banco de dados).
• Itens em Blocos de Controle - os itens são todos de controle, obrigatoriamente.
REVISANDO A SITUAÇÃO DO REGISTRO

Com a tabela a seguir faremos um refinamento em relação à forma como o Form controla o estado de um
registro.
A tabela apresenta para cada tipo de item e de bloco, a evolução do estado do registro quando efetuamos
uma modificação.
Tipo de Bloco Tipo de Item Modificado Estado do Registro Antes da Estado do Registro Depois da
Modificação Modificação
Bloco de Dados Item do banco de dados NEW INSERT
Bloco de Dados Item de controle NEW INSERT
Bloco de Dados Item do banco de dados QUERY CHANGED
Bloco de Dados Item de controle QUERY QUERY
Bloco de Controle Item de controle NEW INSERT
Tabela 1- Evolução do Estado de um Registro
Quando precisamos, por algum motivo, limpar a área de buffer de um Bloco de Dados, o Form analisa a
situação de atualização daquele bloco.
Se existirem registros pendentes de atualização, antes de executar a ação solicitada o Form questiona o
usuário se deseja ou não efetivar as modificações pendentes (figura 15). Neste caso o usuário poderá
tomar três ações :
• Sim (Yes) – Indica que o processo de atualização do banco deve ser efetuado antes da ação
solicitada pelo usuário.
• Não (No) – Indica que os registros pendentes devem ser descartados, mas a ação solicitada,
causadora da limpeza no buffer, deve ser realizada.
• Cancelar (Cancel) – Indica que o usuário está desistindo da ação solicitada. Neste caso a
ação é interrompida e o programa volta para o estado de leitura do teclado aguardando que o
usuário inicie outra ação.
AÇÕES QUE CAUSAM A MENSAGEM
• Clear Block - A primeira e mais direta é a própria solicitação de limpeza do bloco, opção
Limpar (Clear) do menu Bloco(Block). Esta ação causa a limpeza da área de buffer associada
ao bloco. Também pode ser iniciada com a opção Limpar Bloco (Clear Block – Shift+F5) do
teclado ou, por programação, com o uso da rotina Clear_Block.
• Clear Form - A solicitação de limpeza de toda a aplicação causa a limpeza da área de buffer
de todos os blocos. Se em algum deles houver registros pendentes, ocorrerá a mensagem.
Esta ação pode ser iniciada pelo usuário através da opção Limpar Tudo(Clear All) do menu
Ação(Action), da opção Limpar Form (Clear Form – Shift + F7) do teclado ou, através da
programação, com o uso da rotina Clear_Form.
• Exit Form - O término da aplicação com registros pendentes também causa a presença da
mensagem, apesar de não causar a limpeza direta do buffer e sim a indireta pois toda a
memória da aplicação será liberada para o sistema operacional. Esta ação pode ser solicitada
pelo usuário através da opção Sair (Exit) do menu Ação (Action), do botão Sair (Exit) da barra
de ferramentas, do botão Fechar ( X ) da janela do F50Run, da opção Sair (Exit – Ctrl + q) do
teclado ou, por programação, com o uso da rotina Exit_Form.
• Enter Query - Ao solicitarmos uma nova consulta, o Form Runtime deve limpar o buffer a fim
de carregar os dados da nova consulta solicitada. O usuário poderá causar esta situação ao
escolher a opção Entrar(Enter) ou Último Critério(Last Criteria) do menu Consultar (Query), o
botão Entrar com Consulta (Enter Query) da barra de ferramentas e a opção Entrar com
Consulta (Enter Query – F7) do teclado ou, por programação, com o uso da rotina
Enter_Query.
• Execute Query - Se tentarmos executar uma consulta sem previamente estabelecermos as

restrições, o Form Runtime deve limpar o buffer a fim de carregar os dados da nova consulta
solicitada. O usuário poderá causar esta situação ao escolher a opção Executar(Execute) ou a
opção Contar Acertos (Count Query Hits) do menu Consultar (Query), o botão Executar
Consulta (Execute Query) da barra de ferramentas, a opção Executar Consulta (Execute
Query – F8) do teclado ou, por programação, com o uso da rotina Execute_Query.
Navegação
O que acontece quando, através da navegação, atingimos o último item de um bloco e acionarmos a
navegação para o próximo item ? Qual ação será realizada pelo Form ?
Estas questões serão definidas pelo desenvolvedor ao preencher as propriedades Estilo de Navegação
(Navigation Style), Bloco de Dados Anterior de Navegação (Previous Navigation Data Block) e Próximo
Bloco de Dados de Navegação (Next Navigation Data Block). Todas estas propriedades se encontram
grupadas no nó Navegação (Navigation) da Paleta de Propriedades.
SEQÜÊNCIA DE NAVEGAÇÃO
Quando não especificamos um valor para as propriedades Próximo e Anterior, a seqüência de navegação
relativa aos objetos é dada pela ordem destes objetos no Navegador.
O controle pelo Navegador é mais fácil do que pelas propriedades internas porque ele é visual.
Com o mouse podemos arrastar os blocos no Navegador e especificar a seqüência de navegação

desejada. Para tal pressione o mouse sobre o ícone que aparece ao lado esquerdo do nome do bloco e
arraste-o.
ESTILO DE NAVEGAÇÃO
A propriedade Estilo de Navegação (Navigation Style) possui três valores:
• Mesmo Registro (Same Record) - Opção default. Indica que quando uma operação de
navegação para o próximo item é acionada e o posicionamento do cursor é exatamente no
último item navegável do bloco, o foco deve retornar para o primeiro item navegável deste
mesmo registro.
• Alterar Registro (Change Record) - Indica que quando uma operação de navegação para o
próximo item é acionada e o posicionamento do cursor é exatamente no último item navegável
do bloco, o foco deve se dirigir para o primeiro item navegável do próximo registro.
• Alterar Bloco de Dados (Change Block) - Indica que quando uma operação de navegação
para o próximo item é acionada e o posicionamento do cursor é exatamente no último item
navegável do bloco, o foco deve se dirigir para o primeiro item navegável do próximo bloco.
Modificando as características dos Registros

No grupo Registros (Records) vemos diversas propriedades relativas aos registros do bloco, dentre estas:
• Orientação do Registro (Record Orientation) - determina se os registros navegarão no

sentido vertical ou horizontal.
• Número de Registros Exibidos (Number of Records Displayed) - que permite que após o
desenvolvimento do bloco modifiquemos a quantidade de registros presentes na canvas (tela).
• Número de Registros Armazenados no Buffer (Number of Records Buffered) – esta

propriedade determina o tamanho da área de memória local para armazenamento dos
registros do bloco que estamos trabalhando. Quanto maior este número, mais ágil é o
processo de manipulação da informação localmente, porém precisaremos de mais memória
real disponibilizada.
Quando o número de registros que precisamos armazenar no buffer local(em função da leitura
de uma tabela grande, por exemplo) é maior que o valor especificado por esta propriedade o
Form faz overlay para disco a fim guardar o restante. O valor default de 0 (ou Null) indica que
serão armazenados em memória a mesma quantidade de registros exibidos mais 3 (três).
• Tamanho do Array de Consulta (Query Array Size) – Esta propriedade define a freqüência
com que o Form faz acesso ao banco de dados para obtenção dos dados a serem
apresentados. Um número muito baixo pode dar ao usuário a impressão de uma resposta
imediata melhor se ele estiver analisando os registros passo a passo.
Se ele estiver fazendo navegação uma quantidade maior de registros permitirá que ele
navegue mais rapidamente até haver necessidade do Form obter o próximo conjunto.
Se analisarmos pelo lado da performance, um número maior de registros é mais eficiente, pois
temos de fazer menos acesso ao servidor para obtenção dos dados, porém o tempo de
resposta de cada acesso pode ser maior, apesar do tempo de resposta total, certamente, ser
menor.
Ligando o Bloco ao Database

O grupo Banco de Dados (Database) é o local onde especificamos se e como se dará a interface entre o
bloco de dados e o objeto associado no banco de dados.
• Bloco de Dados do Banco de Dados (Database Data Block) - indica se o bloco é um bloco
de dados (Sim) ou um bloco de controle (Não). Quando escolhemos Sim, o Form verifica as
informações relativas à origem do dados, ou seja, como se dará a captura das informações a
serem apresentadas. Caso nossa opção seja Não estas informações serão ignoradas pelo
Forms.
• Tipo de Origem de Dados de Consulta (Query Data Source Type) - indica de onde se
originarão os dados para preenchimento dos itens do bloco. As opções válidas são: Nenhum
(para bloco de controle), Tabela(Table), Gatilhos Transacionais (Transactional Triggers),
Procedimento (Procedure) e Consulta da cláusula From (From clause).
• Nome de Origem de Dados de Consulta (Query Data Source Name) - indica o nome da
tabela ou o nome do procedimento para consulta ou a query a ser anexada à cláusula From.
• Colunas de Origem de Dados de Consulta (Query Data Source Columns) - determina os dados
a serem trazidos pela consulta.
• Cláusula Where(Where Clause) - define uma restrição a ser utilizada em todas as consultas.
• Cláusula Order By(Order By Caluse) - define uma ordenação a ser utilizada em todas as
consultas.
• Consulta Permitida (Query Allowed) - indica que o Form poderá realizar consultas aos
dados associados a este bloco.
• Inserção Permitida (Insert Allowed) - indica que o Form adicionará à aplicação a capacidade
de incluir linhas para este bloco e, consequentemente, no banco de dados.
• Atualização Permitida (Update Allowed) - indica que o Form adicionará à aplicação a

capacidade de alterar linhas neste bloco e, consequentemente, no banco de dados.
• Exclusão Permitida (Delete Allowed) - indica que o Form adicionará à aplicação a

capacidade de excluir registros deste bloco e, consequentemente, no banco de dados.
Para efeito de teste, acompanhe seu instrutor nas seguintes modificações :
• Impeça que o bloco Func possa sofrer exclusões.

• Inclua uma cláusula Where para o bloco Func.
• Ordene os dados do bloco por nome do funcionário.
Criando um Bloco a partir de um Procedimento

Como descobrimos, pelas propriedades, um bloco de dados também pode ser criado a partir de um
procedimento armazenado no banco de dados.
Por exemplo, podemos definir rotinas para efetuar todas as etapas de atualização e consulta aos dados,
sem que o usuário tenha acesso direto à tabela. Estas rotinas podem completar informações, efetuar
críticas mais elaboradas, enfim qualquer ação desejada de atualização.
Acompanharemos, a seguir, o instrutor na criação de um bloco deste tipo usando o pacote Pfunc.
O PACOTE PFUNC
A parte de especificação do pacote é apresentada a seguir:
SQL> CREATE OR REPLACE PACKAGE PFUNC IS

2 TYPE CFUNC IS REF CURSOR RETURN FUNC%ROWTYPE;
3 TYPE TFUNC IS TABLE OF FUNC%ROWTYPE
4 INDEX BY BINARY_INTEGER;
5 PROCEDURE ATUALIZA (PTAB IN OUT TFUNC,
6 PTIPO IN VARCHAR2);
7 PROCEDURE CONSULTA (PCD_MAT IN NUMBER := NULL,
8 PCD_DEPTO IN VARCHAR2 := NULL,
9 PNR_CARGO IN NUMBER := NULL,
10 PNR_GIT IN NUMBER := NULL,
11 PTAB IN OUT CFUNC);
12 END PFUNC;
13 /
Listagem 1 - Especificação do pacote Pfunc
Neste pacote incluímos um tipo Cursor(Cfunc) e um tipo Table(Tfunc), ambos fazendo referência à linha da
tabela Func.
Estabelecemos, ainda, a parte de especificação das duas rotinas : uma rotina de consulta e uma rotina de
atualização.
A rotina de consulta recebe como parâmetro a matrícula, o departamento, o cargo e o grau de instrução e
retorna uma variável cursor do tipo Cfunc.
Os parâmetros para esta rotina são opcionais: o usuário poderá fornecer apenas a matrícula ou uma
combinação de cargo com grau de instrução ou nenhum deles e assim por diante. De acordo com estas
informações serão selecionadas as linhas de funcionário que atendem às condições.
A seguir o corpo do pacote Pfunc.
SQL> CREATE OR REPLACE PACKAGE BODY PFUNC IS

2 PROCEDURE CONSULTA (PCD_MAT IN NUMBER := NULL,
3 PCD_DEPTO IN VARCHAR2 := NULL,
4 PNR_CARGO IN NUMBER := NULL,
5 PNR_GIT IN NUMBER := NULL,
6 PTAB IN OUT CFUNC) IS
7 BEGIN
8 OPEN PTAB FOR
9 SELECT CD_MAT, NM_FUNC, NM_SOBRENOME, IN_SEXO, NR_RAMAL,
10 VL_SAL, DT_NASC, DT_ADM, CD_DEPTO, NR_CARGO, NR_GIT
11 FROM FUNC
12 WHERE CD_MAT = NVL(PCD_MAT, CD_MAT)
13 AND CD_DEPTO = NVL(PCD_DEPTO, CD_DEPTO)
14 AND NR_CARGO = NVL(PNR_CARGO, NR_CARGO)
15 AND NR_GIT = NVL(PNR_GIT, NR_GIT);
16 END CONSULTA;
17 PROCEDURE ATUALIZA (PTAB IN OUT TFUNC, PTIPO IN VARCHAR2) IS
18 I NUMBER := 1;
19 DUMMY NUMBER;
20 BEGIN
21 WHILE PTAB.EXISTS(I) LOOP
22 IF UPPER(PTIPO) = 'I' THEN
23 INSERT INTO FUNC
24 (CD_MAT, NM_FUNC, NM_SOBRENOME, IN_SEXO, NR_RAMAL, VL_SAL,
25 DT_NASC, CD_DEPTO, NR_CARGO, NR_GIT, DT_ADM) VALUES
26 (SEQMAT.NEXTVAL, PTAB(I).NM_FUNC, PTAB(I).NM_SOBRENOME,
27 PTAB(I).IN_SEXO, PTAB(I).NR_RAMAL, PTAB(I).VL_SAL,
28 PTAB(I).DT_NASC, PTAB(I).CD_DEPTO, PTAB(I).NR_CARGO,
29 PTAB(I).NR_GIT, SYSDATE);
30 ELSIF UPPER(PTIPO) = 'A' THEN
31 UPDATE FUNC
32 SET NM_FUNC = NVL(PTAB(I).NM_FUNC, NM_FUNC),
33 NM_SOBRENOME = NVL(PTAB(I).NM_SOBRENOME, NM_SOBRENOME),
34 IN_SEXO = NVL(PTAB(I).IN_SEXO, IN_SEXO),
35 NR_RAMAL = NVL(PTAB(I).NR_RAMAL, NR_RAMAL),
36 VL_SAL = NVL(PTAB(I).VL_SAL, VL_SAL),
37 DT_NASC = NVL(PTAB(I).DT_NASC, DT_NASC),
38 CD_DEPTO = NVL(PTAB(I).CD_DEPTO, CD_DEPTO),
39 NR_GIT = NVL(PTAB(I).NR_GIT, NR_GIT),
40 DT_ADM = NVL(PTAB(I).DT_ADM, DT_ADM)
41 WHERE CD_MAT = PTAB(I).CD_MAT;
42 ELSIF UPPER(PTIPO) = 'E' THEN
43 DELETE FROM FUNC WHERE CD_MAT = PTAB(I).CD_MAT;
44 ELSIF UPPER(PTIPO) = 'B' THEN
45 SELECT 1 INTO DUMMY FROM FUNC
46 WHERE CD_MAT = PTAB(I).CD_MAT FOR UPDATE;
47 END IF;
48 I := I + 1;
49 END LOOP;
50 END ATUALIZA;
51 END PFUNC;
52 /
Listagem 2 - Corpo do pacote Pfunc
DEFININDO UM BLOCO DE DADOS DO TIPO PROCEDIMENTO

O preenchimento das informações do bloco será a seguinte (passo a passo) :
1. Criar uma nova aplicação de nome TPROC.
2. Criar um bloco de dados com a ajuda do Assistente (Procedimento Armazenado no banco de

dados).
3. Preencher o diálogo com o nome da rotina de Consulta (veja a figura 18).
Fig. 18 - Procedimento para Consultar Dados
Os argumentos devem ser preenchidos da seguinte forma:
• pcd_mat - preencheremos a coluna Valor com :cd_mat. Isto significa que quando o usuário
preencher o item cd_mat do bloco, a tempo de Enter-Query, o valor deste item será associado
ao parâmetro pcd_mat para possibilitar a consulta por matrícula.
• pcd_depto - preencheremos a coluna Valor com :cd_depto. Observe que o nome do item do
bloco será obtido da definição do registro Func%Rowtype do qual o parâmetro Ptab (tipo
RefCursor) se origina.
• pnr_cargo - usaremos :nr_cargo.
• pnr_git - com :nr_git.
• Ptab - não recebe nenhum valor pois é um parâmetro de saída da rotina.
4. Preencher o próximo diálogo com o nome da rotina para inclusão de dados.
Fig. 19 - Procedimento para Inserir Dados
Após pressionarmos o botão Renovar, o quadro abaixo do nome do procedimento é preenchido

automaticamente com o conteúdo do tipo table Ptab.
Os argumentos serão preenchidos da seguinte forma:
• Ptab - receberá o conteúdo do bloco, ou seja :BFunc.
• Ptipo - receberá a constante I, para indicar a rotina que é uma chamada de inclusão.
5. Os diálogos seguintes a este são preenchidos de forma similar, de acordo com o quadro abaixo:
Diálogo Procedimento Parâmetro Ptab Parâmetro Ptipo

Procedimento de Atualização Pfunc.Atualiza :BFunc A
Procedimento de Exclusão Pfunc.Atualiza :BFunc E
Procedimento de Bloqueio Pfunc.Atualiza :BFunc B
Tabela 2 – Assistente de Bloco de Dados – Atualizar, Excluir e Bloquear
6. Crie o layout da aplicação com todas as colunas, uma canvas de conteúdo e uma barra de
rolagem (bem simples).
7. Altere o nome do bloco para BFunc para que fique compatível com as informações que passamos.
8. Abra a paleta de propriedades do bloco com o nó Banco de Dados expandido. Analise o resultado
gerado nas propriedades Tipo de Origem de Dados de Consulta(Query Data Source Type), Nome
de Origem de Dados de Consulta (Query Data Source Name), Colunas de Origem de Dados de
Consulta (Query Data Source Columns) e Argumentos de Origem de Dados de Consulta (Query
Data Source Arguments).
9. Expanda, agora, o nó Banco de Dados Avançado para a especificação das propriedades das
demais rotinas (confira o que está preenchido), da seguinte forma:
• Tipo de Destino dos Dados de DML (DML Data Target Type) – esta propriedade indica para
onde os dados a serem incluídos, alterados, bloqueados ou excluídos serão enviados. No
nosso caso Procedimento.
• Nome do Destino dos Dados de DML (DML Data Target Name) – Se a propriedade anterior
estivesse preenchida com Tabela, nesta propriedade teríamos o nome da tabela. No nosso
caso em cada situação os dados serão enviados para rotinas diferentes, portanto esta
propriedade é irrelevante.
• Inserir Nome do Procedimento (Insert Procedure Name) – Indica o nome do procedimento

para onde serão enviados os dados a tempo de inclusão: Pfunc.Atualiza.
• Atualizar Nome do Procedimento (Update Procedure Name) – Indica o nome do

procedimento para onde serão enviados os dados a tempo de alteração: Pfunc.Atualiza.
• Excluir Nome do Procedimento (Delete Procedure Name) – Indica o nome do procedimento

para onde serão enviados os dados a tempo de exclusão: Pfunc.Atualiza.
• Bloquear Nome do Procedimento (Lock Procedure Name) – Indica o nome do

procedimento para onde serão enviados os dados a tempo de bloqueio: Pfunc.Atualiza.
• Os argumentos e retornos nas quatro situações são similares. Desta forma veremos apenas
na situação de inclusão:
• Inserir Colunas de Conjuntos de Resultado (Insert Procedure Result Set Columns) - são
apresentados todos os parâmetro do tipo OUT ou IN OUT. Como nosso parâmetro Table é do
tipo IN OUT, ele é automaticamente listado neste diálogo.
• Inserir Argumentos de Procedimento (Insert Procedure Arguments) - são apresentados

todos os parâmetro do tipo IN ou IN OUT para que possamos informar de onde serão obtidos
os dados. Observe que para o argumento Ptab preenchemos o tipo do argumento (Table) e o
Nome (Pfunc.Tfunc) pois se trata de um tipo do usuário. Em ambos os argumentos
preenchemos a coluna Valor. No caso de Ptab com o nome do bloco (:BFunc) e no caso de
Ptipo com um valor constante, que varia de acordo com a ação da rotina (I – Inclusão, B –
Bloqueio, A – Alteração e E – Exclusão).
As demais propriedades relativas a argumentos são preenchidas de forma similar. Verifique se os valores
estão corretos.
10. Retorne ao Navegador de Objetos (Object Navigator) e observe :
• O nó Itens subordinado ao nó do bloco BFunc. Quais os itens criados ?
Foram criados todos os itens associados ao parâmetro PTAB. No nosso caso este parâmetro é
do tipo CFUNC correspondendo à linha (row) da tabela Func. Caso o tipo CFUNC fosse
derivado de um RECORD com descrição específica, os elementos deste RECORD é que
apareceriam subordinados ao nó Itens do bloco.
• O nó Gatilhos subordinado ao nó do bloco Func. Quais os gatilhos criados ?
Estas rotinas são geradas, automaticamente, a tempo de compilação do módulo. Não

podemos modificar seu conteúdo uma vez que elas são geradas novamente cada vez que
compilamos a aplicação.
Se houver qualquer erro de sintaxe relativamente a elas, devemos retornar à etapa anterior e
verificar o preenchimento das propriedades relativas aos argumentos das rotinas.
Estes gatilhos (triggers) são executados da seguinte forma:
- Cada vez que modificamos o valor de um campo na tela ou acionamos o comando de

remover a linha, a rotina para bloqueio é acionada, ou seja, a rotina é acionada uma vez para
cada linha. A tabela parâmetro é preenchida com um único elemento.
- Quando solicitamos a opção Salvar (Commit), caso hajam inclusões a serem realizadas a
rotina de inclusão é acionada uma única vez, recebendo como parâmetro todas as linhas a
serem incluídas. O mesmo ocorre com a rotina de alteração e exclusão.
COMENTÁRIOS RELATIVOS A PROCEDIMENTOS

Como regra para a utilização de Procedimentos temos que:
• Uma Stored Procedure se comunica com o Form através de uma variável Cursor ou de um tipo
Table. A especificação destes tipos é obrigatória em todos os tipos de procedimento.
• A variável Cursor só pode ser utilizada para Consulta. Já o tipo Table pode ser usado em
ambas as situações.
• Como vantagem de utilização da variável Cursor temos que ela favorece o mecanismo de
transferência de informações (Array Processing), isto significa, que quando usamos este tipo
de variável a leitura dos registros no ambiente Server pode ser feita parcialmente, respeitando-
se os valores estabelecidos de Fetch. Já a tabela recebe todos os dados de uma única vez, o
que pode gerar a necessidade de uma quantidade maior de memória.
• No exemplo utilizamos um único tipo Record contendo todas as colunas necessárias à leitura,
porém a transferência de informações a tempo de bloqueio ou exclusão foi de toda a linha.
Não havia necessidade de trabalharmos desta forma. Podemos utilizar tipos Record diferentes
para leitura, atualização, exclusão e bloqueio, desde que os elementos individuais, presentes
nos tipos tenham os mesmos nomes (entre si), ou seja, a associação é feita por nome.
RESTRIÇÕES RELATIVAS AOS TIPOS DE BLOCOS

O quadro a seguir apresenta o que pode e o que não pode ser feito relativamente a cada tipo de bloco.
Origem Consultas Demais Operações de DML Array Processing

(Inc, Exc e Alt)
Tabela Sim Sim Sim
View Sim Sim (excetuando-se certas Sim
views contendo Joins)
Cláusula FROM Sim Não Sim (somente para registros
consultados)
Procedure Sim Não (se a rotina usa Ref Não (se o procedimento utiliza
Cursor) tipo Table)
Transactional Trigger Sim Sim Não (se o trigger utiliza tipo
Table)
Tabela 3 – Restrições por Tipo de Bloco
Retornando Valores
Quando efetuamos uma operação de atualização no banco de dados (inclusão ou alteração), podemos
desejar retornar os valores atualizados.
Isto é muito útil quando temos um trigger associado à tabela que modifica os valores atualizados.
O Form Builder permite que façamos esta operação através da propriedade DML Returning Value (grupo
Advanced Database).
Quando esta propriedade está preenchida com YES e o banco de dados em uso é um Oracle9 database, o
Forms utiliza a cláusula Returning para retornar os valores que tenham sido modificados após as
operações de atualização por causa da execução de triggers no banco de dados.
Desta forma o usuário não terá necessidade de executar a query novamente após uma atualização.
OBS: esta cláusula terá efeito apenas para bancos de dados da versão 9 ou superior e para inserts e
updates.
CAPÍTULO 3: INTERFACE VISUAL

Já sabemos que funcionalmente os itens dependem dos blocos, porém visualmente um bloco não existe,
isto é, não tem representação visual. Os objetos vistos pelo usuário são a Canvas (tela) e os itens.
Sendo assim os itens estão subordinados, visualmente, à canvas em que são apresentados. Ao tempo de
atualização, crítica, leitura, gravação e todas as ações funcionais estão subordinados aos blocos, porém
itens pertencentes a um mesmo bloco podem ser apresentados em diferentes canvas, da mesma forma
que itens pertencentes a blocos diferentes podem ser apresentados numa mesma canvas.
Para que tenhamos, graficamente, informações a respeito desta hierarquia, o Navegador de Objetos
oferece uma alteração das informações para este padrão através da opção View Visual (Visual View) do
menu Visualizar (View), como apresentado pela figura 20.
Na figura 20 podemos observar que o nó Janelas(Windows) apresenta duas janelas: Null_Window e

Window1.
Fig. 20 – Hierarquia Visual
Na janela Window1 encontramos a Canvas3 onde se acham subordinados todos os itens visíveis desta
aplicação.
Podemos desta forma concluir que a hierarquia visual é composta de Windows – Canvas – Itens.
A janela Null_Window é uma janela fictícia. Representa a hierarquia de todos os objetos que não serão
visualizados, ou seja, dos objetos que não estão subordinados a uma canvas. Estes objetos são
chamados de Null_Canvas Itens ou objetos que se apresentariam em uma canvas fictícia chamada
Null_Canvas.
Sendo assim a figura 20 apresenta todos os objetos visíveis subordinados às suas canvas e janelas (onde
se apresentarão) e todos os objetos escondidos aparecem subordinados a uma canvas não visível e uma
janela não visível.
Ao retornarmos ao modo View Propriedade (Property View) podemos verificar que o nó Canvas somente
apresenta a Canvas3 e o nó Janelas (Windows) só apresenta a Window1.
CAPÍTULO 3: INTERFACE VISUAL - 29

Itens
Em uma aplicação gráfica, os dados não se apresentam de uma única forma. Podem ser botões, listas,
imagens, gráficos, etc.
Em uma aplicação Forms, portanto, poderemos apresentar os dados de uma forma mais agradável e
amigável para o nosso usuário, bastando para isto que modifiquemos os tipos de itens em que os dados
são apresentados.
Lembre-se, porém, de que a informação armazenada no buffer associado àquele item continua a mesma,
ou seja, se foi lido do banco o valor 42 para grau de instrução, a forma de visualização pode ser uma lista
de nomes, mas o que está no banco de dados e na memória é 42. Por isto devemos, de acordo com o tipo
do item, estabelecer regras de conversão entre o valor real do dado e o valor apresentado para o usuário.
PROPRIEDADES COMUNS
Ao abrirmos a paleta de propriedades de um item qualquer verificaremos que estes possuem uma
quantidade significativa de características a serem analisadas.
O grupo funcional será o último analisado uma vez que possui características específicas ao tipo do item.
Grupo Geral (General)

• Tipo do Item (Item Type) - determina quais as características de visualização específicas do
item, pois modifica o conjunto de propriedades definidas no grupo funcional.
Grupo Navegação (Navigation)

• Navegável com Teclado (Keyboard Navigable) - indica se o usuário poderá, utilizando a
tecla TAB, levar o cursor até este item.
Grupo Dados (Data)

Neste grupo definimos as características do item em relação aos dados que ele armazenará:
• Tipo de Dado (Data Type) – indica se o dados armazenado é numérico, data, caracter, etc.
• Tamanho Máximo (Maximum Length) – indica o tamanho máximo do dado armazenado no

buffer.
• Tamanho Fixo (Fixed Length) – indica que o dado a ser armazenado sempre terá o
comprimento igual ao tamanho máximo. Isto pode ser útil para informações de comprimento
fixo como por exemplo CEP.
• Valor Inicial (Initial Value) – indica qual o valor do item quando estamos fazendo a inclusão
de um novo registro no buffer. O usuário poderá modificar este valor quando vier a digitar os
dados do registro.
• Obrigatório (Required) – indica que o item deve ser preenchido. Não pode ser omitido em
uma inclusão ou apagado em uma alteração.
• Mínimo e Máximo Valor Permitido (Lowest / Highest Allowed Value) – indicam uma
restrição relativa aos valores aceitáveis para o item: o menor e o maior valor permitidos.
Grupo Cálculo(Calculation)
No grupo Cálculo poderemos estabelecer um item que seja um somatório ou uma fórmula resultante dos
itens de outro bloco.

Grupo Registros (Records)

• Distância entre Registros (Distance Between Records) – a presença desta propriedade
indica que a distância entre os registros pode ser diferente de um item para o outro.
• Número de Itens Exibidos (Number of Items Displayed) – esta informação está preenchida
com zero, o que indica que a quantidade de itens exibidos acompanha a quantidade do bloco.
Fig. 21 – Alteração das propriedades do grupo Registros
Na figura 21 vemos o que aconteceu quando alteramos as duas propriedades acima para os itens cd_mat
e nm_func.
Grupo Banco de Dados (Database)

• Item do Banco de Dados (Database Item) – esta propriedade indica se o item em questão
pertence ou não à base de dados. Isto significa que podemos criar um item que não pertence
ao banco de dados, mesmo em um Bloco de Dados (que tem interface direta com o banco de
dados). Para que o Form não tente enviar ou receber do banco de dados um item que não se
encontra na tabela ou procedimento correspondente, devemos preencher esta propriedade
com Não, quando este for o caso.
• Nome da Coluna (Column Name) – indica o nome da coluna no banco de dados. Isto nos dá
a liberdade de nomear o item como quisermos.
• Somente Consulta (Query Only) – esta propriedade indica que este item não será atualizado
ou alterado nesta aplicação. Sua informação será apenas vista pelo usuário. Esta propriedade
impede que o item seja modificado.
• Consulta Permitida (Query Allowed) – esta propriedade indica que a tempo de Entrar
Consulta (Enter Query), o usuário poderá estabelecer uma restrição de pesquisa neste item.
Só devemos habilitar para pesquisa aqueles itens em que, realmente, permitimos que os
usuários venham a pesquisar. Bloqueie o uso de consulta nos demais itens. Isto pode trazer
modificações significativas na performance.
• Tamanho da Consulta (Query Length) – esta propriedade define que no momento de Entrar
Consulta (Enter Query) este item pode ter o mesmo tamanho da propriedade Tamanho
Máximo (Maximum Length) ou poderá ser maior. Isto é útil pois sabemos que uma restrição
poderia ser preenchida com “> 500”, por exemplo para o item matrícula. Isto precisa de mais
espaço que o tamanho máximo do item (no caso com 3 caracteres).

• Consulta Insensível a Maiúsculas/Minúsculas (Case Insensitive Query) – Esta

propriedade indica que a tempo de consulta, as colunas alfanuméricas habilitadas para
pesquisa poderão ser preenchidas com qualquer valor (maiúsculo ou minúsculo) que o Form
Runtime encontrará a informação de qualquer forma. Isto significa que o Form executará a
função Upper do lado da coluna e do lado o valor. Por exemplo: Upper(cd_depto) =
Upper(‘e01’). Este tipo de ação deve ser verificado pois pode trazer conseqüências na
performance da aplicação. Consulte seu DBA a respeito deste uso.
• Inserção Permitida (Insert Allowed) – esta propriedade indica que quando estivermos
criando um novo registro no buffer, este item estará apto a ser preenchido.
• Atualização Permitida (Update Allowed) – da mesma forma que a anterior, indica que
quando houvermos consultado um item, ou seja, quando não estivermos mais em um novo
registro (com estado de New ou Insert), poderemos modificar o valor deste item.
• Atualizar Somente se Null (Update Only if Null) – já esta propriedade é mutuamente

exclusiva com a anterior e indica que somente poderemos modificar o valor deste item se ele
não tiver qualquer valor preenchido (Null).
• Bloquear Registro (Lock Record) – esta propriedade indica que se o item atual for
modificado o Form deve, imediatamente, tentar o bloqueio da linha correspondente no banco
de dados. Esta propriedade pode ser útil quando temos um item no bloco que não pertence ao
banco de dados e, no entanto, desejamos que se seu valor for modificado, toda a linha seja
reservada. Para um item associado ao banco de dados este bloqueio é automático.
O grupo Lista de Valores (Lov) será estudado em tópico específico, assim como o grupo Editor.
Grupo Físico (Physical)

• Bevel – esta propriedade caracteriza a borda do objeto podendo dar uma aparência
tridimensional ao item. Só é aplicável a itens Chart, Custom, Text e canvas do tipo Stack.
• Finalizado (Rendered) – esta propriedade indica se um item que não detém o foco continua
conservando os recursos do sistema. Se a propriedade receber True (default), o item somente
precisará se utilizar dos recursos de apresentação (display) do sistema quando detiver o foco,
caso contrário os recursos são liberados.
• Mostrar Barra de Rolagem Vertical (Show Vertical Scroll Bar) – esta propriedade indica se
o item deve ou não apresentar uma barra de rolagem vertical. Esta propriedade somente faz
sentido para itens que os dados possam ser apresentados em mais de uma linha (texto) ou
imagens.
Grupo Ajuda
• Dica (Hint) – aqui poderemos preencher um texto que indique ao usuário como preencher este
item. Esta informação será apresentada na linha de mensagens quando o usuário navegar
para este item, se a propriedade Exibir Dica (a seguir) estiver habilitada.
• Exibir Dica Automaticamente (Display Hint Automatically) – indica se o texto definido na

propriedade anterior deve ser apresentado quando o item ganha o foco.
• Tooltip (Tooltip) – corresponde a uma etiqueta flutuante que aparece ao lado do item para
indicar seu nome ou alguma informação pequena que indique ao usuário para que serve.
Os grupos Fonte e Cor serão analisados através dos exercícios.
O grupo Prompt diz respeito ao texto que aparece ao lado do item para nomeá-lo ou identificá-lo a fim de
facilitar o preenchimento por parte do usuário. Trabalharemos estas características em um item específico
ainda neste mesmo capítulo.

A seguir veremos o grupo funcional específico por tipo de item.
ITEM DE TEXTO (TEXT ITEM)
• Justificação (Justification) – definindo o alinhamento do item.
• Várias Linhas (Multi-Line) – indicando se o texto contido no item poderá ocupar várias linhas.
O uso apenas desta propriedade não é suficiente para que o resultado seja mostrado em
diversas linhas. É necessário que, graficamente, aumentemos o tamanho do item na vertical
para que as demais linhas fiquem visíveis.
• Estilo de Sobreposição (Wrap Style) – definimos aqui como desejamos que o Form efetue a
quebra do texto entre as linhas.
• Restrição a Maiúsculas / Minúsculas (Case Restriction) – nesta propriedade indicamos que

quando o usuário estiver digitando uma informação, independente da forma de digitação as
informações serão transformadas na opção desejada. Isto só é possível para dados digitados
pelo usuário.
• Ocultar Dados (Conceal Data) – indica que o texto digitado pelo usuário não será refletido no
vídeo. Isto é útil para campos de senha.
• Salto Automático (Automatic Skip) – aqui indicamos que quando o usuário digitar todo o
item, o cursor deverá, automaticamente, “pular” para o próximo campo.
ITEM DE EXIBIÇÃO (DISPLAY ITEM)

Este tipo de item só possui duas propriedades no grupo funcional: Justificação (Justification) e Menu
Popup (Popup Menu).
GRUPO DE RÁDIOS (RADIO GROUP)

Este tipo de item é composto de botões de rádio que representam os valores reais do item.
Observe que as propriedades do grupo Funcional relativamente a este item são apenas Tecla de Acesso
(Access Key), Menu Popup (Popup Menu) e:
• Mapeamento de Outros Valores (Mapping of Other Values) – da mesma forma que para a
lista, a ausência de valor neste campo indica que a tempo de leitura ou atribuição por
programação não serão aceitos valores diferentes daqueles mapeados nos botões.
BOTÃO DE RÁDIO (RADIO BUTTON)

Observe na tela de propriedades do botão que o grupo funcional apresenta:
• Etiqueta (Label) – indica o texto que será apresentado ao lado do botão.
• Tecla de Acesso (Access Key) – indica uma letra da etiqueta que permitirá ao usuário
acionar o item com o uso das teclas Alt + <letra escolhida>.
• Valor do Botão de Rádio (Radio Button Value) – indica o valor que o item assumirá se o
usuário selecionar este botão.

ITEM DA LISTA (LIST ITEM)
• Estilo da Lista (List Style) – esta propriedade indica o tipo de lista a ser apresentada. Os
estilos Poplist e ComboBox (Caixa de Combinação) precisam que o usuário abra a lista para
selecionar um valor. Já o estilo Tlist pode mostrar mais de uma opção simultaneamente se o
espaço vertical no layout for maior. Apenas o estilo ComboBox permite que o usuário escolha
ou digite um valor. Os demais estilos somente permitem a escolha de valores da lista.
• Elementos da Lista (Elements in List) – esta propriedade deve ser preenchida para
estabelecer uma relação entre os valores apresentados para o usuário na lista e o valor do
dado no banco de dados e na memória (buffer) do bloco.
Na figura 22 vemos o diálogo referente ao preenchimento dos

elementos da lista.
Na parte superior devemos preencher com o texto ou valor que

desejamos apresentar ao usuário.
Para cada linha selecionada na parte de cima preenchemos com um

valor correspondente na parte de baixo, que indica o valor real do
dado.
Nota:
Para incluirmos um elemento novo no meio da lista, devemos
selecionar o elemento imediatamente anterior e pressionar as teclas
ctrl + shift + >.
Se desejarmos excluir um elemento da lista, devemos nos posicionar Fig. 22 – Elementos da Lista
sobre o elemento e pressionar as teclas ctrl + shift + <.
• Mapeamento de Outros Valores (Mapping of Other Values) - indica ao Oracle como deve
ser posicionada a lista quando for lido do banco ou atribuído por programação um valor a este
item que não esteja presente na lista de valores.
Cuidado!
Se deixarmos esta propriedade sem preenchimento, estamos indicando que não serão admitidos outros
valores. Desta forma a tempo de leitura do banco de dados um item com um valor não compatível com a
lista é rejeitado, isto é, não é lido para o programa.

IMAGEM (IMAGE)
• Formato da Imagem (Image Format) – com esta propriedade podemos determinar o formato
no qual a imagem será armazenada no banco de dados. Os valores válidos são: BMP, CALS,
GIF, JFIF, PICT, RAS, TIFF, TPIC.
• Profundidade da Imagem (Image Depth) – aqui especificamos a intensidade ou tonalidade

da imagem a ser lida ou gravada para um arquivo do sistema operacional. Os valores válidos
são: Original, Monochrome (monocromática), Gray (escala de cinzas) , LUT (Lookup Table),
RGB (Red, Green, Blue) (colorida usando padrão RGB).
• Qualidade de Compactação (Compression Quality) – determina se a imagem que está

sendo lida de um arquivo ou que está sendo gravada para um arquivo deve ser compactada e
em caso afirmativo qual o grau de compactação. Os valores válidos são : None (nenhum),
Minimum (mínimo), Low (baixo), Medium (médio), High (alto), Maximum(máximo).
• Qualidade de Exibição (Display Quality) – determina a qualidade de exibição de uma

imagem. Os valores válidos são Low (baixo), Medium (médio), High (alto). Quanto melhor a
qualidade mais memória e recursos são necessários à exibição.
• Estilo de Dimensionamento (Sizing Style) – indica o que deve ser feito quando a imagem
não cabe no item definido para ela na canvas. A opção Crop (Recortar) indica que será
apresentada uma parte da imagem, ele aparecerá cortada. A opção Adjust (Ajustar) indica que
a imagem será ajustada (sem perder a proporção) para o tamanho definido para o item na
canvas.
TECLA(PUSH BUTTON)
Um botão não armazena dados. Não existem propriedades relativas ao grupo Banco de Dados, nem ao
grupo Dados. Um botão (ou tecla), tem a finalidade de iniciar uma ação.
Suas propriedades mais importantes do grupo Funcional são:
• Etiqueta (Label) – texto a ser apresentado para o botão.
• Icônico (Iconic) – indica se será apresentado um ícone para o botão.
• Nome do Arquivo de Ícones (Icon Filename) – indica o nome do arquivo que corresponde
ao ícone a ser apresentado.
• Botão Default (Default Button) – indica se este item será default dentre um grupo de botões
disponibilizados.

CAIXA DE VERIFICAÇÃO (CHECK BOX)

Este é o último tipo de item que analisaremos por enquanto. Os demais serão tratados em tópicos
próprios.
As principais propriedades do grupo funcional são:
• Etiqueta(Label) – Indica o texto a ser apresentado próximo ao item.
• Valor quando Assinalado (Value When Checked) – Esta propriedade indica ao Form para
interpretar como checado (ou assinalado) o valor que informarmos. Isto significa que quando
este item receber este valor o usuário verá a caixa marcada.
• Valor quando não-Verificado (Value When Unchecked) – Esta propriedade indica ao Form
para interpretar como não checado (ou não assinalado) o valor que informarmos. Isto significa
que quando este item receber este valor o usuário verá a caixa sem marcação.
• Mapeamento de Outros Valores da Caixa de Verificação (Check Box Mapping of Other

Values) – esta propriedade indica qual deve ser a atitude do Form quando o item receber um
valor diferente daqueles definidos nas duas propriedades acima (seja lendo do banco de
dados ou por programação). O valores válidos para esta propriedade são: Assinalado (a caixa
aparecerá marcada, porém, em memória o valor não será alterado), Seleção Cancelada (a
caixa aparecerá desmarcada. O valor atribuído a ela não será alterado) e Não permitido (neste
caso o registro será ignorado a tempo de leitura ou ocorrerá um erro no caso de atribuição).

Definindo Prompts
Nosso último teste se refere ao posicionamento do prompt do item.
Na figura 23 separamos o item nm_func para que possamos alterar e entender o

posicionamento do Prompt.
Fig. 23 - Prompt
Atualmente as propriedades do grupo Prompt estão preenchidas da seguinte forma:
• Prompt (Prompt) – nesta propriedade temos o valor “Nome” que corresponde ao texto
exibido.
• Estilo de Exibição do Prompt (Prompt Display Style) – esta propriedade está preenchida
com Primeiro Registro (First Record), indicando que o prompt só deve ser apresentado no
primeiro registro. Para um bloco Multi-Record poderíamos desejar que o Prompt se repetisse
para cada registro.
• Justificação do Prompt (Prompt Justification) – aqui indicamos se o prompt será justificado

à direita, esquerda, inicial, final ou centralizado. No nosso caso utilizamos a opção Inicial. Esta
propriedade se refere ao alinhamento interno do texto.
• Limite de Conexão do Prompt (Prompt Attachment Edge) – esta propriedade indica em

qual dos quatro lados o prompt deve ser apresentado. Escolhemos topo, ou seja acima do
item.
• Alinhamento do Prompt (Prompt Alignment) – aqui indica-se como o texto é alinhado em

relação à lateral onde está associado. Escolhemos Centralizado.
• Deslocamento de Conexão do Prompt (Prompt Attachment Offset) – esta propriedade

indica a distância entre o item e seu prompt.
• Deslocamento de Alinhamento do Prompt (Prompt Alignment Offset) – indica o

deslocamento do prompt em relação ao ponto definido para alinhamento.
Para melhor entendimento as figuras a seguir apresentam as seguintes alterações em relação ao

posicionamento inicial:
Propriedade Original Fig. 24 Fig. 25

Justificação do Prompt Inicial Inicial Centralizado
Limite de Conexão do Prompt Topo Inicial Base
Alinhamento do Prompt Centralizado Inicial Final
Deslocamento de Conexão do Prompt 0 2 5
Deslocamento de Alinhamento do Prompt 0 7 5
Tabela 4
Fig. 24 - Prompt
Fig. 25 - Prompt

CAPÍTULO 4: CANVAS E WINDOWS

Para entendermos a relação entre estes dois elementos, comparemos com uma pintura. Quando
adquirimos um quadro, reconhecemos a existência de dois elementos : a tela e a moldura.
Da mesma forma, no Form, podemos entender a presença destes dois elementos, sendo a Canvas
considerada a tela e a Janela (Windows) considerada a moldura.
Janelas (Windows)
Quando criamos uma nova aplicação, é criada, automaticamente, uma janela (Window1).
Para que possamos apresentar as diversas telas (Canvas) da aplicação necessitamos montar pelo menos
uma janela. A janela faz a interface com o ambiente Windows.
Grupo Funcional
• Título(Title) - faz com que seja apresentado um título na janela (na barra azul superior).
• Canvas Principal (Primary Canvas) – Nesta propriedade indicaremos a primeira canvas a ser
apresentada nesta Janela. Esta propriedade só é obrigatória de preenchimento se viermos a
acionar a apresentação de uma janela por programação (rotina Show_Window). Caso
contrário a canvas apresentada corresponderá àquela que contém o primeiro item da
seqüência de navegação.
A seqüência de navegação é definida pelos blocos e itens. Um elemento que detém o foco nunca fica
escondido, ele sempre é apresentado, forçando o aparecimento da canvas onde ele está “espetado”.
• Canvas da Barra de Ferramentas Horizontal (Horizontal Toolbar Canvas) – Uma barra de

ferramentas corresponde a uma canvas contendo elementos (principalmente botões, que
efetuam ações sobre os itens apresentados na canvas principal). Nesta propriedade
informamos qual o nome da canvas (do tipo Barra de Ferramentas (não é Rolagem)
Horizontal) que será apresentada nesta janela.
Mesmo que criemos na aplicação uma canvas deste tipo, se esta propriedade não for
preenchida ela não será apresentada.
• Canvas da Barra de Ferramentas Vertical (Vertical Toolbar Canvas) – Nesta propriedade

informamos qual o nome da canvas (do tipo Barra de Ferramentas Vertical) que será
apresentada nesta janela. Esta propriedade deve ser preenchida para que a canvas seja
apresentada (não é automático).
• Estilo da Janela (Window Style)

– Esta propriedade possui duas
opções: Documento (Document) e
Caixa de Diálogo (Dialog). Indica
se a janela atual será apresentada
dentro da janela do Runtime
(F50Run) ou se ficará solta.
Fig. 26 – Janela estilo

Caixa de Diálogo (Dialog)
Na figura 26 apresentamos uma janela no

estilo Caixa de Diálogo. Observe que a janela
fica solta sobre a janela do Forms Runtime. No
caso do estilo Documento a janela da
aplicação fica subordinada (interna) à janela
do Forms Runtime.
CAPÍTULO 4: CANVAS E WINDOWS - 38

• Modal (Modal) – indica se a janela atual pode ou não perder o foco. Quando indicamos que
uma janela é Modal, o Form impede que o usuário navegue para outra janela sem fechar a
janela atual. Esta opção é muito utilizada para a apresentação de mensagens ou informações
de ajuda.
Se preenchermos esta propriedade com Sim e o estilo da janela com Caixa de Diálogo, a
tempo de execução não será possível a navegação para a janela do Forms Runtime, uma vez
que os controles de término (botões e menu) estão presentes nesta janela, haverá
necessidade de abortar a aplicação.
• Ocultar na Saída (Hide on Exit) – determina que se o foco for movido para um item
apresentado em outra janela, a janela atual deve ser posicionada atrás da que deterá o foco.
Caso esta propriedade esteja preenchida com Não, esta ação só ocorrerá se o item que
receberá o foco estiver escondido atrás da janela atual. Se ele estiver visível, a janela atual
continua na frente das demais.
• Fechamento Permitido (Close Allowed) – indica se o ícone ( X ) de fechamento da janela

pode ser utilizado pelo usuário.
Esta propriedade quando habilitada não fecha a aplicação a menos que tenhamos programado
(When-Window-Closed) esta ação. Isto significa que a aplicação recebe a indicação de que o
usuário tentou fechar a janela, mas como não existe nenhuma ação automática, nada
acontece.
Caso o usuário tente fechar a janela do Forms Runtime, o próprio Form determina o
fechamento da aplicação subordinada executando um comando Do_key(‘exit_form’).
• Movimentação Permitida (Move Allowed) – determina se o usuário poderá ou não

movimentar a janela da aplicação. A movimentação é obtida ao pressionarmos o botão
esquerdo do mouse sobre a parte azul da janela e movimentarmos o mouse sem soltar o
botão.
• Redimensionamento Permitido (Resize Allowed) – define se o usuário poderá ou não

aumentar(ou diminuir) o tamanho da janela. Esta modificação de tamanho é obtida quando
posicionamos o mouse sobre uma das laterais da janela e aparece um símbolo ( √ ) indicativo
da elasticidade. A maximização ou minimização são permitidas independentemente do valor
desta propriedade.
• Maximização Permitida (Maximize Allowed) – indica se a janela da aplicação poderá ser

maximizada.
• Minimização Permitida (Minimize Allowed) – indica se a janela da aplicação poderá ser

minimizada.
• Título Minimizado (Minimized Title) – informamos aqui o texto a ser apresentado quando a
janela é minimizada.
• Nome do Arquivo de Ícones (Icon Filename) – Indica o ícone a ser usado quando a janela é
minimizada.
• Herdar Menu (Inherit Menu) – Indica se a janela atual deve apresentar o Menu associado à
aplicação.

Canvas
Já sabemos que uma Canvas corresponde à tela de um quadro.
Em uma mesma janela podem ser apresentadas diversas canvas simultaneamente, porém apenas uma
delas pode ser de conteúdo (Content), pois esta é a canvas principal da janela.
Fig. 27 – Simultaneidade
das Canvas
Podemos apresentar em uma janela, simultaneamente:
• uma canvas do tipo Conteúdo (Content).

• uma canvas do tipo Barra de Ferramentas Horizontal (Horizontal Toolbar).
• uma canvas do tipo Barra de Ferramentas Vertical (Vertical Toolbar).
• várias canvas do tipo Empilhado (Stack).
• várias canvas do tipo Tab (Tab).
A propriedade que determina o tipo da canvas (Canvas Type) está presente no grupo Geral.

CANVAS DE CONTEÚDO (CONTENT)

Em uma canvas de conteúdo, o grupo Físico possui duas propriedades de interesse:
• Posição X do Visor no Canvas – uma canvas pode apresentar uma parte da informação na
janela. Esta parte visível é determinada por um objeto chamado visor (Viewport). O tamanho
deste visor para uma canvas do tipo Conteúdo é determinado pelo tamanho da janela onde se
apresenta a tempo de execução.
• Posição Y do Visor no Canvas – determina o posicionamento vertical do visor, isto é, a

posição do canto esquerdo superior em relação ao eixo Y (vertical). Veja o comentário da
propriedade anterior.
Fig. 28 – Posicionamento do Visor
No exemplo da figura 28, preenchemos as duas propriedades de posicionamento do visor com 30. Como
resultado, observamos que do trecho visível da Canvas foi omitido uma faixa à esquerda e uma faixa
superior.
CANVAS BARRA DE FERRAMENTAS (TOOLBAR)

Para que uma Canvas do tipo Barra de Ferramentas (Horizontal ou Vertical) fique visível, devemos
preencher a propriedade Canvas da Barra de Ferramentas Horizontal (Horizontal Toolbar Canvas) ou a
propriedade Canvas da Barra de Ferramentas Vertical (Vertical Toolbar Canvas) com o nome desta nova
canvas no grupo (Funcional) de propriedades da janela onde ela será apresentada.
Ao acionarmos o editor de Layout observaremos que a área prevista para desenho não foi diminuída, ou
seja, o tamanho da canvas deve ser diminuído manualmente por nós.
Quando definimos que uma canvas é do tipo Barra de Ferramentas Horizontal, o Form a apresenta acima
da canvas do tipo Conteúdo, independente do seu tamanho.
Uma canvas com o tipo de barra de ferramentas (horizontal ou vertical) não possui um Viewport.

CANVAS EMPILHADO (STACK)

Este tipo de canvas possui um grupo de propriedades chamado Visor (Viewport). Neste grupo definimos:
• Posição X do Visor (Viewport X Position) / Posição Y do Visor (Viewport Y Position) –

estas propriedades, na verdade, definem o posicionamento da canvas do tipo Empilhado
(Stack) em relação à canvas do tipo Conteúdo (Content) que preenche a janela.
• Largura do Visor (ViewPort

Width) / Altura do Visor (ViewPort
Height) – Em uma canvas do tipo
Empilhado devemos definir
explicitamente a largura e a altura
do Viewport.
Na figura 29 verificamos a presença de uma

Canvas do tipo Barra de Ferramentas e uma
Canvas do tipo Empilhado.
Normalmente, uma canvas do tipo Empilhado

não é visível logo que a aplicação mostra a
canvas de Conteúdo, de acordo com ações do
usuário ela é acionada por programação.
Fig. 29 – Canvas Empilhado e

Barra de Ferramentas
CANVAS TAB (TAB)

O último tipo de canvas (Tab) é similar a uma canvas Empilhado, também pode ser acionada por
programação, possui um grupo Visor que a posiciona na canvas de conteúdo, porém, adicionalmente
possui uma ou várias pastas dentro da canvas, nas quais podemos distribuir os elementos.
As características próprias deste tipo de Canvas estão presentes no grupo Físico:
• Estilo dos Cantos (Corner Style) – determina o aspecto que o contorno (os cantos) da
etiqueta de cada pasta assumirá. A diferença é sutil. Os valores válidos são: Quadrado,
Chanfrado e Arredondado.
• Estilo da Largura (Width Style) – Indica se a Canvas poderá ou não variar de tamanho. Os
valores válidos são: Fixo e Variável.
• Estilo Ativo (Style) – Os valores válidos são Normal e Negrito.
• Limite de Conexão de Tab (Tab Attachment Edge) – com esta propriedade determinamos
de que lado da pasta as etiquetas serão apresentadas.

CAPÍTULO 5: O EDITOR DE LAYOUT
Quadro (Frame)
Na figura 30, subordinado à canvas Canvas2, verificaremos a existência de um objeto chamado Frame5
que se constitui de um objeto exclusivamente gráfico para apresentação de informações em uma canvas.
Fig. 30 – Quadro de Layout
O grupo Quadro de Layout (Layout Frame) possui algumas propriedades já comentadas anteriormente,
mas que adquirem aspectos particulares neste objeto.
• Bloco de Dados de Layout (Layout Data Block) – Quando esta propriedade possui o valor
preenchido com o nome de um bloco de dados e a propriedade Atualizar Layout (Update
Layout) estiver com o valor Automaticamente (Automatic), qualquer modificação que fizermos
nas propriedades do Frame são refletidas nas propriedades do bloco, do item, etc. Os outros
elementos herdam as características que estabelecermos aqui.
• Atualizar Layout (Update Layout) – Indica se as modificações que efetuarmos para os

elementos, para as propriedades do quadro, etc serão refletidas automaticamente. Caso esta
propriedades esteja preenchida com o valor Manualmente, devemos pressionar o botão
Atualizar da barra de ferramentas superior do editor de layout para que elas sejam refletidas. A
opção Bloqueado impede a atualização.
• Estilo de Layout (Layout Style) – Indica a forma de organização dos elementos. Se a

atualização estiver automática, os objetos são reorganizados cada vez que aumentamos ou
diminuímos o tamanho do quadro.
• Alinhamento do Quadro (Frame Alignment) – Esta propriedade determina como os

elementos serão alinhados dentro da largura do Frame (Quadro). Utilizada quando o estilo de
layout é Form.
• Alinhamento de Objetos Simples (Single Object Alignment) – Indica o alinhamento de

cada objeto quando a propriedade anterior (Alinhamento do Quadro) possuir o valor
Preenchimento (Fill).
CAPÍTULO 5: O EDITOR DE LAYOUT - 43

• Margem Horizontal (Horizontal Margin) / Margem Vertical (Vertical Margin) – Especifica a

margem entre a borda do Frame e os objetos internos.
• Deslocamento Horizontal de Objeto (Horizontal Object Offset) / Deslocamento Vertical

de Objeto (Vertical Object Offset) – Estas propriedades definem a distância entre os objetos
dentro do Frame.
• Permitir Expansão (Allow Expansion) – Esta propriedade determina se o Form poderá

aumentar o tamanho do Frame se os objetos em seu interior ultrapassagem as bordas do
Frame.
• ShrinkWrap (ShrinkWrap) – Esta propriedade permite que o Form Builder aproxime o Frame
dos objetos internos. Quando aumentamos o tamanho do Frame e esta propriedade está
preenchida com Sim, o Form Builder diminui o Frame para que este fique próximo aos objetos.
• Preenchimento Vertical (Vertical Fill) – Esta propriedade indica se o Form Builder deve ou
não colocar o maior número possível de objetos por linha. Se esta propriedade estiver
preenchida com Sim, a propriedade que determina o número máximo de objetos por linha é
ignorada.
Fig. 31 - Quadro
Para obtermos o resultado da figura 31 preenchemos as propriedades Deslocamento Horizontal e Vertical

com 10, Expansão com Sim, ShrinkWrap com Sim e Preenchimento Vertical com Não.
OBS: A presença de Quadro não é obrigatória na Canvas.

A Janela do Editor de Layout

O Editor de Layout possui os seguintes componentes:
WORKSPACE
É a área de janela do Layout, ou seja, a área disponível para desenho. Seu tamanho é independente do
tamanho atual da janela, isto é, o Workspace pode ser maior ou menor que a área da janela.
Quando o Workspace é maior que a janela, podemos rolar a janela para ver outras partes do Workspace.
Para alterar o tamanho do Workspace, devemos selecionar no menu Formato (Format) o submenu Opções
de Layout (Layout Settings) e neste a opção Layout.
O diálogo apresentado permitirá que determinemos o tamanho do Workspace (em centímetros ou

polegadas) e ainda que façamos a definição da ordem de impressão(Vertical ou Horizontal) se
escolhermos a opção Imprimir(Print) do menu Arquivo(File).
BARRA DE TÍTULO(TITLE BAR)

É uma barra de informações que aparece na parte superior da janela, com:
<produto> [<modulo>:< canvas> ( <bloco> )], onde:
• <produto> - nome da ferramenta Oracle, neste caso Form Builder.

• <modulo> - nome do módulo ativo.
• <canvas> - nome da canvas corrente.
• <bloco> - nome do bloco corrente.
RÉGUAS (RULERS)
Uma régua horizontal (em cima) e uma vertical (lateral esquerda). Esta régua pode ser apresentada em
unidades diferentes (ex.: centímetros, caracteres, pés, etc.), de acordo com a unidade em vigor no Form.
GUIAS
Podem ser selecionadas guias (tracejadas) horizontais e verticais para referência.
Para selecionarmos uma guia basta que posicionemos o mouse sobre uma das réguas, o pressionemos e
arrastemos até a posição desejada para apresentação da guia.
GRID
Existe uma grade dentro do Workspace para auxílio no posicionamento de objetos. Se desejarmos
visualizar esta grade devemos esconder a visibilidade da canvas. Usar o menu Visualizar (View), opção
Mostrar Canvas (Show Canvas).
Se você testar esta opção e a grade não aparecer, não se assuste. Isto às vezes ocorre quando a
distância entre as linhas da grade é tão grande que dá a impressão que não tem grade.
Para corrigirmos esta situação, devemos selecionar no menu Formato, Opções de Layout, o item Régua
(será apresentado um diálogo que permitirá o espaçamento).
LINHA INDICATIVA DE SITUAÇÃO (STATUS LINE)

A linha de status no pé da página do layout mostra as seguintes informações:
• Posição absoluta do mouse.

• Distância de afastamento do mouse (quando criando / movendo objetos).
• Ângulo de rotação (quando em movimento).
• Nível de zoom.

As Barras de Ferramentas
Ao olharmos para a tela do Layout Editor observamos a presença de duas barras de Ferramentas
Superiores e uma Vertical, na lateral esquerda.
A BARRA DE FERRAMENTAS HORIZONTAL SUPERIOR

O primeiro conjunto de botões presentes na barra de ferramentas horizontal superior já é conhecido pois é
o mesmo conjunto que se encontra presente no Navegador de Objetos:
• Novo(New) - nova aplicação.
• Abrir(Open) - abrir uma aplicação existente.
• Salvar(Save) - gravar/salvar a aplicação atual.
• Executar(Execute) - executar a aplicação atual.
• Recortar / Copiar / Colar - estas ações recortam, copiam ou colam objetos no layout. Se
recortarmos um item ele será removido do Layout e do Navegador de Objetos, não sendo
possível seu retorno com o botão Colar.
• Atualizar Layout (Layout Update) – é capaz de efetuar a atualização do Layout quando

utilizamos um Frame e a propriedade Atualizar Layout recebeu o valor Manualmente. Quando
pressionamos este botão, as modificações efetuadas nas características do Frame ou dos
elementos internos são refletidas no Layout.
Os próximos três botões acionam os três Assistentes(Wizards) disponibilizados pelo Form Builder:
• Assistente de Bloco de Dados(Data Block Wizard)

• Assistente de Layout (Layout Wizard)
• Assistente de Gráfico (Graphics Wizard) - este assistente aciona o Oracle Graphics para o
desenvolvimento de um gráfico com os dados de um dos blocos de dados.
Em seguida temos um campo do tipo Lista que mostra uma lista de canvas. Quando selecionamos outra
canvas da lista, imediatamente o editor de Layout apresenta esta nova canvas. Neste editor somente
efetuamos a manipulação de uma canvas de cada vez.
O penúltimo elemento desta barra é um campo do tipo Lista que mostra uma lista de blocos(Contexto de
Bloco).
Esta lista tem a finalidade de indicar o bloco em que se encontra o elemento selecionado. Ao
selecionarmos um determinado elemento e escolhermos outro bloco, o elemento será transferido de bloco,
adquirindo a funcionalidade associada ao outro bloco.
• Ajuda (Help) – aciona a Ajuda do Editor.

A BARRA DE FERRAMENTAS HORIZONTAL INFERIOR

A segunda barra de ferramentas horizontal apresenta diversas ações associadas aos elementos, como
veremos a seguir.
As duas primeiras listas determinam o tipo de letra e tamanho. Para que esta ação tenha efeito devemos
selecionar(clicar o mouse sobre o elemento) o item ou objeto de texto (prompt por exemplo) e modificar
sua letra e tamanho.
Em seguida temos os botões que afetam as

características das letras B(Bold – Negrito), I (Italic –
Itálico), U(Underline – Sublinhado).
A figura 32 mostra os prompts de departamento e ramal

em negrito, de cargo e grau de instrução sublinhados e
de data de nascimento e do botão masculino do grupo
de rádio em itálico. Fig. 32 – Características das letras
Os botões seguintes aumentam ou diminuem o nível de Zoom. A indicação do nível atual se acha presente
no rodapé da tela de layout. Cada vez que pressionamos o botão Ampliar ( + ), o nível de Zoom é
duplicado. Da mesma forma, cada vez que pressionamos o botão Reduzir ( - ), o nível de Zoom é dividido
por dois.
O grupo de botões a seguir realiza alinhamento de elementos uns em relação aos outros. Os três primeiros
realizam o alinhamento horizontal e os três seguintes realizam o alinhamento em relação ao eixo Y
(vertical).
Para realizarmos este alinhamento devemos selecionar simultaneamente (clique com o mouse e mantenha
o botão Ctrl pressionado) os itens para os quais desejamos realizar o alinhamento (os quais devem estar
posicionados verticalmente uns acima dos outros) e pressionar um dos botões de alinhamento (esquerda,
central ou direita).
Para realizarmos o alinhamento horizontal, os itens selecionados devem estar lado a lado, caso contrário
serão posicionados uns sobre os outros.
O layout do Form é construído em duas camadas (Layers) principais. A primeira camada é a camada de
itens. A segunda camada é a camada de objetos gráficos.
Os itens podem ser sobrepostos entre si, assim como os objetos gráficos, porém um objeto gráfico não fica
sobre um item. Um item sempre tem precedência.
Os dois últimos botões desta barra de ferramentas possuem as ações de trazer para frente e enviar para
trás e se aplicam a objetos gráficos.

A BARRA DE FERRAMENTAS VERTICAL OU PALETA DE FERRAMENTAS

A barra de ferramentas vertical ou Paleta de Ferramentas possui um conjunto de botões que efetuam
diversas ações. Subdividimos estes botões em grupos comuns.
O primeiro grupo contém botões que se aplicam a diversos tipos de objetos, são gerais para os diversos
elementos presentes nas canvas:
Fig.33 – Botões da Paleta de Ferramentas
• Selecionar (Select) - seleciona um objeto ou grupo de objetos. Basta que efetuemos um

clique sobre o objeto desejado.
• Girar (Rotate) - gira os objetos (gráficos, itens não podem ser rodados). Para girarmos um
elemento devemos selecioná-lo, clicar na ferramenta e, com o mouse, pressionar um dos
indicadores de tamanho (presentes nos cantos do objeto) e sem soltar o botão esquerdo do
mouse rodar .
• Ampliar (Magnify) - aumenta ou reduz a apresentação do Layout (fator - 2x), isto é, zoom.
Para obtermos este efeito devemos clicar sobre o botão e em seguida sobre a canvas. O efeito
inverso é obtido com os mesmos movimentos, porém, a tecla Ctrl (ou Shift) deve esta
pressionada simultaneamente.
• Reformar (Reshape) - permite que se modifique um objeto (gráfico) selecionado (ex.: ângulo
de um arco). Para efetuarmos um teste com esta ferramenta, devemos criar um objeto do tipo
Arco, selecione-o na paleta de ferramentas e faça um arco. Com este objeto selecionado
pressione o botão Reformar. Você perceberá que apenas dois pontos ficam indicados no
elemento. Utilize o mouse para arrastar um destes pontos e modificar o ângulo do arco.
O segundo grupo de botões é composto de ferramentas gráficas, ou seja, ferramentas para a

criação de elementos gráficos, também chamados de boilerplates gráficos. Neste grupo se
encontram as ferramentas:
• Retângulo (Rectangle) - cria retângulos. Fig. 34 – Botões da

• Linha (Line) - cria objetos lineares (linha). Paleta de
• Elipse (Elipse) - cria objetos ovais. Ferramentas
• Arco (Arc) - cria objetos em forma de arco.
• Polígono (Polygon) - cria polígonos.
• Polilinha(Polyline) - cria linhas quebradas.
• Retângulo Arredondado (Rounded Rectangle) – cria retângulos com as bordas
arredondadas.
• Mão Livre (Freehand) - cria desenhos livres (linhas curvas).
• Texto (Boilerplate Text) - cria textos.
• Quadro (Frame) – cria Frames.

O terceiro grupo cria itens. Da mesma forma que fizemos no Navegador podemos criar itens diretamente
na Canvas desejada.
O único cuidado adicional a ser tomado é a identificação do bloco em que o item será criado.
Para que o elemento seja adicionado ao bloco desejado, devemos posicionar a lista que
contém os nomes dos blocos no bloco que pretendemos (Block Context). Esta lista se
encontra na Barra de Ferramentas Horizontal Superior.
Fig. 35 – Botões da
Paleta de Ferramentas.
• Botão (Button) - cria itens do tipo botão (Button)
• Caixa de Verificação (Check Box) – cria itens do tipo Caixa de Verificação

(Check Box).
• Botão de Rádio (Rádio Button) - cria itens do tipo Botão de Rádio. Ao criarmos um item
deste tipo o Form Builder criará um Grupo de Rádios (Radio Group) se não existir nenhum no
bloco definido ou apresentará uma lista de grupos para que façamos uma seleção entre os
existentes ou optemos pela criação de um novo.
• Itens de Texto (Text Item) - cria itens do tipo Texto(Text).
• Item de Imagem (Image Item) - cria um item do tipo imagem (Image).
• Item de Gráfico (Chart Item) - cria um item do tipo gráfico(Chart) desenhado no Oracle
Graphics.
• Recipiente OLE (OLE2 Object) - cria um item do tipo OLE2 para interface com outras
aplicações do ambiente Windows.
• Controle X Ativo (ActiveX Control) - cria um item do tipo Controle X Ativo (ActiveX) para
interface com um objeto OCX do ambiente Windows.
• Item de Exibição (Display Item) - cria um item do tipo Exibição (Display).
• Item de Lista (List Item) - Cria um item do tipo Lista (List).
• Item de Som (Sound) – Cria um item do tipo Som (Sound).
Neste conjunto ainda existem dois botões referentes à criação da Canvas Tab(Tab) e da Canvas
Empilhado(Stack). A vantagem da definição da Canvas diretamente no Layout é que podemos definir,
visualmente, seu posicionamento sobre uma canvas de Conteúdo (Content).
• Canvas de Guia (Canvas Tab) – cria uma canvas do tipo Tab (Pasta) e permite seu
posicionamento sobre a canvas Content desejada.
• Canvas Sobreposto (Canvas Stack) – cria uma canvas do tipo Empilhado (Stack) e permite
seu posicionamento sobre a canvas Content desejada.

O último grupo de botões contém o que chamamos de paleta de atributos visuais, pois os
botões presentes nesta paleta tem a finalidade de atribuir cor aos objetos (itens e
boilerplates).
Fig. 36 – Paleta de
Atributos Visuais
A paleta de atributos visuais contém os seguintes elementos:
• Caixa de Atributos (Attributes Box) - Reflete os atributos definidos para o objeto

selecionado. Quando um elemento é selecionado a Caixa de Atributos mostra a cor de borda,
a cor de preenchimento e a cor de letra do objeto. Quando nenhum objeto estiver selecionado,
ela mostra os atributos atualmente em uso, ou seja, qualquer objeto criado adquirirá estes
atributos.
• Cor de Preenchimento (Fill Color) - Indica as características de preenchimento do objeto.

Possui as seguintes opções:
- Um conjunto de cores - o objeto terá esta cor de preenchimento.

- Nenhum Preenchimento (No Fill) - o objeto será transparente
- Padrões (Patterns) - exibe a janela de textura quando desejamos que o objeto possua 2
cores de preenchimento simultaneamente (Foreground Color e Background Color).
- Tirar Paleta (Tear Off Palette) - fixa a janela de cores para movimentação.
• Cor de Linha (Line Color) - Indica as características da linha que envolve o objeto (borda).
Pode ser preenchido com um dos seguintes valores:
- Uma cor do conjunto - a linha terá esta cor de preenchimento.

- Nenhuma Linha (No line) - o objeto não terá borda visível.
- Tirar Paleta (Tear Off Palette) - fixa a janela de cores para movimentação.
• Cor de Texto (Text Color) - Indica a cor do texto. Podemos escolher uma das opções a
seguir:
- Uma cor do conjunto - o texto terá a cor selecionada.

- Tirar Paleta (Tear off palette) - fixa a janela de cores para movimentação.
Nota
A informação de cor de cada objeto é armazenada com um índice para localização de cor na paleta. Se
alterarmos a paleta, a conseqüência será a modificação involuntária da cor do objeto.

Manipulando uma Canvas no Editor de Layout

Algumas ações de manipulação de um objeto Canvas podem ser feitas diretamente com o editor de
Layout, sem utilização das propriedades, como veremos a seguir:
MOSTRAR OU ESCONDER A CANVAS

Para vermos a canvas devemos habilitar a opção Mostrar Canvas (Show Canvas) no menu Visualizar
(View). Se desabilitarmos esta opção a Canvas é escondida e apresentada a Grade (Grid) de fundo.
REDIMENSIONAR A CANVAS
O redimensionamento é feito com o cursor, clicando-se no canto inferior direito da canvas e arrastando-se
o mouse até a posição desejada, podemos modificar seu tamanho.
MUDAR OS ATRIBUTOS VISUAIS DA CANVAS

Quando a canvas é selecionada podemos escolher a cor e a textura como qualquer outro objeto. Para isto
basta que façamos a seleção da Canvas (clicando-se no canto inferior direito) e usando a parte de
Atributos Visuais da Paleta de Ferramentas.
MOSTRAR OU ESCONDER O VIEWPORT

Quando ativamos o layout, o viewport fica, inicialmente, invisível. Para visualizarmos o viewport, devemos
habilitar a opção (Mostrar View (Show View) no menu Visualizar (View).
O Viewport aparecerá como um retângulo com os cantos pretos (quadrado preto). Esta opção só é válida
para Canvas do tipo Empilhado (Stack).
MOVER O VIEWPORT
Para mover o viewport, usamos o mouse ou o teclado (teclas de setas para direita, para esquerda, para
cima ou para baixo). Esta opção irá alterar as coordenadas do Viewport, que podem ser verificadas no
conjunto de propriedades da canvas.
POSICIONAR CANVAS(EMPILHADA OU TAB) SOBRE CANVAS DE CONTEÚDO

Podemos visualizar uma Canvas do tipo Empilhado sobre uma Canvas de Conteúdo a fim de, mais
facilmente, determinarmos seu tamanho e posição.
Para tal, devemos abrir o editor de Layout com a Canvas de Conteúdo e, no menu Visualizar (View),
escolher a opção Views Sobrepostas (Stacked Views). Será, então, apresentado um diálogo contendo uma
lista de Canvas do tipo Tab ou Empilhado (Stack) definidas em sua aplicação.
Para apresentarmos uma destas canvas, devemos clicar sobre ela (ficará em azul) e apertar o botão OK.
O Layout será novamente mostrado com a Canvas apresentada sobre a outra.
Para escondermos novamente esta Canvas devemos abrir o diálogo anterior novamente (opção Views
Sobrepostas do menu Visualizar). Será apresentada uma lista com a Canvas em questão marcada (azul).
Para desmarcá-la, devemos pressionar a tecla Ctrl e clicar sobre a linha contendo o nome da Canvas. Em
seguida apertar o botão OK.
O Layout será novamente mostrado sem a Canvas apresentada sobre a outra.
Se desejarmos efetuar seu dimensionamento devemos selecioná-la (canto esquerdo inferior), para que
sejam apresentados os indicadores de tamanho e possamos dimensioná-la adequadamente.
Uma maneira mais fácil de identificarmos o posicionamento desta Canvas é antes de iniciar este processo
pintá-la de outra cor para sua visualização ser total.
A movimentação requer que a Canvas esteja selecionada. Utilize o teclado (seta para cima, seta para
baixo, seta para direita e seta para esquerda) para a movimentação.

Manipulando Itens no Editor de Layout

Neste tópico veremos, passo a passo, as etapas necessárias para efetuarmos diversas ações sobre os
itens usando, diretamente, o editor de Layout.
CRIANDO ITENS
Para criarmos um novo item, devemos cumprir os seguintes passos:
• Selecionar o bloco onde o item será criado (Barra de Ferramentas Horizontal Superior).
• Na paleta de ferramentas, selecionar a ferramenta para o tipo de item que desejamos criar.
• Posicionar o cursor na canvas onde desejamos que seja o canto esquerdo superior do item
seja posicionado.
• Pressionar o mouse uma vez para criação de itens no tamanho default ( de acordo com a fonte
selecionada) ou pressionar e arrastar o mouse até o desenho atingir o tamanho desejado.
O Form Builder vai associar o novo item ao bloco corrente. se este bloco for do tipo multi-record, mostrará
“n” desenhos do item, um para cada registro do bloco.
MARCANDO O CONTEXTO PARA UM BLOCO

Na janela do Layout existe uma identificação para o bloco corrente. Para modificar o bloco corrente
devemos selecionar da lista de blocos disponível(na Barra de Ferramentas Horizontal Superior) o bloco
desejado.
MOVER ITENS
Para mover um item, usamos o mouse. Esta opção irá alterar as coordenadas do item, que podem ser
verificadas no conjunto de propriedades do item selecionado.
REDIMENSIONANDO OBJETOS NA CANVAS

O dimensionamento de um objeto em relação a outro
pode ser feito com a opção Dimensionar Objetos (Size
Objects) do menu Organizar (Arrange).
Neste diálogo poderemos dimensionar os objetos

selecionados pelo maior, pelo menor, pela média ou
atribuir um valor específico.
Fig. 37 – Diálogo
Dimensionar Objetos
Este valor pode ser fornecido nas unidades: polegadas, centímetros, pontos ou caracteres.
Posteriormente, podemos reutilizar as opções definidas sem necessidade de reabrir o diálogo usando a
opção Repetir Dimensionamento (Repeat Sizing) do mesmo menu Organizar (Arrange).

ALINHANDO OBJETOS NA CANVAS

O alinhamento pode ser feito em relação à grade
(grid) ou um objeto em relação ao outro. Para tal,
devemos escolher a opção Alinhar Objetos (Align
Objects) no menu Organizar (Arrange).
As opções de alinhamento dependem da direção

horizontal ou vertical. Algumas destas opções já
foram vistas nos botões da Barra de Ferramentas
Horizontal Inferior.
• Horizontalmente temos: esquerda, direita,

centralizar, distribuir (espaços entre
objetos horizontalmente iguais) e pilha
(objetos colados lateralmente uns nos Fig. 38 – Diálogo
outros). Alinhar Objetos
• Verticalmente temos: topo, base, centralizar, distribuir (espaços entre objetos verticalmente
iguais) e pilha (objetos colados lateralmente uns nos outros).
O alinhamento também pode ser repetido com a opção Repetir Alinhamento (Repeat Alignment) do menu
Organizar (Arrange).
OBTER AS PROPRIEDADES DE UM ITEM

As propriedades podem ser obtidas de 2 formas diferentes:
efetuando-se um duplo clique sobre o item

usando-se o botão direito do mouse

Manipulando Boilerplates no Editor de Layout

BOILERPLATE DE TEXTO
Para criar um Boilerplate de Texto, devemos:
• Selecionar a ferramenta Texto (Text) na Paleta de Ferramentas.

• Posicionar e pressionar o mouse no local que desejamos escrever o texto .
• Digitar o texto desejado.
• Cancelar o modo texto, pressionando o mouse fora do espaço do texto.
Para editar um texto já existente:
• Selecionar a ferramenta Texto (Text) na Paleta de Ferramentas.

• Posicionar e pressionar o mouse sobre o texto que desejamos alterar .
• Editar o texto.
• Pressionar o mouse fora do espaço do texto.
BOILERPLATE GRÁFICO
Para adicionarmos um boilerplate gráfico a uma Canvas, usamos as ferramentas adequadas da paleta de
ferramentas.
O modo de criação é semelhante ao visto anteriormente para Boilerplate de Texto, Items, etc.

Ações comuns aos Objetos de Layout

ATRIBUINDO FONTE
Para modificarmos a fonte de um elemento qualquer, devemos
selecioná-lo e escolher a opção Fonte (Font) no menu Formato.
Fig. 39 – Diálogo
Fonte
Neste diálogo podemos determinar a fonte, estilo de letra, tamanho
e efeitos para o item ou boilerplate selecionado.
Algumas destas opções também se acham presentes na Barra de

Ferramentas Horizontal Inferior.
MODIFICANDO A LINHA
Existem cinco opções para customização de linha:
• Largura da Linha (Line Width) – Apresenta um conjunto de opções de espessuras de linha.

• Bevel(Bevel) – Apresenta um conjunto de opções relevo para linha.
• Traço(Dash) – Apresenta um conjunto de tipos de linhas (tracejado, pontilhado, contínua, etc).
• Setas(Arrow) – Apresenta opções para inclusão de setas nas linhas.
• Borda(Border) – Apresenta a possibilidade de apresentarmos ou escondermos qualquer um
dos quatro lados da borda de um elemento.
ALINHAMENTO E ESPACEJAMENTO
O alinhamento e espacejamento dos textos dos itens pode ser feito com as
opções Espacejamento de Texto (Spacing) e Justificar (Alignment).
O espacejamento diz respeito ao espaço interno entre linha de um objeto.

Facilmente visível quando um boilerplate de texto ocupa mais de uma linha.
Na figura 40 o texto foi centralizado com espacejamento duplo.

Fig. 40 – Espacejamento
e Alinhamento
SELEÇÃO DE UM OU VÁRIOS OBJETOS
Para manipular objetos (redimensionar, cortar, copiar, mover, colar, etc.), devemos inicialmente selecioná-
los. Para isto usamos as opções SELECT da paleta de ferramentas.
A seleção de um único elemento é feita quando clicamos sobre ele.
A seleção de diversos elementos pode ser feita de duas maneiras:
• Clicando-se sobre os diversos elementos, mas mantendo a tecla Ctrl pressionada.

• Desenhando-se um retângulo (apenas com a ferramenta Select) em torno de todos os
elementos desejados.

OPERAÇÕES
As seguintes operações podem ser feitas com objetos (itens e boilerplates):
• Movimentação – pode ser feita diretamente com o cursor.
• Redimensionamento – pode ser feito diretamente com o cursor.
• Recorte - após a seleção, devemos escolher a opção Recortar (Cut) ou Copiar (Copy) do
menu Editar (Edit). A opção Recortar, quando aplicada a um item age como a opção Limpar
(Exclusão).
• Colagem - selecionar a opção Colar (Paste) do menu Editar (Edit).
• Exclusão - usar a opção Limpar (Clear) do menu Editar (Edit )ou apertar a tecla Delete.
• Duplicação - após a seleção, usar a opção Duplicar (Duplicate) do menu Editar (Edit).
Quando duplicamos um item, no mesmo bloco, o Form Builder associa um novo nome a este item, uma
vez que os nomes devem ser únicos dentro de um bloco.
Quando duplicamos um item, todos os triggers(veremos no próximo capítulo) associados a ele são
duplicados também.
ASSOCIAÇÃO PROMPT – ITEM

Esta característica pode nos auxiliar quando tivermos definido um label para um item usando um
boilerplate e, posteriormente, desejarmos que o boilerplate de texto torne-se o Prompt do item.
Para que a associação seja estabelecida, devemos selecionar simultaneamente os dois elementos e
pressionar o botão Prompt Associado, presente na barra de ferramentas inferior da janela do Editor de
Layout (último botão à direita) ou usar a opção Prompt Associado do menu Organizar.

CAPÍTULO 6: EVENTOS E GATILHOS (TRIGGERS)
Conceitos
EVENTOS
Uma aplicação Form é sensível a eventos ou orientada a eventos. Isto significa que quando determinadas
situações ocorrem a aplicação recebe uma indicação e pode efetuar uma ação.
Por exemplo, suponhamos que o usuário tenha pressionado o mouse sobre um item do tipo botão. A
aplicação recebe uma indicação de que esta situação (evento) ocorreu e pode ou não realizar uma ação.
Para usarmos a nomenclatura da ferramenta diremos que um trigger é ativado pelo Form em resposta a
um evento.
GATILHOS(TRIGGERS)
Gatilhos (Triggers) são blocos de código PL/SQL que escrevemos para adicionar funcionalidade a uma
aplicação. Gatilhos (Triggers) são ativados ou acionados pelo Form em resposta a um evento.
Os nomes dos gatilhos (triggers) correspondem aos eventos. É o nome que estabelece a associação entre
o evento e o código do trigger.
Destas três afirmativas concluímos que quando um evento ocorre o Form verifica se adicionamos algum
código de PL/SQL a este evento (ou seja a um trigger). Caso isto tenha ocorrido ele executa o código que
tivermos definido.
CAPÍTULO 6: EVENTOS E GATILHOS (TRIGGERS) - 57

Escopo de um Gatilho (Trigger)

Um trigger deve ser associado a um objeto específico no Form: um item, um bloco ou ao próprio módulo.
O objeto ao qual o trigger é associado define seu escopo.
O escopo, ou abrangência, determina quando um evento deve ocorrer para que o trigger seja acionado.
ITEM
Um trigger definido a nível de item, isto é, associado a um determinado item, só é acionado se o evento
ocorrer enquanto o foco estiver exatamente no item escolhido.
BLOCO
Um trigger definido a nível de bloco, isto é associado a
um determinado bloco, só é acionado se o evento
ocorrer enquanto o foco estiver em algum dos itens ou
em algum dos registros do bloco escolhido.
MÓDULO
Um trigger definido a nível de módulo é o mais
abrangente. O trigger será acionado se o evento ocorrer
enquanto o foco estiver em qualquer dos itens, registros
ou blocos da aplicação (módulo).
No Navegador de Objetos podemos facilmente verificar

a existência dos nós onde poderemos incluir gatilhos
(triggers).
Fig. 41 – Escopo de um Gatilho
Na figura 41 encontramos uma imagem do Navegador de Objetos (Object Navigator) contendo três
gatilhos (triggers) criados nos três níveis disponíveis: When-New-Form-Instance (a nível de módulo),
When-Validate-Record (a nível de bloco - Func) e When-Validate-Item (a nível de item – cd_mat).
ORDEM DE EXECUÇÃO
Quando definimos o mesmo trigger em diferentes níveis, normalmente o Form define que o trigger de nível
mais baixo, ou seja, aquele mais específico seja acionado.
Suponhamos que tivéssemos definido um mesmo trigger para o item cd_mat e para o bloco Func.
Se o evento ocorresse enquanto o foco estivesse sobre o item cd_mat, o trigger acionado seria aquele
definido a nível de item, porém, se o evento ocorresse enquanto o foco estivesse em qualquer outro item
do bloco Func, o evento acionado seria aquele definido a nível de bloco.
Esta é a forma normal de ação da ferramenta. Podemos, no entanto, desejar que quando o evento ocorrer
no item cd_mat, ambos os gatilhos (triggers) (a nível de item e a nível de bloco) sejam acionados. Esta
opção é uma das propriedades que poderemos definir para um trigger (hierarquia de execução).
RESTRIÇÕES
Alguns gatilhos (triggers) somente podem ser definidos em um nível específico, ou seja, não podemos criar
sua definição em todos os três níveis.
Para que não haja dúvidas e erros de definição, o Form não disponibiliza todos os gatilhos (triggers) em
todos os níveis.
Quando criamos um trigger escolhemos de uma lista pré definida a qual evento faremos referência. Na
lista apresentada somente os eventos válidos para o nível particular são mostrados.

Criando Gatilhos (Triggers)

Para a criação de um gatilho (trigger), devemos realizar as etapas a seguir:
• Como primeiro passo selecionamos o nó onde desejamos criar o gatilho.
• Como segundo passo podemos:
- pressionar o botão direito do mouse e escolher um evento da opção Gatilhos Inteligentes

(Smart Triggers), a qual apresenta uma lista reduzida contendo os eventos mais usados
para o nível e tipo de elemento escolhido, ou seja, uma lista sensível ao contexto.
- pressionar a teclar Criar (Create) da barra de ferramentas do Navegador, que apresentará

um diálogo contendo toda a lista de eventos disponíveis para o nível definido, também é
uma lista sensível ao contexto.
• O próximo passo será a definição do texto de PL/SQL associado ao gatilho, pois que o editor
de PL/SQL será acionado neste momento.
O EDITOR DE PL/SQL
A janela do editor nos apresenta algumas informações a respeito do código de PL/SQL em definição.
Na parte superior encontramos um conjunto de botões com as seguintes funcionalidades:
• Compilar (Compile) – aciona a execução do compilador PL/SQL para o bloco.
• Reverter (Revert) – desfaz todas as modificações realizadas desde a última salva ou

compilação bem sucedida (que realiza uma salva).
• Novo (New) – cria um novo gatilho (trigger) com o mesmo escopo do atual. Um diálogo
contendo a lista de eventos é apresentada.
• Deletar (Delete) – Remove o gatilho atual.
• Fechar (Close) – Fecha e salva as modificações efetuadas, sem compilar.
• Ajuda (Help) – Aciona o mecanismo de ajuda. Apresenta um diálogo contendo a informações

sobre o editor PL/SQL.
Imediatamente abaixo dos botões é apresentado o tipo e escopo do objeto atual:
• Tipo – Indica se o código de PL/SQL refere-se a um gatilho (trigger), unidade de programa

(program unit) ou item de menu (menu item). O editor de PL/SQL é o mesmo nas três situação
com esta mesma janela de diálogo.
• Objeto – Indica o escopo do gatilho (trigger) :
- Se o gatilho (trigger) foi criado a nível de módulo, a primeira lista estará preenchida com o
texto “Nível de Form”(Form Level) e a segunda lista ficará vazia.
- Se o gatilho (trigger) foi criado a nível de bloco, a primeira lista estará preenchida com o
nome do bloco e a segunda lista com “Nível de Bloco de Dados” (Data Block Level).
- Se o gatilho (trigger) foi criado a nível de item, a primeira lista estará preenchida com o
nome do bloco e a segunda lista com o nome do item.
Finalmente a última linha de informações apresenta o nome do gatilho (trigger), da unidade de programa
(program unit) ou do item de menu (menu item).
Estas listas também podem ser utilizadas para navegação entre os diversos códigos de PL/SQL da
aplicação. Basta que modifiquemos o elemento da lista.

Classificação dos Gatilhos (Triggers)

Para que possamos escolher o evento mais adequado ao código PL/SQL que desejamos definir é
importante que tenhamos um bom conhecimento da situação exata que causa o evento e
consequentemente a execução do gatilho (trigger).
Neste tópico incluiremos gatilhos de diversos tipos na aplicação para que tenhamos condições de verificar
o momento exato de sua execução.
O Form percebe uma grande quantidade de eventos. Por este motivo eles foram subdivididos em grupos
que facilitam nosso entendimento sobre o momento de sua ocorrência.
Existem duas formas de subdividirmos os triggers: Por Nome e Por Categoria Funcional.
CLASSIFICAÇÃO POR NOME

A classificação Por Nome determina em que momento os gatilhos são acionados a partir do nome do
trigger:
• When-<evento> - indica um ponto em que podemos adicionar código ao processamento

default do Forms, isto é, o Form age normalmente e ainda realiza as tarefas que
determinamos. Não estamos modificando as ações padrões do Forms, apenas adicionando
funcionalidade.
• On-<evento> - indica um ponto em que substituímos o processamento default do Forms. Para

todos os eventos que comecem com a palavra ON, devemos ter cuidados adicionais, pois
estaremos modificando as ações padrões do Forms. Quando incluímos um gatilho associado a
um evento iniciado com ON, devemos suprir a ação feita pelo Form pois ele não mais a fará.
Estamos indicando que assumiremos a responsabilidade de programar aquela ação.
• Pre-<evento> - indica um ponto em que podemos adicionar código ao processamento default

do Forms. Os gatilhos associados a eventos iniciados com Pre são executados antes dos
gatilhos iniciados com When (o mesmo evento) e dos gatilhos iniciados com ON (o mesmo
evento). Com este tipo de gatilho não estamos modificando as ações padrões do Forms,
apenas adicionando funcionalidade.
• Post-<evento> - indica um ponto em que podemos adicionar código ao processamento default

do Oracle. Os gatilhos associados a eventos iniciados com Post são executados depois dos
gatilhos iniciados com When (o mesmo evento) e depois dos gatilhos iniciados com ON (o
mesmo evento). Com este tipo de gatilho não estamos modificando as ações padrões do
Forms, apenas adicionando funcionalidade.
• Key-<evento> - possuem uma ligação direta com o teclado. O evento é causado quando o
operador pressiona uma seqüência de teclas pré definidas. Um gatilho para este tipo de
evento faz a substituição do processamento default do Forms. Isto significa que quando
adicionamos este tipo de gatilho estamos indicando ao Forms que a ação implícita será
suprida por programação.

CLASSIFICAÇÃO POR CATEGORIA FUNCIONAL

Este tipo de classificação subdivide os eventos de acordo com a situação em que são causados,
independente do seu nome:
• Validação – os eventos classificados neste grupo estão associados ao momento de validação.

O Form valida individualmente os itens e os registros. Quando o Form tem necessidade de
efetuar uma validação, podemos incluir nossas próprias regras de validação em adição (e
após) àquelas estabelecidas por ele.
• Processamento do Bloco – os eventos classificados neste grupo estão associados a ações

sobre o buffer bloco. O Form controla a necessidade de inclusão, exclusão ou alteração de
linhas no banco de dados através da área de buffer. Quando ocorrem mudanças na situação
de um registro ou mesmo de todo o buffer, temos condições de incluir ações em adição
àquelas já realizadas por ele.
• Interface – neste grupo se encontram todos os eventos ligados a ações do usuário, sejam elas
realizadas com o mouse ou com o teclado. Alguns eventos deste grupo são acionados apenas
quando o usuário efetua uma ação (pressiona o mouse sobre um botão, por exemplo), outros
são acionados quando o usuário efetua uma ação ou por programação (redimensionamento de
uma janela, por exemplo).
• Query – os eventos classificados neste grupo estão associados ao momento da consulta ao

banco de dados, ou seja, quando o Form monta a query que efetivamente será enviada para o
banco de dados e quando ele faz a leitura de cada uma das linhas selecionadas. Nestes dois
momentos poderemos incluir ações em adição àquelas já estabelecidas por ele.
• Navegação – os eventos classificados neste grupo estão associados à navegação, ou seja o

momento em que o foco muda de um item para outro. Esta mudança pode ocorrer entre itens
de um mesmo registro, de registros diferentes, de blocos diferentes e, ainda para fora da
aplicação ou na entrada de uma aplicação. De acordo com o tipo de navegação um conjunto
particular de eventos é causado. Quem causa este tipo de evento pode ser o usuário ao mudar
de item ou a programação ao comandar a mudança.
• Controle de Mensagem – este grupo de eventos está associado à recepção e apresentação

de mensagens por parte do Forms. Podemos interceptar e modificar as mensagens recebidas
por ele ao criarmos gatilhos(triggers) para os eventos deste grupo.
• Relacionamento entre Blocos (Master-Detail) – este grupos de eventos encontra-se ligado

às ações padrões realizadas pelo Form quando ele realiza o controle de leitura e atualização
de blocos relacionados. Podemos interferir neste controle e modificar as ações padrões
realizadas pelo Forms.
• Transação – este grupo de eventos encontra-se ligado ao momento em que o Form realiza a
comunicação com o banco de dados seja para efetivação da transação, leitura de dados
(Select), início e fim de conexão ou bloqueio (lock). Deste grupo os gatilhos mais importantes
são aqueles ligados à efetivação da transação. São a estes que daremos especial atenção.
Estudaremos individualmente cada um dos grupos desta segunda classificação e simultaneamente

chamaremos atenção para os gatilhos que venham a adicionar ou modificar a funcionalidade padrão.
ROTINAS PRÉ-DEFINIDAS
O Form possui mais de 100 rotinas que permitem a realização de diversas ações por programação, tais
como:
• navegação entre itens OBS: A lista destas funções pode ser

• envio de mensagens consultada diretamente no Form dentro do
• obtenção do valor de propriedades nó Pacotes Embutidos (Built-In Packages)
• alteração no valor de propriedades e, ainda, dentro dos manuais de ajuda
• e muitas outras ações (obtidos através do menu Ajuda).

GATILHOS PARA VALIDAÇÃO

Os eventos classificados neste grupo estão associados ao momento de validação.
O Form valida individualmente os itens e os registros. Quando o Form tem necessidade de efetuar uma
validação, podemos incluir nossas próprias regras de validação em adição (e após) àquelas estabelecidas
por ele.
Existem apenas dois eventos neste grupo:
• When-Validate-Item – Este evento é

causado todas as vezes que o Form
percebe que um item sofreu algum tipo de
modificação e precisa ser validado
novamente.
Após haver modificado o valor do item o

usuário poderá tentar navegar para outro item
ou salvar o registro ou quando a programação
Fig.42 – Gatilho When-Validate-Item criado a
executar uma ação de navegação ou de
nível do item cd_mat do bloco Func
atualização.
Um gatilho associado a este evento é ideal quando desejamos adicionar algum tipo de validação a
um determinado item (neste caso podemos criar este gatilho a nível de item) ou quando desejamos
adicionar algum tipo de validação comum a qualquer um dos itens do registro (neste caso
podemos criar este gatilho a nível de bloco).
• When-Validate-Record – Este evento é causado todas as vezes que o Form percebe que
houve alguma mudança no registro e este precisa ser validado novamente.
Esta validação ocorre no momento em que o usuário tenta navegar para outro registro ou quando
ocorre o processamento padrão do Form (um Commit por exemplo) e, ainda, quando causamos
uma destas duas situações por programação.
Como todos estes gatilhos começam com When, eles serão acionados após o evento padrão, isto é, após
a validação padrão do Forms, em adição a esta.
Na figura 42 apresentada, observamos:
• que o gatilho está a nível de item (o nome do bloco e o nome do item estão preenchidos).
• que não precisamos definir um bloco de PL/SQL completo pois o Form adiciona um Begin
antes destes comandos incluídos no gatilho e um End no fim. Desta forma se desejarmos
incluir uma variável ou qualquer tipo de código mais complexo podemos considerar que
estamos dentro de um bloco de PL/SQL, ou seja, podemos definir quantos blocos
independentes ou aninhados desejarmos.
• que a rotina message recebe dois parâmetros (no entanto só informamos um).
- O primeiro corresponde à mensagem que desejamos apresentar (na linha de mensagens

no rodapé da tela).
- O segundo indica que se enviarmos duas mensagens consecutivas, o Form pode

apresentar a primeira delas em uma janela modal e a segunda na linha de mensagem
normalmente (esta é a ação default), o valor do parâmetro neste caso é Acknowledge.
Caso não desejemos a presença desta janela modal, o Form enviará uma mensagem em
seguida da outra na linha de mensagens sem intervalo entre elas, o que poderá causar a
perda da primeira. Neste caso o segundo parâmetro deve ser preenchido com
No_Acknowledge.

GATILHOS PARA PROCESSAMENTO DO BLOCO

Os eventos classificados neste grupo estão associados a ações sobre o buffer bloco. O Form controla a
necessidade de inclusão, exclusão ou alteração de linhas no banco de dados através da área de buffer.
Quando ocorrem mudanças na situação de um registro ou mesmo de todo o buffer, temos condições de
incluir ações em adição àquelas já realizadas por ele.
Neste grupo se encontram os seguintes eventos:
• When-Create-Record – Este gatilho será acionado quando o Form cria um novo registro em
um bloco.
• When-Clear-Block – Este gatilho será acionado quando o Form limpa o bloco corrente,
esvazia a área de buffer.
• When-Database-Record – Este gatilho será acionado quando o Form modifica o estado de

um determinado registro, passando de New para Insert ou de Query para Update. Com esta
modificação este registro passa a ser considerado como pendente de atualização, ou seja,
deve ser enviado para o banco de dados.
• When-Remove-Record – Este gatilho será acionado quando um determinado registro é limpo

ou removido.
Como todos estes gatilhos começam com When, eles serão acionados após o evento padrão, isto é, após
a remoção do registro ou após o registro ter mudado de estado ou após a criação do registro, etc. Podem
ser acionados pelo usuário ou por programação.
Estes gatilhos podem ser adicionados a nível de item, bloco ou Forms. Seu uso mais comum, no entanto,
é a nível de bloco.
Quando incluímos um gatilho (trigger) a nível de item, por exemplo When-Database-Record, estamos
indicando que somente se a mudança de estado do registro ocorrer enquanto o foco estiver no item
específico é que o gatilho será acionado.
Quando incluímos a nível de Form indicamos que se ocorrer mudança no estado de qualquer registro de
qualquer bloco o gatilho deverá ser acionado. A nível de bloco indicamos que quando ocorrer uma
modificação para qualquer registro daquele bloco o gatilho deverá ser acionado.
Nota
Quando indicamos ao Form para remover um registro (do banco de dados) ele o retira do buffer e
armazena seu rowid em uma lista de linhas a serem removidas.
Quando modificamos(ou incluímos) um registro e desistimos da modificação acionando a ação de Clear-

Record (Limpar Registro), o Form o retira do buffer, porém sem armazenar qualquer outra informação.
Sendo assim, todas as vezes que retiramos uma linha do buffer seja lá qual for o motivo estaremos
acionando o gatilho When-Remove-Record.

GATILHOS ASSOCIADOS À INTERFACE

Neste grupo se encontram todos os eventos ligados a ações do usuário, sejam elas realizadas com o
mouse ou com o teclado.
Alguns eventos deste grupo são acionados apenas quando o usuário efetua uma ação (pressiona o mouse
sobre um botão, por exemplo), outros são acionados quando o usuário efetua uma ação ou por
programação (redimensionamento de uma janela, por exemplo) :
• When-Button-Pressed – Inicia uma ação quando um operador seleciona(pressiona) um botão

seja com o mouse ou com o teclado. Este evento não é causado por programação.
• When-CheckBox-Changed – Inicia uma ação quando o operador troca o estado de um item

do tipo caixa de verificação (Check Box). Este evento pode ser causado por mouse, teclado ou
programação.
• When-Image-Activated – Inicia uma ação quando o operador realiza um click duplo em um

item do tipo imagem.
• When-Image-Pressed – Inicia uma ação quando o operador realiza um click simples em um

item do tipo imagem.
• When-List_Activated – Inicia uma ação quando um operador efetua uma click duplo em uma
lista do tipo T-List.
• When-List-Changed – Inicia uma ação quando um operador modifica o valor do item,

selecionando outro elemento da lista. Quando a lista é do tipo Combo, este evento também é
causado quando o operador esvazia ou digita um novo valor para o item.
• When-Mouse-Click – Este gatilho é acionado quando o operador faz um click em qualquer

item do módulo ou em qualquer canvas se o gatilho estiver a nível de módulo. Se o gatilho
estiver a nível de bloco ou a nível de item, somente se o click for dado no item específico ou
em um dos itens do bloco específico. Quando um usuário faz um click com o mouse, os
seguintes eventos são causados: Mouse Down, Mouse Up e Mouse Click, nesta ordem.
• When-Mouse-DoubleClick – Este gatilho é acionado quando o operador faz um click duplo

em qualquer item do módulo ou em qualquer canvas se o gatilho estiver a nível de módulo. Se
o gatilho estiver a nível de bloco ou a nível de item, somente se o click duplo for dado no item
específico ou em um dos itens do bloco específico. Quando um usuário faz um click duplo com
o mouse, os seguintes eventos são causados: Mouse Down, Mouse Up, Mouse Click, Mouse
Down, Mouse Up e Mouse DoubleClick nesta ordem.
• When-Mouse-Down – Este gatilho é acionado quando o operador faz um click em qualquer

item do módulo ou em qualquer canvas se o gatilho estiver a nível de módulo. Se o gatilho
estiver a nível de bloco ou a nível de item, somente se o click for dado no item específico ou
em um dos itens do bloco específico.
• When-Mouse-Enter - Este gatilho é acionado quando o operador move o mouse(sem

pressioná-lo), entrando, em qualquer item do módulo ou em qualquer canvas e se o gatilho
estiver a nível de módulo. Se o gatilho estiver a nível de bloco ou a nível de item, somente se
operador mover o mouse (entrando) em um item específico ou em um dos itens do bloco
específico.
• When-Mouse-Leave - Este gatilho é acionado quando o operador move o mouse(sem

pressioná-lo), saindo, de qualquer item do módulo ou de qualquer canvas e se o gatilho estiver
a nível de módulo. Se o gatilho estiver a nível de bloco ou a nível de item, somente se
operador mover o mouse (saindo) de um item específico ou de um dos itens do bloco
específico.

• When-Mouse-Move - Este gatilho é acionado quando o operador move o mouse(sem

pressioná-lo) em qualquer item do módulo ou em qualquer canvas e se o gatilho estiver a nível
de módulo. Se o gatilho estiver a nível de bloco ou a nível de item, somente se operador mover
o mouse em um item específico ou em um dos itens do bloco específico.
• When-Mouse-Up - Este gatilho é acionado quando o operador solta o botão do mouse após
um click em qualquer item do módulo ou em qualquer canvas se o gatilho estiver a nível de
módulo. Se o gatilho estiver a nível de bloco ou a nível de item, somente se o operador soltar o
botão do mouse no item específico ou em um dos itens do bloco específico.
• When-Radio-Changed – Inicia uma ação quando o operador altera o botão selecionado em

um grupo de rádios (radio group).
• When-Tab-Page-Changed – Inicia uma ação quando o operador modifica a página ativa de

uma canvas Tab. O evento só é causado se a mudança de página for explícita. Uma
navegação entre itens em páginas diferentes não causa o evento.
• When-Timer-Expired – Inicia uma ação quando o tempo programado expira.
• When-Window-Activated – Inicia uma ação quando uma janela é ativada.
• When-Window-Closed – Inicia uma ação quando uma janela é fechada.
• When-Window-Deactivated – Inicia uma ação quando uma janela é desativada em função de

outra janela ter se tornado ativa.
• When-Window-Resized – Inicia uma ação quando uma janela muda de tamanho.
Observe que os gatilhos associados e este grupo começam com When e, portanto, adicionam ações ao
procedimento padrão. Devido ao grande número de opções faremos apenas alguns testes.
Neste grupo ainda se encontram alguns gatilhos acionados exclusivamente pelo teclado. O quadro a
seguir apresenta a lista de gatilhos disponíveis, a ação padrão associada e a tecla necessária para o
acionamento da ação no Windows.
Gatilho(Trigger) Ação Tecla no Windows

Key-CLRBLK Limpar Bloco (Clear Block) SHIFT+F5
Key-CLRFRM Limpar Form (Clear Form) SHIFT+F7
Key-CLRREC Limpar Registro (Clear Record) SHIFT+F4
Key-COMMIT Salvar (Save) ou Aceitar (Accept) F10
Key-CQUERY Contar Registros Coincidentes (Count Query Hits) SHIFT+F2
Key-CREREC Incluir Registro (Insert Record) F6
Key-DELREC Remover Registro (Delete Record) SHIFT+F6
Key-DOWN Navegar para Baixo (Down) Seta para Baixo ou CTRL+I
Key-DUP-ITEM Duplicar Item (Duplicate Item) F3
Key-DUPREC Duplicar Registro (Duplicate Record) F4
Key-EDIT Editar (Edit) CTRL+e
Key-ENTQRY Entrar Consulta (Enter Query) F7
Key-EXEQRY Executar Consulta (Execute Query) F8
Key-EXIT Sair (Exit) CTRL+q
Key-HELP Ajuda (Help) F1
Key-LISTVAL Lov (List of Values) F9
Key-MENU Menu de Blocos (Block Menu) F5
Key-NXTBLK Próximo Bloco (Next Block) CTRL+Page Down
Key-NXT-ITEM Próximo Item (Next Item) Tab ou CTRL+Tab

Gatilho(Trigger) Ação Tecla no Windows

Key-NXTKEY Próxima PK (Next Primary Key) SHIFT+F3
Key-NXTREC Próximo Registro (Next Record) SHIFT+Seta para Baixo
Key-NXTSET Próximo Conjunto de Registros (Next Set of CTRL+>
Records)
Key-PRINT Imprimir (Print) SHIFT+F8
Key-PRVBLK Bloco Anterior (Previous Block) CTRL+Page Up
Key-PRV-ITEM Item Anterior (Previous Item) SHIFT+Tab ou
SHIFT+CTRL+Tab
Key-PRVREC Registro Anterior (Previous Record) SHIFT+Seta para Cima
Key-SCRDOWN Rolar a tela para baixo (Scroll Down) Page Down
Key-SCRUP Rolar a tela para cima (Scroll Up) Page Up
Key-UP Navegar para cima (Up) Seta para Cima ou CTRL+p
Tabela 5 – Triggers Key x Ação x Teclas
Os gatilhos deste grupo começam com Key, portanto já possuem uma funcionalidade padrão implícita.
Quando incluímos um trigger deste conjunto em nossa aplicação a ação padrão associada deixa de ser
executada.
Por este motivo, o Form Builder possui um conjunto de rotinas que executam as ações padrões, tanto de
teclado como também transacionais (veremos num dos próximos tópicos).
Em versões anteriores do Form o usuário contava apenas com o teclado para efetuar as ações que
desejasse. Com a introdução do mouse nas aplicações, o usuário conta agora com duas formas de efetuar
as ações: por teclado ou por botões (ou menus).
A diferença entre estas duas formas é que na segunda é necessário que o programador inclua um botão
na tela para realizar uma determina ação ou que inclua um item em um menu para executar o
procedimento desejado (considerando-se que retiraremos o menu e a barra de ferramentas padrão da
aplicação).
Desta forma as lógicas incluídas são validadas e verificadas. Não podemos nos esquecer, porém, que as
mesmas ações (Consultar, Salvar, Navegar, etc) podem ser feitas exclusivamente com o teclado, sem que
haja necessidade de nenhuma programação adicional.
Estes gatilhos permitirão que sejam desabilitadas (por exemplo) todas as teclas em que um botão ou item
de menu possua uma programação mais complexa e não desejemos que o usuário pule esta programação
ao acionar uma tecla de função. Poderemos incluir a mesma programação na tecla para que o usuário
tenha opções de executar a mesma ação de formas diferentes.
Nota
O importante é que durante a programação não venhamos a esquecer que isto pode acontecer e sejamos
surpreendidos por uma ação do usuário não prevista na programação.
Key-Others
O Form possui uma trigger neste grupo muito especial, criada para nos dar mais segurança na
programação. Ela se chama Key-Others. Quando incluímos esta trigger em nossa aplicação, toda e
qualquer ação de teclado fica desabilitada por default. Apenas serão válidas aquelas ações que forem
incluídas explicitamente na programação, ou seja, apenas aqueles gatilhos do tipo Key que tivermos
definido no Form.
Esta forma de trabalhar garante que não seremos surpreendidos pelo usuário na implantação do sistema.
Principalmente para aqueles programadores que estão começando a usar esta ferramenta, o uso do Key-
Others é mais seguro e mais documentável (pois torna os gatilhos usados visíveis na aplicação).

Quando, a tempo de execução listamos o conjunto de teclas (menu Ajuda-Help, opção Teclas-Keys)
percebemos que aparecem na lista ações que não foram mencionadas acima.
Isto ocorre porque nem todas as ações do teclado são passíveis de controle ou da criação de gatilhos
associados.
Ações normalmente executadas pelo gerenciador do ambiente (e não pelo Form), dentre outras não são
passíveis de intervenção.
Estas ações estão listadas a seguir:
Ação Tecla no Windows

Limpar Item(Clear Item) CTRL+u
Primeiro Caracter(First Character) Home
Copiar (Copy) CTRL+C
Recortar (Cut) CTRL+X
Remover Caracter (Delete Character) Delete (caracter à frente) ou Backspace (caracter atrás)
Esquerda (Left) Seta para Esquerda
Selecionar (Select) SHIFT
Colar (Paste) CTRL+V
Mostrar Teclas(Show Keys) CTRL+F1
Mostrar Erro(Display Error) SHIFT+F1
Modo Incluir/Alterar (Toggle Insert/Replace) Insert
Fim de Linha(End of Line) End
Direita (Right) Seta para Direita
Enviar/Transmitir (Transmit) Enter
Tabela 6 – Ações de Teclado supridas pelo Gerenciador do Ambiente (Windows)
GATILHOS ASSOCIADOS A UMA CONSULTA

Os eventos classificados neste grupo estão associados ao momento da consulta ao banco de dados, ou
seja, quando o Form monta a query que efetivamente será enviada para o banco de dados e quando ele
faz a leitura de cada uma das linhas selecionadas. Nestes dois momentos poderemos incluir ações em
adição àquelas já estabelecidas por ele.
• Pre-Query – Este gatilho é acionado imediatamente antes do Form preparar o comando Select
a ser enviado para o banco de dados. Isto permitirá que façamos uma intervenção neste
processo e modifiquemos por programação as condições da consulta a ser realizada.
• Post-Query – Este gatilho é acionado a cada linha lida do banco de dados. Isto permitirá que
façamos modificações no registro lido, completemos dados, cálculos, leitura de informações,
etc.
Os triggers deste grupo começam com Pre e Post, marcando momentos imediatamente antes ou depois
do evento (ou do When) onde estaremos adicionando funcionalidade. A consulta será executada de
qualquer forma.

GATILHOS ASSOCIADOS À NAVEGAÇÃO

Os eventos classificados neste grupo estão associados à navegação, ou seja, o momento em que o foco
muda de um item para outro.
Esta mudança pode ocorrer entre itens de um mesmo registro, de registros diferentes, de blocos diferentes
e, ainda para fora da aplicação ou na entrada de uma aplicação.
De acordo com o tipo de navegação um conjunto particular de eventos é causado. Quem causa este tipo
de evento pode ser o usuário ao mudar de item ou a programação ao comandar a mudança.
Este grupo de triggers pode ser subdividido em duas subcategorias: Pre / Post e When-New-Instance.
Subcategoria Pre / Post

Estes triggers são acionados quando o Form navega internamente através de diferentes níveis de
hierarquia do objeto.
Os triggers deste grupo iniciam com Pre ou Post, portanto adicionam funcionalidade imediatamente antes
ou depois do evento ou When.
• Pre-Form – Inicia uma ação imediatamente antes do Form navegar para o módulo atual vindo
de outro módulo. Funciona como um Startup (só a primeira vez que o módulo ganha o foco).
• Pre-Block – Inicia uma ação quando o Form navega para o nível de bloco, tendo vindo do
nível de módulo.
• Pre-Record – Inicia uma ação quando o Form navega para o nível de registro, tendo vindo do
nível de bloco.
• Pre-Text-Item – Inicia uma ação quando o Form navega para o nível de item, tendo vindo do
nível de registro.
• Post-Text-Item – Inicia uma ação quando o Form deixa o nível de item e navega para o nível
de registro.
• Post-Record – Inicia uma ação quando o Form deixa o nível de registro e navega para o nível
de bloco.
• Post-Block – Inicia uma ação quando o Form deixa o nível de bloco e navega para o nível de
módulo.
• Post-Form – Inicia uma ação antes do Form navegar para fora do módulo.
Quando o Form navega de um objeto para o outro ele retorna ao nível superior. Por exemplo, quando ele
navega entre itens ele retorna ao nível de registro e seleciona o próximo item na seqüência de navegação.
Isto faz com que os gatilhos de Post-Text-Item (associados ao item anterior) e Pre-Text-Item associados
ao item atual sejam executados (mas não os gatilhos associados a registro – Post-Record e Pre-Record).
Estes gatilhos são acionados em diferentes situações de acordo com a navegação realizada. Por exemplo
entre dois itens de um mesmo registro ou entre dois itens em registros diferentes ou entre dois itens em
blocos diferentes ou quando iniciamos ou encerramos a aplicação.
Nestes triggers, no entanto, não podemos incluir rotinas que causem um desvio no processo de
navegação padrão (por exemplo, go_item).
Isto ocorre porque o Form é responsável por efetuar a navegação entre os objetos e enquanto esta
navegação estiver em andamento, não podemos interferir no processo, isto é, não podemos desviar o
caminho a ser seguido pelo Form.

Em vista disso e havendo necessidade de desvio o Form Builder possui um conjunto de triggers criados
especificamente para que possamos realizar desvios durante o processo de navegação.
Subcategoria When-New-Instance
Estes gatilhos podem receber comandos que desviem a ação normal de navegação. São executados após
o processo de navegação ter sido concluído e imediatamente antes do controle retornar ao usuário.
• When-New-Form-Instance – Inicia uma ação na inicialização do módulo.
• When-New-Block-Instance – Inicia uma ação após o foco ser movido de um item em um

bloco para outro item em outro bloco.
• When-New-Record-Instance – Inicia uma ação após o foco se mover para um novo registro.
Se o novo registro estiver também em um novo bloco, este gatilho é acionado após When-
New-Block-Instance, mas antes do When-New-Item-Instance.
• When-New-Item-Instance – Inicia uma ação imediatamente após o foco se mover para um

item diferente. Se o item estiver em um novo registro, este gatilho é disparado após When-
New-Record-Instance.
GATILHOS ASSOCIADOS AO RELACIONAMENTO ENTRE BLOCOS (MASTER-DETAIL)

Este grupo de eventos encontra-se ligado às ações padrões realizadas pelo Form quando ele faz o
controle de leitura e atualização de blocos relacionados. Podemos interferir neste controle e modificar as
ações padrões realizadas pelo Forms.
As triggers deste grupo serão vistas no próximo capítulo quando estudaremos o relacionamento entre
blocos.

GATILHOS ASSOCIADOS AO CONTROLE DE MENSAGENS

Este grupo de eventos está associado à recepção e apresentação de mensagens por parte do Forms.
Podemos interceptar e modificar as mensagens recebidas por ele ao criarmos gatilhos(triggers) para os
eventos deste grupo.
• On-Error – Este evento é acionado quando o Form recebe um erro. Podemos incluí-lo na
aplicação se desejarmos substituir a mensagem de erro padrão do Form por uma mensagem
de erro customizada.
• On-Message - Este evento é acionado quando o Form recebe um aviso. Podemos incluí-lo na
aplicação se desejarmos substituir a mensagem de aviso padrão do Form por uma mensagem
de erro customizada.
Observe que os gatilhos deste grupo começam com On. Sendo assim possuem uma funcionalidade
implícita que podemos substituir.
Se desejarmos incluir um destes triggers em nossa aplicação deveremos capturar a mensagem que seria
apresentada para que possamos modificá-la. Desta forma o Form Builder disponibiliza um conjunto de
rotinas com esta finalidade:
• Error_Code - Obtém o código (numérico) do erro em um gatilho On-Error.
• Error_Text - Obtém o texto da mensagem de erro em um gatilho On-Error.
• Error_Type - Obtém o tipo do erro: FRM, PLS, etc em um gatilho On-Error.
• Message_Code - Obtém o código (numérico) do erro em um gatilho On- Message.
• Message_Text - Obtém o texto da mensagem de erro em um gatilho On- Message.
• Message_Type - Obtém o tipo do erro: FRM, PLS, etc em um gatilho On- Message.
• Dbms_Error_Code - Obtém o código (numérico) do erro enviado pelo banco de dados para o
Forms.
• Dbms_Error_Text - Obtém o texto da mensagem de erro enviado pelo banco de dados para o
Forms.
No exemplo da listagem 3, o trigger On-Error criado apresenta tanto a mensagem do Forms quanto a
mensagem que o Forms recebeu do banco de dados (quando isto ocorrer).
DECLARE
COD NUMBER := ERROR_CODE;
TEXTO VARCHAR2(2000) := ERROR_TEXT;
TIPO VARCHAR2(10) := ERROR_TYPE;
DBCOD NUMBER := DBMS_ERROR_CODE;
DBTEXTO VARCHAR2(2000) := DBMS_ERROR_TEXT;
BEGIN
MESSAGE(COD || '*' || TIPO || '*' || TEXTO);
MESSAGE(DBCOD || '#' || DBTEXTO);
END;
Listagem 3
As rotinas utilizadas neste gatilho obtém as mensagens de erro padrão do Form (error-xxx) e do banco de
dados (dbms-xxx).
A mensagem fornecida pelo Form é diferente daquela enviada pelo banco de dados.
Quando desejamos obter exatamente qual o erro de informado pelo banco devemos utilizar as funções
Dbms-Error-Code e Dbms-Error-Text.

GATILHOS ASSOCIADOS À INTERFACE COM O BANCO DE DADOS

Este grupo de eventos encontra-se ligado ao momento em que o Form realiza a comunicação com o
banco de dados seja para efetivação da transação, leitura de dados (Select), início e fim de conexão ou
bloqueio (lock).
Deste grupo os gatilhos mais importantes são aqueles ligados à efetivação da transação. São a estes que
daremos especial atenção.
O momento de efetivação da transação é aquele em que o Form percebe que existem modificações feitas
nos buffers dos blocos de dados e é chegado o momento de refleti-las no banco de dados. Podemos
simplesmente adicionar funcionalidade a este momento ou até mesmo interferir neste processo e alterar a
ação a ser feita para o banco de dados.
Os gatilhos deste grupo são acionados em função do Form ter entrado na fase transacional na aplicação,
ou seja alguma situação ocorreu que fez com que o Form tivesse necessidade de efetivar as modificações
realizadas nos registros para o banco de dados.
A fase transacional é ativada em uma das seguintes circunstâncias:
• Foi acionada, explicitamente, a salva. Esta ação pode ser iniciada por teclado ou por botão ou
por menu ou por programação (em um botão por exemplo).
• Foi acionada a limpeza de um bloco com registros pendentes de atualização. Quando isto
ocorre é apresentada uma tela de mensagem indicando que o usuário deve escolher entre
salvar as pendências ou ignorá-las. Se for escolhido salvar, o processo transacional é
acionado. Esta ação (de limpeza) pode ser disparada por teclado, menu, botão ou por
programação.
• Foi acionada a limpeza do Form e haviam registros pendentes de atualização em algum dos
blocos desta aplicação. Quando isto ocorre é apresentada uma tela de mensagem indicando
que o usuário deve escolher entre salvar as pendências ou ignorá-las. Se for escolhido salvar,
o processo transacional é acionado. Esta ação (de limpeza) pode ser disparada por teclado,
menu, botão ou por programação.
• Foi feita uma tentativa de encerramento aplicação sem salvar e haviam registros pendentes.
Quando isto ocorre é apresentada uma tela de mensagem indicando que o usuário deve
escolher entre salvar as pendências ou ignorá-las. Se for escolhido salvar, o processo
transacional é acionado. Esta ação (de limpeza) pode ser disparada por teclado, menu, botão
ou por programação.
• Foi feita uma tentativa de Consulta (Entrar Consulta ou Executar Consulta) e o bloco continha
registros pendentes de atualização. Quando isto ocorre é apresentada uma tela de mensagem
indicando que o usuário deve escolher entre salvar as pendências ou ignorá-las. Se for
escolhido salvar, o processo transacional é acionado. Esta ação (de limpeza) pode ser
disparada por teclado, menu, botão ou por programação.
A programação acionou uma rotina Post ou Commit_Form.
Quando o processo transacional é disparado o Form pesquisa em cada um dos blocos em que
existam registros pendentes e inicia a montagem dos comandos Insert, Update e Delete e os
executa.

Podemos interferir nesta montagem com os gatilhos deste grupo.
• On-Delete – substitui a funcionalidade padrão de remoção de registros. É acionado uma vez

para cada registro a ser removido do banco de dados.
• On-Insert – substitui a funcionalidade padrão de inclusão de registros. É acionado uma vez

para cada registro a ser incluído no banco de dados.
• On-Update – substitui a funcionalidade padrão de alteração de registros. É acionado uma vez

para cada registro a ser incluído no banco de dados.
• Post-Database-Commit – adiciona uma ação ao processamento padrão após a ação de

Commit para o banco de dados. É executado uma única vez ao término do processo
transacional.
• Post-Delete – é acionado após uma determinada linha ter sido removida do banco de dados.
Adiciona ações ao processamento padrão após o evento. É executado uma vez para cada
linha a ser removida.
• Post-Forms-Commit – é acionado antes da ação de Commit para o banco de dados e após a

ação de Post (onde todos os comandos Insert, Update e Delete são executados). É executado
uma única vez após toda a transação ter sido enviada para o banco de dados.
• Post-Insert - é acionado após uma determinada linha ter sido incluída no banco de dados.
linha a ser incluída.
• Post-Update - é acionado após uma determinada linha ter sido alterada no banco de dados.
linha a ser alterada.
• Pre-Commit – é acionado antes do Form iniciar o processo de Post. É executado uma única
vez no início de todo o processo.
• Pre-Delete - é acionado antes uma determinada linha ser removida do banco de dados.
Adiciona ações ao processamento padrão antes do evento. É executado uma vez para cada
linha a ser removida.
• Pre-Insert – é acionado antes de uma determinada linha ser incluída no banco de dados.
linha a ser incluída.
• Pre-Update – é acionado antes de uma determinada linha ser alterada no banco de dados.
linha a ser alterada.

As ações são executadas na seguinte ordem:
1) Pre-commit uma única vez.
2) Pre-delete, On-Delete e Post-delete para cada linha a ser removida, independente da ordem
em que esta ação foi feita ou da ordem dos registros no buffer.
3) Pre-update, On-Update e Post-update para cada linha a ser alterada, independente da

ordem em que esta ação foi feita ou da ordem dos registros no buffer.
4) Pre-insert, On-Insert e Post-insert para cada linha a ser incluída, independente da ordem em
que esta ação foi feita ou da ordem dos registros no buffer.
5) Post-forms-commit uma única vez.
6) Commit.
7) Post-database-commit.
Nota
Como restrição temos que não podemos navegar durante o período transacional. O desvio é inválido da
mesma forma que nos gatilhos de navegação.
Durante o processo transacional o Form percorre os blocos e registros de acordo com seu próprio
algoritmo, que não pode ser modificado pela programação.

Propriedades dos Gatilhos (Triggers)

Vamos verificar outras características os gatilhos possuem dentro de seu conjunto de propriedades.
O grupo funcional conta com as seguintes propriedades:
• Estilo do Gatilho (Trigger Style) – esta propriedade não deve ser alterada. Todo texto a ser
escrito deve ser feito em PL/SQL. O estilo V2 foi mantido para compatibilidade com versões
anteriores.
• Texto do Gatilho (Trigger Text) – esta propriedade contém o texto de PL/SQL que tivermos
escrito.
• Hierarquia de Execução (Execution Hierarchy) – indica se o gatilho atual deve substituir, ser
acionado antes ou ser acionado depois de um outro gatilho associado ao mesmo evento,
porém de mais alto nível. Por exemplo, suponhamos a criação de um gatilho Key-Down no
item cd_mat e um gatilho Key-Down no bloco Func. A propriedade de hierarquia do gatilho
Key-Down do item cd_mat poderia ser alterada para que sua execução ocorresse antes do
outro gatilho. O padrão do Form, neste caso, é a substituição.
• Disparar no Modo Entrar Consulta (Fire in Enter-Query Mode) – esta propriedade

determina que o gatilho seja disparado tanto no modo de digitação normal, quanto durante o
período de Entrar Consulta. Esta ação não é válida para todos os tipos de gatilhos.
No grupo Ajuda existem também 2 propriedades:
• Exibição na ‘Ajuda do Teclado’ (Display in ‘Keyboard Help’) - Est propriedade determina

se a descrição do gatilho (somente para gatilhos do tipo Key-*) será mostrada na janela de
ajuda (Teclas – Keys). Maiores detalhes no capítulo 13.
• Texto da ‘Ajuda do Teclado’ (‘Keyboard Help’ Text) - Texto a ser apresentado na tela de
ajuda (Teclas – Keys) a tempo de execução.
Falha nos Gatilhos

Em determinadas situações precisamos abortar um gatilho, isto é, impedir que o usuário prossiga as ações
desejadas sem que determinada ocorrência tenha sucedido.
Em função disso o Form Builder possui uma condição de erro (exception) com o nome
Form_Trigger_Failure.
Quando causamos (Raise Form_Trigger_Failure) esta condição de erro o restante do gatilho não é
executado e, ainda, a ação que causou seu disparo é interrompida.
Por exemplo, se causarmos esta condição de erro durante um processo de navegação (em qualquer dos
triggers de navegação ou nos triggers de validação, pois são executados durante o processo de
navegação) a navegação é interrompida. Isto faz com que o usuário fique preso ao item original. Não
consegue navegar.
Da mesma forma se causarmos esta condição de erro durante o processo transacional este é
interrompido.

Edição de PL/SQL
Uma vez que começamos a tratar da parte de programação, neste tópico analisaremos o editor de
PL/SQL.
INDENTAÇÃO AUTOMÁTICA
A cada linha digitada o posicionamento do cursor na linha subseqüente acompanha a indentação da linha
que lhe é superior. Digite o seguinte trecho de programa e avalie o resultado da digitação.
IF VARIAVEL > 'ABC' THEN

VARIAVEL := 'CDE'; -- COMENTÁRIO
VARIAVEL := 'ABC' || 'CDE';
VARIAVEL := TO_CHAR(SYSDATE, 'DD/MM/YYYY');
VARIAVEL := 5;
VARIAVEL := VARIAVEL + 1;
END IF;
Listagem 4
INDENTAÇÃO MANUAL
Para indentação manual contamos com as opções Endentar e Endentar Invertido do menu Editar (se
usarmos o mouse) e com as teclas Tab e Shift + Tab, respectivamente, se usarmos o teclado.
CORES
Ocorre variação no colorido das informações. As palavras chaves, comentários, constantes strings e
numéricas, os símbolos de atribuição ( := ) e de concatenação ( || ) são destacados com cores diferentes
que os identificam facilitando a localização das informações.
SELEÇÃO
Podemos selecionar tanto linhas de texto quanto colunas.
Para selecionar uma linha, posicione o mouse no canto esquerdo da linha (sobre a faixa existente na
lateral esquerda) até que o formato do ícone seja a seta e clique no botão esquerdo.
Para selecionar uma coluna pressione a tecla ALT e com o mouse selecione (“pinte”) as coluna(s)
desejada(s).
CÓPIA E MOVIMENTAÇÃO DE TEXTOS

Podemos tanto movimentar textos selecionados (ou “pintados”) quanto copia-los para outra parte do
código.
Para realizar estas ações basta que façamos a seleção do trecho de código desejado (linha) e em seguida
soltemos o mouse. Quando aproximarmos o mouse novamente sobre a área selecionada o desenho do
cursor mudará para seta (em vez do i ).
Neste momento se desejarmos efetuar uma movimentação, simplesmente arrastamos o mouse (sem soltar
o botão) para o ponto desejado e, em seguida, soltamos o botão do mouse.
Notaremos que o cursor mudará de posição indicando a localização onde o trecho será incluído. Durante a
movimentação o desenho do ícone do mouse ganhará um retângulo sob a seta.
Se desejarmos copiar o trecho em vez de apenas movimenta-lo, devemos pressionar a tecla Ctrl e efetuar
as mesmas ações descritas anteriormente.
Neste caso o desenho do ícone do mouse além do retângulo apresentará também um quadrado
preenchido com o sinal +, ambos sob a seta.

SPLIT DA ÁREA DE EDIÇÃO

A área de edição pode ser subdividida em até 4 painéis.
Na lateral direita, acima da seta da barra de rolagem vertical a existe uma pequena barra de split. Ao
clicarmos sobre ela e arrastarmos o mouse para baixo (sem soltar o botão), dividiremos a tela.
No canto inferior esquerdo, ao lado da seta da barra de rolagem horizontal encontramos a mesma barra de
split. Se repetirmos a operação de divisão obteremos o resultado da figura 43.
Para desfazer este efeito basta um

clique duplo sobre a linha
separadora dos quadros, destacadas
na figura 43.
Fig. 43 - Editor de PL/SQL
IMPRESSÃO, EXPORTAÇÃO E IMPORTAÇÃO

Podemos imprimir a unidade de programa corrente através do menu Arquivo, opção Print.
Outra ação válida é a de Importar Texto ou Exportar Texto também presente no menu Arquivo.
OPÇÃO DESFAZER
A opção desfazer (Undo) pode ser repetida muitas vezes (e não apenas uma). O Form Builder guarda
todas as modificações realizadas no código desde a última operação de Salvar.
Esta ação está disponível no menu Editar.
Paleta de Sintaxe
Para edição de trechos de PL/SQL ou para obtenção da chamada
de uma rotina pré-definida contamos, agora, com a ajuda de uma
paleta de sintaxe.
Devemos mater o editor de PL/SQL aberto e escolher a opção

Paleta de Sintaxe do menu Programa (apresentado na figura 44).
Esta paleta possui duas pastas, uma relativa a sintaxe de PL/SQL e

a outra relativa às rotinas pré-definidas.
No exemplo da figura 44, selecionamos o conjunto de instruções

relativas a Controlar Fluxo (veja a janela superior). Dentro da lista
apresentada escolhemos a instrução IF ELSIF ELSE.
Quando pressionarmos o botão Inserir, o trecho de código mostrado

na janela inferior é copiado para a posição do cursor no editor de
PL/SQL aberto.
Fig. 44 - Paleta de Sintaxe

CAPÍTULO 7: RELACIONAMENTO MASTER-DETAIL

Um relacionamento Master-Detail nada mais é do que um relacionamento entre dois blocos de uma
mesma aplicação.
O objeto Relação (Relation)

A coordenação das ações realizadas entre os blocos é feita com a ajuda de um objeto chamado Relação
(Relation). Este objeto tem a finalidade de controlar os processos de leitura e atualização entre os dois
blocos.
Quando usamos o Assistente de Bloco de Dados para estabelecer o relacionamento, o diálogo da figura
45 deve ser preenchido para estabelecermos as colunas necessárias à relação.
Fig. 45 - Relacionamento
Master-Detail
Durante a construção do bloco detalhe (no exemplo bloco Func), preencheremos o diálogo do Assistente
conforme apresentado na figura 45. Observe que o bloco mestre (no exemplo Depto) já está criado
previamente.
Será criado, subordinado ao bloco mestre (no Navegador), no nó Relação, um objeto que será responsável
pela coordenação da leitura entre os dois blocos e pela coordenação da atualização.
Abra as propriedades deste objeto para que possamos entender as regras da relação.
CAPÍTULO 7: RELACIONAMENTO MASTER-DETAIL - 77

Propriedades da Relação
Estudemos, a seguir, as propriedades (ou regras) do relacionamento entre estes dois blocos.
Grupo Funcional
• Bloco de Dados Detalhado (Detail Data Block) - determina qual o nome do bloco de dados
detalhe (uma vez que este objeto está pendurado no mestre).
• Condição de Junção (Join Condition) - qual a ligação entre estes blocos, ou seja, qual a
coluna ou colunas PK no bloco mestre e quais as colunas (ou coluna) FK no bloco detalhe
correspondentes.
• Excluir Comportamento do Registro (Delete Record Behavior) – esta propriedade indica

qual a ação que o Form deve tomar se o usuário tentar remover registros no bloco que é o
mestre da relação. Existem três possibilidades diferentes:
- Não-Isolado – indica que se houverem registros no detalhe, a remoção no bloco mestre

deve ser invalidada. Esta é a opção default.
- Isolado – indica que o Form deve enviar para o banco de dados apenas o comando de
Delete dos registros do bloco mestre mesmo que haja registro no detalhe. Esta ação é útil
quando o relacionamento entre as tabelas a nível de banco de dados é do tipo Cascade
Delete. Isto significa que quando solicitamos ao banco de dados uma remoção em alguma
linha da tabela mestre ele, automaticamente, remove todas as linhas correspondentes na
tabela detalhe. Neste caso não temos necessidade de repetir esta ação no Form, pois o
banco de dados se encarrega de fazê-la.
- Em Cascata – esta é a situação inversa da opção anterior. Como no banco de dados o

relacionamento entre as tabela não é do tipo Cascade, temos necessidade de prover esta
situação no Form. Desta forma quando escolhemos esta opção o Form programa um
comando Delete para todas as linhas detalhe que correspondam ao mestre que
desejamos remover. Esta ação é incluída em uma trigger de Pre-Delete no bloco mestre.
• Impedir Operações sem Mestre (Prevent Masterless Operation) – esta propriedade indica
quando o operador estará apto a consultar ou inserir registros no bloco detalhe. Esta
propriedade pode ser preenchida com:
- Sim – indicando que não são permitidas inclusões no bloco detalhe se não houver um
registro associado no bloco mestre e, ainda, não são permitidas consultas no bloco
detalhe se não houver um registro lido e associado no bloco mestre.
- Não – pode-se consultar ou incluir registros no detalhe sem restrições. Esta é a opção
default.

Grupo Coordenação
As propriedades deste grupo se referem à forma de leitura das informações.
• Diferido (Deferred) – Indica se a consulta no bloco detalhe deve ou não ser adiada após a
identificação do registro no bloco mestre.
Quando esta propriedade recebe o valor Não, tão logo seja feita uma consulta ou navegação para
o próximo registro no bloco principal, ocorrerá a consulta no bloco detalhe. Neste caso a
propriedade Consulta Automática (Automatic Query) é ignorada.
Quando indicamos que desejamos o adiamento (Sim) a propriedade Consulta Automática

(Automatic Query) indicará como será feita a consulta no detalhe.
• Consulta Automática (Automatic Query) – Para que esta propriedade tenha efeito, a
propriedade Diferido (Deferred) deve estar preenchida com Sim.
Se esta propriedade for preenchida com Sim, estamos indicando que a consulta será feita
automaticamente, porém somente quando o usuário navegar para o bloco detalhe. Enquanto ele
permanecer no bloco principal não será feita nenhuma pesquisa no detalhe.
Se esta propriedade for preenchida com Não, o usuário além de navegar para o bloco detalhe,
deverá, explicitamente, acionar uma consulta (Entrar Consulta e/ou Executar Consulta).

Os Gatilhos (Triggers) de uma Relação

Alguns triggers foram criados em nossa aplicação, automaticamente pelo Form Builder.
Os triggers são criados em função da propriedade Excluir Comportamento do Registro (Delete Record
Behavior).
O conteúdo dos triggers é definido em função do grupo Coordenação (Coordination).
O quadro a seguir mostra esta ligação.
Excluir Comportamento do Registro Gatilhos (Triggers)

(Delete Record Behavior)
Não-Isolado On-Check-Delete-Master,
On-Clear-Details,
On-Populate-Details
Isolado On-Clear-Details,
On-Populate-Details
Cascata On-Clear-Details,
On-Populate-Details,
Pre-Delete
Tabela 7 - Gatilhos de uma Relação
Alguns dos gatilhos mostrados acima não foram vistos no tópico anterior e serão estudados agora.
GATILHOS ASSOCIADOS AO RELACIONAMENTO ENTRE BLOCOS (MASTER-DETAIL)

Este grupo de eventos encontra-se ligado às ações padrões realizadas pelo Form quando ele faz o
controle de leitura e atualização de blocos relacionados. Podemos interferir neste controle e modificar as
ações padrões realizadas pelo Forms.
São eles:
• On-Check-Delete-Master – Este gatilho é acionado quando o Form tenta remover um registro

em um bloco que é o bloco mestre em um relacionamento mestre-detalhe.
• On-Clear-Details – Este gatilho é acionado quando o Form precisa limpar os registros de um

bloco detalhe em função destes registros não mais corresponderem ao registro corrente no
bloco mestre.
• On-Populate-Details – Este gatilho é acionado quando o Form precisa obter registros para o
bloco detalhe em função da coordenação de leitura entre os blocos mestre-detalhe.
De um modo geral não precisamos intervir nos triggers gerados em função da presença da relação.
Se desejarmos incluir alguma funcionalidade específica podemos adicionar código aos gatilhos criados.
Devemos tomar cuidado, no entanto, se viermos a modificar alguma característica da relação, pois os
gatilhos podem ser modificados independentemente de os termos alterado ou não, podendo ocasionar a
perda de código na aplicação.

CAPÍTULO 8: VARIÁVEIS E ROTINAS

Uma aplicação Form possui diversos pontos em que podemos escrever códigos de PL/SQL (os triggers).
Sabemos que a PL/SQL é uma linguagem estruturada em blocos. Sabemos, ainda, que com a PL/SQL
podemos criar blocos de código com nome, isto é, procedimentos, funções e pacotes.
Sendo assim, uma aplicação Form não poderia deixar de possuir formas de estruturação de código. Locais
em que pudéssemos escrever códigos de PL/SQL que pudessem ser utilizados em diversos pontos da
aplicação. Este é o assunto do tópico Rotinas.
O assunto do tópico Variáveis vai tratar de todos os tipos de variáveis que podemos usar em uma
aplicação: variáveis definidas dentro de um trigger, variáveis de sistema, itens de trabalho (fora da
canvas), variáveis de pacotes, variáveis globais e parâmetros.
CAPÍTULO 8: VARIÁVEIS E ROTINAS - 81

Rotinas
Dentro do Form podemos acionar três tipos de rotinas:
• Rotinas armazenadas no banco de dados
• Rotinas armazenadas dentro do programa
• Rotinas armazenadas em bibliotecas (Libraries)
Cada uma destas formas de armazenamento possui uma abrangência e utilidade específica.
A determinação da localização da unidade de programa deve seguir os critérios apresentados a seguir.
ROTINAS LOCAIS
São aquelas armazenadas dentro da própria aplicação. São utilizadas para estruturação do código e não
tem utilização em outros módulos.
Está localizada localmente porque:
• Não precisa ser compartilhadas por outras aplicações.

• Não utiliza estruturas do banco de dados ou utiliza apenas para atualização, não causando
impacto no tráfego da rede.
• Está associada a ações específicas do ambiente cliente (usa built-ins do Form ou do Report).
A criação de uma rotina local segue os critérios de criação dos demais

objetos:
• selecione o nó Unidade de Programa (Program Unit).
• utilize a ferramenta Criar (Create).
O diálogo da figura 46 será apresentado para que possamos determinar

o nome e tipo da unidade de programa.
Fig. 46 - Nova Unidade
de Programa
Avaliemos quais as opções de unidades de programa e sua melhor utilização:
• Procedimentos (Procedures) - Podem receber parâmetros e retornar valores para a rotina

chamadora através de parâmetros de saída (out). Deve ser o tipo escolhido se mais de uma
informação de retorno for necessária. Quando temos necessidade de retornar ao programa
chamador mais de uma informação é mais comum o uso de um procedimento do que de uma
função, porém não há impedimento de uso.
• Funções (Functions) - Podem receber parâmetros. Sempre retornam um valor através da

própria chamada da função. Também podem retornar valores através de parâmetros de saída
(out), mas é pouco comum esta forma de uso. Deve ser o tipo escolhido se apenas uma
informação de retorno for necessária.
• Pacotes (Packages) - Nos pacotes podemos criar procedures, functions e ainda variáveis e
cursores globais (declarados na especificação) ou de uso apenas no pacote (declarado no
corpo). Pacotes favorecem a organização, utilize-os sempre. Use e abuse de sua
funcionalidade para grupar rotinas afins.
Quando aceitarmos este diálogo, o editor de PL/SQL será acionado para que possamos escrever o código
desejado.

ROTINAS ARMAZENADAS NO BANCO DE DADOS

Quando decidimos pelo cadastramento de uma determinada rotina no banco de dados, nossa principal
motivação é compartilhamento.
Aquele código pode ser aproveitado (reutilizado) por diversas aplicações estejam elas no ambiente cliente
(módulos de tela ou relatório) ou no ambiente servidor (outras rotinas armazenadas no banco de dados).
Porém o compartilhamento também é possível com bibliotecas (Libraries). Armazenadas fora do banco de
dados (no ambiente de rede).
Escolheríamos armazenar uma rotina no banco de dados porque:
• a rotina executa ações de leitura e atualização no banco de dados (local ou remoto), de tal
forma que sua performance seja melhorada em função da diminuição do tráfego na rede.
• a rotina não está associada a ações específicas do ambiente cliente (tela, navegação, etc).
• a rotina será utilizada por aplicativos em batch (PL/SQL, PRO*C, etc) apesar de não fazer
acesso a estruturas do banco de dados. Neste caso específico deve-se analisar o impacto de
se duplicar esta rotina. Uma para utilização por aplicativos online (no ambiente de cliente) e
outra para os aplicativos em batch (no ambiente servidor).
A criação ou manutenção de uma stored procedure pode ser feita com o próprio Form Builder, da seguinte
forma:
• ao expandirmos o nó Objetos do Banco de Dados

(Database Objects) veremos a lista de usuários criados
no banco.
• ao expandirmos o nó correspondente ao usuário de
trabalho serão apresentados 4 nós principais:
Unidades de Programas Armazenados (Stored
Program Units), Tabelas (Tables), Bibliotecas de
PL/SQL (PL/SQL Libraries) e Views.
• ao expandirmos o nó Tabelas você veremos a lista de
tabelas do usuário de trabalho.
• ao escolhermos uma tabela qualquer e expandirmos
novamente o nó, encontrarremos dois nós:
Triggers(Database Trigger) e Colunas (Columns).
Fig. 47 - Objetos do
Banco de Dados
Se desejarmos dar manutenção a uma rotina gravada no banco de dados ou quisermos incluir uma nova
rotina, devemos selecionar o nó Unidades de Programa Armazenadas (Stored Program Units) e expandi-lo
para encontrar a rotina desejada ou pressionar o botão Criar (Create) para que seja apresentado
novamente o diálogo da figura 44.
Para que possamos visualizar o editor de PL/SQL, abriremos uma rotina qualquer cadastrada no banoc de
dados.

Observaremos que a janela do editor de PL/SQL é ligeiramente diferente daquelas vistas anteriormente.
Ela mostra quem é o usuário dono da rotina (Owner), o nome e tipo da rotina.
Os botões da parte superior possuem o seguinte significado:
• Novo (New) – Com este botão podemos criar uma nova unidade de programa. O diálogo da
figura 44 será apresentado novamente.
• Salvar (Save) – Este botão dispara a compilação da unidade de programa e armazenamento

no banco de dados. Não se esqueça que o Oracle armazena as rotinas mesmo com erro de
compilação. Caso seja encontrado um erro, haverá a apresentação da indicação do erro em
um painel abaixo do painel de texto.
• Reverter(Revert) – Desfaz as modificações realizadas após o último Salvar (Save) ou

Reverter (Revert). Observe que após o uso do botão Salvar não podemos retornar o código
anterior. O código é armazenado mesmo contendo erros.
• Descontinuar (Drop) – Remove a unidade de programa do banco de dados. Esta opção

pedirá confirmação.
• Fechar (Close) – Fecha o diálogo. Esta opção pede confirmação se forem detectadas
alterações no código. Se você não modificou o código e ainda assim a tela de confirmação for
apresentada, escolha a opção Reverter (revert) deste diálogo apresentado.
• Ajuda (Help) – Aciona uma tela contendo a descrição desta janela.
Fig. 47a – Stored Program Unit

ROTINAS ARMAZENADAS EM BIBLIOTECAS (LIBRARIES)

Quando decidimos pelo cadastramento de uma determinada rotina em bibliotecas da rede, desejamos o
compartilhamento apenas para o ambiente cliente. Aquele código pode ser aproveitado (reutilizado) por
diversas aplicações no ambiente cliente (módulos de tela ou relatório).
Escolheríamos seu armazenamento em um biblioteca porque:
• a rotina poderá ser compartilhada por mais de um módulo.
• a rotina não utiliza estruturas do banco de dados ou utiliza apenas para atualização, não
causando impacto no tráfego da rede.
• a rotina está associada a ações específicas do ambiente cliente (usa built-ins do Form ou do
Report).
A criação de bibliotecas no ambiente será vista em um capítulo à parte, pois, trata-se de um módulo. Não é
um objeto de dentro da aplicação Form.
EMPACOTAMENTO DA LÓGICA
As formas de empacotamento (procedimentos, funções e pacotes) apresentadas acima existem tanto no
ambiente cliente quanto no ambiente servidor.
Com todas estas opções não há justificativa para um código não modular, não estruturado.
• Considere quebrar sua trigger (no Forms) em um pacote (da trigger X) se a visualização do
texto ultrapassar 3 páginas (em torno de 80 linhas).
• Considere criar rotinas (procedures ou functions) para trechos de programas repetitivos.
• Crie uma biblioteca com rotinas que você possa utilizar em diversos sistemas. Podem existir
soluções já criadas em um sistema que facilitem sua programação em outro.
• Considere a utilização de pacotes em seu Forms, grupando rotinas referentes a uma mesma
trigger ou relativas a uma mesma ação.
• Documente sempre.
A lista acima são apenas sugestões. Você, certamente, encontrará a forma mais adequada para o
desenvolvimento das suas aplicações.

Variáveis
Neste tópico trataremos dos diversos tipos de variáveis de uma aplicação Form. Estão subdivididas em
dois grandes grupos: Variáveis do Usuário e Variáveis de Sistema.
Variáveis do Usuário
As variáveis do Usuário podem ser de diversos tipos, com características e abrangências diferentes:
• Variáveis Locais
• Itens fora de Canvas
• Variáveis Globais
• Parâmetros
• Variáveis de Pacotes no Form
Variáveis de Sistema
As variáveis de Sistema não podem ser alteradas pela aplicação, somente consultadas e fornecem
diversas informações sobre a aplicação em desenvolvimento.
VARIÁVEIS LOCAIS
São aquelas declaradas dentro de um gatilho ou rotina. Os valores desta variável são acessíveis apenas
dentro do trecho de PL/SQL em que é declarada.
Ao término do bloco de PL/SQL onde ela é declarada ela deixa de existir. Tem sua vida útil associada ao
procedimento no qual estão declaradas.
MESSAGE('FIM DE PROGRAMA - EXIT');

DECLARE Listagem 5 - criamos um bloco dentro
V1 NUMBER; do gatilho (Key-Exit) e definimos uma
BEGIN variável local, que deixa de existir tão
V1 := 5; logo o bloco interno termine (End).
END;
MESSAGE('AQUI V1 NÃO EXISTE MAIS');
De um modo geral o tipo destas variáveis é similar aos tipos válidos em PL/SQL (number, char, varchar2,
date, <tabela ou cursor>%rowtype, <coluna>%type, tipos do usuário, etc), porém, o Form disponibiliza
alguns tipos especiais: Alert, Block, Canvas, Groupcolumn, Editor, Formmodule, Item, Recordgroup, Lov,
Menuitem, Paramlist, Relation, Timer, Viewport, Window, etc.
Estes tipos são criados para a obtenção do ID do objeto. Quando criamos qualquer objeto (canvas, item,
janela, bloco, etc) com o Form Builder, ele atribui um ID (interno) para este objeto.
Quando fornecemos o nome de um objeto (em uma rotina pré-definida, por exemplo), o Form é obrigado a
fazer uma pesquisa prévia para obter o identificador (ID) e só então fazer acesso ao objeto desejado.
Sendo assim, quando em uma mesma rotina viermos a utilizar diversas vezes o mesmo objeto, pode ser
interessante, obter o ID inicialmente e utilizar apenas o identificador. Para isto o Form Builder disponibiliza
uma série de rotinas Find_<objeto> que recebem como parâmetro o nome do objeto e retornam o
identificador.
Listagem 6 - exemplo
DECLARE
de utilização.
JANELA WINDOW := FIND_WINDOW('WINDOW1');
BEGIN
SET_WINDOW_PROPERTY(JANELA, TITLE, 'Janela da Aplicação');
SET_WINDOW_PROPERTY(JANELA, WINDOW_STATE, MAXIMIZE);
SET_WINDOW_PROPERTY(JANELA, HIDE_ON_EXIT, PROPERTY_TRUE);
END;

ITENS FORA DE CANVAS

Quando definimos um item que não aparece em nenhuma Canvas, estamos, na verdade, criando uma
variável de trabalho. Sua abrangência, porém, é maior que a das variáveis locais pois possuem visibilidade
em todos os pontos da aplicação.
Podem ser utilizadas em qualquer rotina ou gatilho do Form. Seu uso é restrito ao módulo no qual está
declarada porém, podem ser utilizadas por Menus ou Libraries através das rotinas pré definidas Name-In e
Copy.
Podemos determinar tipo, tamanho específico e valor default.
Caso venham a ser usadas como variáveis de trabalho devem ser declaradas em um bloco de controle
criado para este fim.
Caso venham a ser usadas para armazenamento temporário de informações de um determinado bloco,
devem ser declaradas no próprio bloco, por exemplo, o resultado de um cálculo referente a dados do
registro.
Podem ser apagadas pelas rotinas Clear_Block ou Clear_Form.
Quando as criamos em um bloco de controle, invisível pelo usuário, não corremos o risco deste bloco ser
limpo pelo usuário com as opções Bloco – Limpar do menu pois o usuário não tem acesso a este bloco
porque nenhum item está na canvas, então, ele não recebe foco.
A ação de Limpar Tudo, porém, pode ser feita sem que haja necessidade de foco em nenhum objeto.
Neste caso todos os itens definidos em todos os blocos são apagados.
VARIÁVEIS DE PACOTE NO FORM

Quando criamos a parte de especificação de um pacote no Form, todas as variáveis definidas neste local
são chamadas de variáveis de pacote pois são variáveis de PL/SQL com visibilidade em toda a aplicação.
As variáveis de pacote possuem os mesmos tipos de uma variável local, inclusive aqueles associados ao
ID dos objetos.
PACKAGE AREA_TRAB IS
JANELA WINDOW := FIND_WINDOW('WINDOW1');
V1 NUMBER := 0;
MAT FUNC.CD_MAT%TYPE := 0;
END;
Listagem 7
As variáveis definidas na parte de especificação de um pacote tem a mesma abrangência de um item fora
da canvas, com a vantagem de não serem afetadas por Clear_Block nem Clear Form.
SET_WINDOW_PROPERTY(AREA_TRAB.JANELA, TITLE, 'Janela da Aplicação');

SET_WINDOW_PROPERTY(AREA_TRAB.JANELA, WINDOW_STATE, MAXIMIZE);
SET_WINDOW_PROPERTY(AREA_TRAB.JANELA, HIDE_ON_EXIT, PROPERTY_TRUE);
Listagem 8
Na listagem 8 apresentamos a utilização de uma variável de pacote na mesma rotina vista anteriormente
na listagem 7. Para utilizarmos uma variável de pacote em vez da variável local devemos usar o nome do
pacote como qualificador da variável.

PARÂMETROS
Até este momento estudamos variáveis usadas dentro da aplicação como área de trabalho e em
circunstâncias especiais referenciadas em outros módulos.
Trataremos, agora, da passagem de informação entre módulos.
Um parâmetro é uma variável (com tipo, tamanho e valor inicial) definida na aplicação receptora, com a
finalidade de modificar a forma de atuação da aplicação.
Dentro da aplicação onde o parâmetro está definido, deve-se fazer referência a ele como se existisse um
bloco com o nome de Parameter, isto é, :Parameter.<parâmetro>.
DECLARE
LISTA PARAMLIST := CREATE_PARAMETER_LIST('LISTA_DE_PARAMETROS');
BEGIN
ADD_PARAMETER(LISTA, 'PDEPTO', TEXT_PARAMETER, 'A00');
ADD_PARAMETER(LISTA, 'PMAT', TEXT_PARAMETER, '0');
NEW_FORM('RELACAO', TO_SAVEPOINT, NO_QUERY_ONLY, LISTA);
END;
Listagem 9
Na listagem 9, vemos a chamada de uma aplicação que possui parâmetros.
Para que o trecho de programa da listagem 9 fosse válido deveríamos ter criado sob o nó Parâmetros (no
navegador) os dois parâmetros referenciados: Pdepto e Pmat.
Ao selecionarmos, com o botão direito do mouse, as propriedades de um parâmetro verificarmos que

podemos especificar seu tipo (caracter, numérico ou data), tamanho máximo e valor inicial, se desejado.
Na aplicação chamada (Relação) usamos os parâmetros na cláusula Where do bloco Depto (propriedade
Cláusula Where).
WHERE CD_DEPTO > :PARAMETER.PDEPTO

Listagem 10
Foi necessária a qualificação com a palavra chave Parameter.
A utilização de parâmetro é útil quando desejamos somente enviar uma informação. Não precisamos que
haja retorno de resultado.
Como último lembrete no uso de parâmetros, devemos destruir a Parameter List criada no exemplo da
listagem 9 ao término do uso uma vez que a lista não é destruída automaticamente ao término do bloco.
No nosso caso isto não foi necessário porque o programa se encerra naquele ponto pois a rotina
New_Form passa o controle para a aplicação chamada e encerra a atual.
Se a chamada for feita com Call_Form ou Open_Form, é conveniente que a lista seja destruída ao término
da utilização. Use a rotina Destroy_Parameter_List.

VARIÁVEIS GLOBAIS
Uma variável global não é definida explicitamente em uma aplicação Form. Sua criação é feita com a
primeira atribuição ou com o uso da rotina Default_Value.
Variáveis Globais são sempre alfanuméricas com comprimento máximo de 255 caracteres.
Possuem a vantagem de ficar na memória até que sejam explicitamente destruídas, desta forma podem
ser usadas para passagem de informações entre aplicações, tanto de ida quanto de volta.
Possuem como desvantagem não ter tipo opcional, são sempre Char. Isto significa que qualquer atribuição
de um valor não alfanumérico implicará em uma operação de conversão.
Como ela não tem definição de tamanho, da mesma forma não podemos utilizar restrições de tamanho,
seu comprimento está fixado em 255 caracteres.
De um modo geral a utilização de parâmetros é mais interessante que o uso de globais pois eles tem tipo,
tamanho e até valor inicial.
DOWN;
:GLOBAL.V1 := 'ABC';
DEFAULT_VALUE('RIO DE JANEIRO', 'GLOBAL.CIDADE');
IF :GLOBAL.CIDADE = 'RIO DE JANEIRO' THEN
MESSAGE(:GLOBAL.CIDADE || ' - ' || :GLOBAL.V1);
END IF;
Listagem 11
Na listagem 11 criamos uma variável global de duas formas diferentes.
• A atribuição à variável V1 será feita todas as vezes que o gatilho for executado.
• A atribuição à variável Cidade só ocorrerá a primeira vez que o gatilho for executado. Se o
valor da variável global não for Null a rotina Default_Value não tem efeito. Se a variável não
existir, o Form cria a variável e atribui o valor especificado.
A referência, como vimos na listagem 11, é feita sempre com a palavra reservada Global (como se fosse
um bloco).
Para destruirmos uma variável Global, devemos usar a rotina Erase. Isto liberará memória local.
COMPARANDO AS VARIÁVEIS
O quadro a seguir apresenta de forma resumida as características dos tipos de variáveis vistos até agora.
Característica Local Item Pacote Parâmetro Global

Possui um tipo definido (char, date, number, etc). Sim Sim Sim Sim não
Podem ser dimensionados Sim Sim Sim Sim Não
São visíveis em toda a aplicação Não Sim Sim Sim Sim
São visíveis através de múltiplos módulos Não Não Não Não Sim
Transferem informações entre módulos Não Não Não Sim Sim
A operação de Clear_Form afeta o valor da variável Não Sim Não Não Não
Pode ser usada na cláusula Where de um bloco Sim Sim Não Sim Sim
Tabela 8 – Comparação de Tipos de Variáveis

VARIÁVEIS DE SISTEMA
O Form possui um conjunto de variáveis às quais ele atribui valores automaticamente. Estas variáveis são
chamadas de variáveis de sistema.
Fornecem um conjunto de informações sobre a aplicação. Em sua maioria são apenas legíveis (read-only).
Veremos apenas aquelas que são mais utilizadas nas aplicações de um modo geral.
• System.Cursor_Item – contém o nome do item onde o cursor (foco) está posicionado. O

formato é <bloco>.<item>.
• System.Cursor_Value – contém o valor do item onde o cursor está localizado.
• System.Block_Status – indica o estado do bloco em que o cursor está localizado ou o bloco

corrente durante o processamento de um gatilho. Pode assumir um dos seguintes valores:
- CHANGED – indica que o bloco contém pelo menos um registro alterado.

- NEW – indica que o bloco contém apenas registros novos.
- QUERY – indica que o bloco contém somente registros válidos recuperados do banco de
dados.
• System.Last_Query – representa o comando Select que o Form utiliza para preencher um

bloco. Contém o último comando Select.
• System.Last_Record – contém o valor True se o registro que detém o foco atualmente é o

último registro do bloco. Contém o valor False para os demais registros.
• System.Mode – indica como se encontra o processamento do Form. Os valores podem ser:
- NORMAL – indica que o Form está no estado de digitação, entrada de dados, alteração.
- ENTER_QUERY – indica que o Form está aguardando que o usuário informe restrições
para a consulta a ser realizada.
- QUERY – indica que o Form está lendo dados do banco de dados. Este estado será
perceptível nos triggers de Post-Query, por exemplo.
• System.Mouse_Item – indica o nome do item que está sob o mouse. O formato é

<bloco>.<item>.
• System.Record_Status – indica o estado do registro em que o cursor está localizado. Pode

assumir um dos seguintes valores:
- CHANGED – indica que o registro foi alterado e deve ser enviado para o banco de dados.
- INSERT – indica que um registro New foi modificado e deve ser incluído no banco de
dados.
- NEW – indica que o registro foi criado no buffer, mas ainda não foi modificado.
- QUERY – indica o registro é válido e foi recuperado do banco de dados.
• System.Trigger_Item – indica o item, no formato <bloco>.<item>, no escopo do qual o trigger

corrente foi acionado. Se o trigger é do tipo Key, indica o item em que estava o cursor quando
o trigger foi acionado. Seu valor permanece o mesmo durante toda a execução do gatilho,
independente de haver ou não navegação.

Database Triggers
Já vimos que a atualização de objetos do banco de dados é possível com a ferramenta Form Builder.
Veremos a manutenção de um trigger do banco de dados.
Expandiremos o nó Objetos do Banco de Dados (Database Objects), o nó Desenv (usuário em uso), o nó

Tabelas (Tables), a tabela Func para encontrarmos o nó Trigger.
Acionaremos, então a ferramenta Criar (Create) para que seja mostrado o diálogo da figura 48.
Fig. 48 - Atualização de um
Gatilho do Banco de Dados
Neste diálogo pressionaremos o botão Novo (New) para que a tela seja habilitada.
Poderemos preencher então:
• O nome do trigger no campo Nome (Name).
• A definição do evento do trigger no campo Disparando (Triggering) e no campo Instrução

(Statement). Observe que se a instrução for Update, o campo de Colunas (Of Columns) fica
habilitado para que informemos as colunas que causarão o evento quando modificadas.
• Indicação de trigger de comando ou de linha. Se marcarmos o check box “Para Cada Linha”
(For each Row) estamos indicando um trigger de linha, o que faz com que os dois campos
abaixo fiquem habilitados.
• Alteração do nome das áreas de trabalho (quando usamos trigger de linha). Ao preenchermos
o campo Referenciando Antigo como (Referencing Old as) e Novo como (New as).
• Definição de uma restrição de leitura ao preenchermos o campo Quando (When).
• Finalmente o texto do trigger no campo Corpo do Gatilho (Trigger Body).

CAPÍTULO 9: ALERTAS, ATRIB. VISUAIS E EDITORES
Alertas
Quando enviamos uma mensagem para a linha de mensagem (no rodapé da aplicação) ela aparece de
forma bastante discreta.
O Form Builder nos oferece uma forma bem menos discreta de enviar mensagens, avisos, etc para o
usuário, o objeto Alerta.
Um alerta é uma janela Modal, isto é, uma janela que o usuário deve responder e se fechar para que seja
possível o prosseguimento da aplicação. Quando o usuário receber uma mensagem em uma janela Modal
ele não poderá continuar a aplicação a menos que responda à questão apresentada pela janela. A
aplicação fica parecendo congelada.
Esta forma de trabalho pode ser utilizada por nós para envio de qualquer mensagem que desejarmos,
bastando que coloquemos esta mensagem em um alerta.
Fig. 49 - alerta chamado Erro.
As propriedades do grupo Funcional aparecem na janela de propriedades ao lado.
• Título (Title) – corresponde ao título da janela a ser apresentada (será mostrado na barra azul
da janela).
• Mensagem (Message) – mensagem a ser apresentada para o usuário.
• Estilo de Alerta (Alert Style) - determina o ícone a ser apresentado ao lado da mensagem.
Pode ser: Parar (Caution), Precaução (Warning) ou Observação (Informational).
• Etiqueta de Botão (Button Label) - determina o texto a ser apresentado no botão (em um dos
três) de uma janela de Alerta. Os valores defaults para as etiquetas são: OK, Cancel e Null.
Quando um botão não recebe etiqueta significa que não será apresentado na janela de Alerta.
Ao menos um dos botões de um Alerta deve ter etiqueta.
• Botão de Alerta Default (Default Alert Button) - determina o botão default. O usuário poderá
acionar este botão com a tecla [Enter].
CAPÍTULO 9: ALERTAS, ATRIBUTOS VISUAIS E EDITORES - 92

Após a definição do alerta, devemos acioná-lo.
DECLARE
BOTAO NUMBER;
BEGIN
BOTAO := SHOW_ALERT('ERRO');
IF BOTAO = ALERT_BUTTON1 THEN
MESSAGE('Usuário escolheu o primeiro botão');
ELSIF BOTAO = ALERT_BUTTON2 THEN
MESSAGE('Usuário escolheu o segundo botão');
ELSE
MESSAGE('Usuário escolheu o terceiro botão');
END IF;
END;
Listagem 12
A listagem 12 mostra o código de PL/SQL utilizado para acionarmos o alerta.
A rotina Show_Alert é uma função que retorna um código numérico indicativo do botão que o usuário
selecionou. Isto nos permitirá tomar ações diferentes de acordo com o botão escolhido.
As constantes Alert_Button1 a 3 podem ser

utilizadas para comparação com a variável local
criada para verificarmos o botão escolhido.
Fig. 50 - Show_Alert
A figura 50 mostra o resultado da montagem do alerta.
Suponhamos que a mensagem a ser apresentada não fosse fixa. Que desejássemos mostrar todas as
mensagens de erro do Form em janelas de alerta. Precisaríamos alterar o texto da mensagem.
DECLARE
BOTAO NUMBER;
ALERTA ALERT := FIND_ALERT('ERRO');
BEGIN
CHANGE_ALERT_MESSAGE(ALERTA, ERROR_TYPE ||
TO_CHAR(ERROR_CODE)||':'||ERROR_TEXT);
BOTAO := SHOW_ALERT('ERRO');
END;
Listagem 13
A listagem 13 mostra esta ação. Alteramos o alerta para que fosse apresentado um único botão e a
mensagem a ser apresentada é modificada antes da apresentação do alerta.

Atributos Visuais (Visual Attributes)

Um atributo visual é um grupamento de propriedades visuais (cor, tipo de letra, etc). Seu uso pode ser útil
no estabelecimento de padrões visuais para a aplicação.
Quando definimos um atributo visual não somos obrigados a especificar todas as propriedades visuais,
podemos definir apenas aquelas que desejamos padronizar.
Fig.51 - Propriedades de um
Atributo Visual
Na figura 51 apresentamos um atributo visual (de nome Corrente) no qual modificamos apenas a primeira
Cor de Fundo (BackGround Color) para DarkGreen (Verde Escuro) e a segunda propriedade Cor de Fundo
(Foreground Color) para White (Branco).
Após a criação deste objeto devemos fazer referência a ele em outro objeto para que se torne útil.
Poderíamos, por exemplo, preencher seu nome na propriedade Grupo de Atributos Visuais do Registro
Corrente (Current Record Visual Attribute Group) do grupo Registros (Records) dos blocos em uso em
uma determinada aplicação.
Fig. 52 - Utilização de
Atributo Visual

Editores
Um editor é uma janela para digitação de texto pelo usuário. Em vez de ficar restrito ao tamanho da área
delimitada para o item na tela, o editor apresenta uma janela para digitação livre até o tamanho definido
para o campo.
O Form fornece um editor padrão, pré-definido, que não precisa de nenhuma programação especial para
ser apresentado. Basta que o usuário posicione o cursor sobre o item que deseja editar e pressione o
conjunto de teclas correspondente à ação Editar (CTRL+e). Isto fará com que seja apresentada a janela de
edição.
A criação de um outro editor dentro da aplicação nos oferece a possibilidade de alterarmos algumas de
suas características (do editor padrão), como veremos por suas propriedades:
• Título (Title) - título a ser apresentado para a janela do editor.
• Título de Base (Bottom Title) - título a ser apresentado abaixo do campo de edição na janela
do editor.
• Estilo de Sobreposição (Wrap Style) - Especifica como o texto será apresentado quando seu
conteúdo exceder à largura especificada para a janela do editor. Os valores válidos para esta
propriedade são: Nenhum (None), Caractere (Character) ou Palavra (Word). Se escolhermos
Palavra (Word), o texto quebrará de linha somente em término de palavra.
O grupo Físico permite a determinação de uma posição para apresentação desta janela, além de tamanho
da janela e presença ou não de barra de rolagem.
Os Grupos Fonte e Cor permitem a determinação de características visuais para a janela.
Não é suficiente, no entanto, a criação do objeto. Temos de associá-lo aos itens que desejamos que ele
apareça.
O grupo Editor(do item) deve ser preenchido para que a apresentação seja feita nas condições desejadas.
A propriedade Editor pode ser preenchida com o nome do editor criado, o texto System_Editor ou <Nulo>:
• No caso de <Nulo> será apresentado o editor padrão do Form.

• No caso de um nome será apresentado o editor definido.
• No caso de System_Editor será acionado um editor do sistema operacional definido através de
uma variável de ambiente (Forms50_Editor = c:\windows\notepad.exe) no registrador do
Windows95.
Podemos especificar, também, a posição de aparecimento da janela. A especificação deste valor se

sobrepõe à especificação que fizemos no objeto.
A figura 53 mostra o resultado da utilização do editor criado na

aplicação.
Fig. 53 - Editor

Se desejássemos efetuar o acionamento do editor através de um botão e não pelo teclado, algumas
etapas deveriam ser cumpridas:
• Criação de uma trigger Key_Editor (a nível de aplicação), desabilitando a chamada a um

editor. Basta que no PL/SQL coloquemos o comando Null; para que nenhuma ação aconteça
ao pressionarmos a seqüência de teclas.
• Criação de um botão contendo uma trigger do tipo When-Button-Pressed conforme o exemplo

da listagem 14 a seguir:
IF :SYSTEM.CURSOR_ITEM = 'DEPTO.NM_DEPTO' THEN

EDIT_TEXTITEM(250, 90);
END IF;
Listagem 14
Na listagem 14 somente quando o foco estiver sobre o item nm_depto do bloco depto, o editor será
acionado.
Outra forma de realizar a mesma ação, é o uso da rotina Show_Editor.
DECLARE
TEXTO VARCHAR2(2000);
RETORNO BOOLEAN;
BEGIN
SHOW_EDITOR('EDITOR', :NM_DEPTO, 180, 90, TEXTO, RETORNO);
IF RETORNO THEN
:NM_DEPTO := TEXTO;
END IF;
END;
Listagem 15
Na listagem 15 apresentamos a rotina Show_Editor que aciona o editor da mesma forma que vimos
anteriormente, porém não precisamos associar o editor ao item a tempo de desenvolvimento e o usuário
não precisa estar com o cursor posicionado sobre o item a ser editado.
Um dos parâmetros passados para a rotina é o texto a ser editado (:nm_depto).

O retorno da edição, isto é, o texto modificado pelo usuário é recebido pela variável local Texto.
Tomamos este cuidado (em vez que atribuir diretamente à variável :nm_depto) pois se o usuário
pressionar a tecla Cancelar (Cancel) da janela do editor o texto retornado é Null.
Assim para que não seja perdido o conteúdo da variável nm_depto, recebemos o texto editado em uma
variável de trabalho e em seguida verificamos o valor do boleano retorno.
Se o usuário escolher OK, o boleano retorna True (e devolvemos o valor para nm_depto). Caso contrário
não sujamos o item da tela.

CAPÍTULO 10 : LOVS E RECORD GROUPS
Lista de Valores (List of Values) - Lovs

Uma Lov (List of Values) corresponde a uma janela (modal) contendo uma lista de valores passível de
seleção.
Os dados apresentados nesta lista estão armazenados em uma estrutura chamada Grupo de Registros
(Record Groups).
Uma Lov está sempre associada a um Record Group. A Lov é um mapeamento dos dados do Record
Group, disponibilizada para o usuário selecionar uma das opções da lista.
Podemos associar a Lov a um ou mais itens da aplicação, de tal forma, que quando o usuário navegar
para um destes itens será mostrado um indicador “Lista de Valores” (List of Values) na linha de status (no
rodapé da tela, abaixo da linha de mensagem) indicando a existência de uma lista para aquele item.
Quando isto ocorre o usuário poderá acionar a lista por teclado (Lista de Valores – F9) para que a janela
seja apresentada.
CRIANDO UMA LOV

Para criamos uma lista de valores devemos, inicialmente,
selecionar o nó LOVs e pressionar o botão Criar (Create) da
barra de ferramentas do Navegador.
No diálogo apresentado poderemos optar pela utilização do

Assistente para a construção da lista ou podemos construí-la
através de manipulação das propriedades.
Fig. 54 - Criação de
Nosso primeiro teste será a utilização do Assistente. uma Lista de Valores
O primeiro diálogo apresentado corresponde à tela de Boas Vindas do editor, que pode ser descartado.
No segundo diálogo, devemos indicar se a lista de valores será criada a partir de um novo Record Group a
ser criado simultaneamente ou se baseará em um Record Group já existente.
Se não tivermos nenhum Record Group em nossa aplicação, a segunda opção já aparece desabilitada.
No terceiro diálogo devemos informar o comando Select a ser incluído no Record Group. Podemos digitar
o comando, importar o texto de um arquivo em disco, estabelecer conexão com o banco de dados, acionar
o Query Builder para auxílio na montagem da sintaxe adequada e, finalmente, verificar a sintaxe
preenchida.
Após preenchermos este diálogo nos é apresentado o quarto diálogo, no qual indicamos quais as colunas
do Record Group devem fazer parte da lista de valores.
São apresentados dois campos, um contendo a lista de colunas existentes no Record Group (Colunas do
Grupo de Registros) e outro contendo a lista de colunas existentes na Lov. Usando os botões centrais
podemos transferir as colunas do Record Group para a Lov (> e >>) ou da Lov para o Record Group (< e
<<).
CAPÍTULO 10: LOVS E RECORD GROUPS - 97

No quinto diálogo indicamos o texto a ser apresentado como cabeçalho de coluna, o tamanho de cada
coluna (ou a opção de dimensionamento automático) e o nome do item (ou itens) para onde deve ser feito
o retorno dos valores referentes à linha selecionada pelo usuário.
Neste diálogo encontramos um botão identificado como “Pesquisar item de retorno...” que nos apresenta
uma lista com os itens presentes na aplicação para que possamos, mais facilmente, indicar para que itens
devem ser copiados os valores referentes à linha selecionada pelo usuário.
No sexto diálogo temos a possibilidade de informar um título para a janela da Lov, suas dimensões
(largura e altura) e seu posicionamento na tela a tempo de execução.
O próximo diálogo (sétimo) permite a indicação da quantidade de linhas a serem lidas de cada vez (para
carga da Lov), da freqüência com que esta leitura deve ser feita e da utilização de filtro para diminuição da
quantidade de linhas lidas.
No diálogo seguinte (oitavo) podemos (ou não) estabelecer a associação da Lov a um item. São
apresentados, opcionalmente, todos os itens indicados como retorno (em diálogo anterior). Este diálogo é
opcional, ou seja, se não indicarmos a associação, a Lov deve ser acionada por programação. Quando
estabelecemos a associação, o usuário poderá acionar a Lov usando a tecla [List] (F9).
Quando teclamos o botão Avançar neste diálogo, nos é apresentado o diálogo de encerramento, sendo,
em seguida, criada a lista de valores e o Record Group.
Quando acionamos o Assistente de Lov com um Record Group já presente na aplicação, no segundo
diálogo podemos indicar que a Lov se utilizará de um Record Group previamente criado (e presente).
Em seguida aparece um diálogo intermediário onde indicamos se a Lov se baseará no Record Group
existente (podemos até modificar este Record Group) ou se a Lov se baseará em um novo Record Group,
porém copiando a definição do Record Group criado anteriormente.
Os diálogos seguintes são semelhantes aos anteriormente descritos.
Foram criados simultaneamente dois objetos:
• uma lista de valores

• um grupo de registros com o mesmo nome da lista de valores.
Nossa primeira reação é achar que a ligação entre os dois objetos é feita pelo nome. Isto não é verdade.
Em uma das propriedades da lista de valores indicamos qual o grupo de registros à que ela se refere.

PROPRIEDADES DA LOV
Analisemos as propriedades da lista (Lov) presentes no grupo funcional.
• Título (Title) – indica o título da janela da lista.
• Tipo de Lista (List Type) – indica se a lista é baseada em um Record Group ou em uma
tabela do estilo V2. Trabalharemos sempre com Record Group.
• Grupo de Registros (Record Group) – define o nome do record group ao qual a lista se
refere.
• Propriedades de Mapeamento de Coluna (Column Mapping Properties) – esta propriedade

será utilizada para mapearmos dentre as colunas no record group quais serão apresentadas
na lista.
• Filtrar Antes da Exibição (Filter Before Display) – quando marcamos esta opção com Sim, a
tempo de execução é apresentada uma tela para que o usuário digite algum texto que restrinja
a pesquisa na base de dados. O texto digitado pelo usuário é completado com ‘%’ e utilizado
em uma cláusula Where adicionada à query. Esta restrição è montada para a primeira coluna
visível (não é a primeira coluna da lista) na janela da Lov.
• Exibição Automática (Automatic Display) – indica que quando o item ao qual a Lov está
associada receber o foco, a lista é apresentada automaticamente.
• Renovação Automática (Automatic Refresh) – indica que a cada vez que o usuário acionar
a Lov, o comando Select associado com o Record Group será executado para “refrescar” os
dados armazenados em memória.
• Seleção Automática (Automatic Select) – indica que se a lista apresentada contiver apenas
uma linha, a seleção é automática. A janela da Lov é fechada e a linha selecionada.
• Salto Automático (Automatic Skip) – indica que após a seleção de uma das opções da lista
o cursor deve navegar automaticamente para o próximo campo.
• Posição Automática (Automatic Position) – especifica que o Form deve posicionar a janela
da Lov próxima ao campo de onde foi acionado.
• Largura Automática da Coluna (Automatic Column Width) – quando marcamos esta

propriedade para Sim. o Form verificará o que é maior o título da coluna (propriedade Título da
Coluna – Column Title) ou seu comprimento (propriedade Largura da Exibição – Display Width)
e faz o ajuste da largura da coluna necessário. Se marcarmos esta propriedade com Não a
largura será dada pela propriedade Largura da Exibição (Display Width).
Pode-se preencher o grupo Físico com o posicionamento da Lov, se desejarmos uma posição fixa, ou
preencher apenas na associação com o item, ou ainda deixar o posicionamento a cargo do Form (com a
propriedade Posição Automática).
ASSOCIANDO A LOV A UM ITEM

A associação é feita através das propriedades presentes no grupo Lov do item.
• Lista de Valores – corresponde ao nome da lista.
• Posição X da Lista – indica o posicionamento da janela da Lov a tempo de exibição.
• Posição Y da Lista – indica o posicionamento da janela da Lov a tempo de exibição.
• Validar a partir da Lista – indica que se o usuário digitar um valor no item (em vez de acionar
a Lov), este valor será verificado no Record Group associado à lista.

MAPEANDO NA LOV AS COLUNAS DO RECORD GROUP

O mapeamento das colunas do Record Group na Lov deve ser efetuado
também.
Na figura 55 apresentamos o diálogo referente a esta propriedade.
Na parte superior deste diálogo são mostradas as colunas presentes no

Record Group.
Quando selecionamos (basta colocar o cursor em uma das colunas)

uma das colunas da parte de cima, as características apresentadas
abaixo são referentes a esta coluna.
• Item de Retorno (Return Item) – quando o usuário

selecionar uma das linhas exibidas pela Lov podemos
atribuir o valor desta coluna (atualmente selecionada) para
um dos itens da aplicação.
Fig. 55 - Mapeamento de
• Largura da Exibição (Display Width) – esta propriedade Colunas da Lov
determina a largura da coluna selecionada na janela da Lov.
• Título da Coluna (Column Title) – Título da Coluna.
CONTROLANDO A APRESENTAÇÃO DA LOV

Suponhamos, agora, que não desejamos que nosso usuário utilize o teclado para acionar a Lov.
Poderemos, então, criar um botão para acionamento da lista a partir do item na qual ela está associada.
DECLARE
BLISTA BOOLEAN;
BEGIN
BLISTA := SHOW_LOV;
END;
Listagem 16
Show_Lov é uma função que retorna um boleano True ou False indicando se a janela (da lista) foi
apresentada ou não.
Na sintaxe desta rotina observaremos que ela pode receber como parâmetro o posicionamento da lista e o
nome da lista, caso não venhamos a fazer a associação com o item (propriedades do item).

RECOMENDAÇÕES A RESPEITO DE LOVS

Neste tópico chamamos a atenção para três parâmetros da lista que podem trazer ganho ou perda de
performance, dependendo da utilização que viermos a dar.
• Renovação Automática (Automatic Refresh) - Se esta propriedade estiver marcada Sim

(True), o Form executa a query associada à LOV (descrita no Record Group) cada vez que a
LOV é acionada. Devemos avaliar a necessidade de deixar esta propriedade Sim (True). Caso
a lista de valores não seja freqüentemente modificada, não há necessidade de mantê-la Sim
(True).
Se desejarmos fazer uma atualização dos valores da lista eventualmente, podemos usar a built-in
Populate-Group.
• Exibição Automática (Automatic Display) - Determina que o Form mostre a LOV

automaticamente, quando houver uma navegação para o item associado. Se a propriedade
anterior estiver com Sim(True), o uso desta propriedade simultaneamente poderá agravar a
seqüência de acessos ao banco de dados, comprometendo a performance.
• Filtrar Antes da Exibição (Filter Before Display) - Quanto maior a quantidade de elementos
apresentados em uma Lov, pior a performance, uma vez que as linhas a serem apresentadas
para o usuário devem trafegar pela rede para chegar ao ambiente cliente e, ainda, ser
armazenadas (em memória ou disco) enquanto forem úteis para a Lov.
Desta forma devemos nos restringir a uma quantidade máxima de 300 linhas (aproximadamente)
por Lov (avalie o número ideal para a sua instalação). Ou seja, caso haja necessidade de
apresentação de uma quantidade superior de linhas, temos 2 alternativas:
- Criar um novo bloco multirecord e efetuar tratamento de leitura parcial com a rotina Enter-
Query.
- Usar a propriedade Filtrar Antes da Exibição (Filter Before Display) para que seja
apresentado um diálogo restritivo. O texto digitado no diálogo é completado com o caracter
%, para que todas as linhas que comecem com o texto digitado sejam apresentadas.
A COLUNA DE PESQUISA
A primeira coluna que especificamos em uma Lov será usada para pesquisa:
• Seleção Automática (Automatic Select) – ocorre quando o operador digita alguma letra e a
janela da LOV está ativa.
• Loc. – a pesquisa será realizada a partir do caracter mais à esquerda somente na primeira
coluna, a não ser que o operador inicie o texto com %. Neste caso todas as colunas serão
pesquisadas.
• Filtrar Antes da Exibição (Filter Before Display) –

o texto entrado no diálogo é usado na cláusula
Where, de acesso ao banco de dados, acrescida de
%. A pesquisa é feita apenas para a primeira
coluna.
• Validar a partir da Lista (Validate from List) – a

validação é feita em relação à primeira coluna
visível.
Fig. 56 - Lov - Filtrar

antes da Exibição

Record Groups
Um Grupo de Registros (Record Group) é uma estrutura interna do Form capaz de armazenar dados como
se fosse uma tabela (ou uma matriz), isto é contendo linhas e colunas. Este armazenamento, a princípio é
feito em memória.
Existem 3 tipos de Record Groups:
• Query Record Group – corresponde a um grupo de registros que contém um comando Select
associado.
• Static Record Group – corresponde a um grupo de registros cuja estrutura é montada a

tempo de desenvolvimento.
• Non-Query Record Group – corresponde a um grupo de registros cuja estrutura é totalmente

definida a tempo de execução. É dinâmico.
Ao tempo de desenvolvimento podemos criar os dois primeiros tipos (Query e Static). Durante a execução
podemos criar (ou popular) Query e Non-Query.
QUERY RECORD GROUP

Um Record Group do tipo Query pode ser criado
juntamente com a Lov, como fizemos no tópico
Lov ou poderemos criar o Record Group primeiro
e depois associa-lo à Lov.
Ao selecionarmos o nó Grupo de Registros e

pressionarmos o botão Criar (Create) nos será
apresentado o diálogo da figura 57.
Para a criação de um Query Record Group

deveremos escolher a opção “Com Base na
Consulta a seguir...” e preencher um a query
para associação com o Record group.
Fig. 57 – Query Record Group

Na tela de propriedades de um Record Group (no grupo funcional) encontramos:
• Tipo de Grupo de Registros (Record Group Type) - determina o tipo do Grupo de Registros
(Record Group). Podemos preencher com Estático (Static) ou Consulta (Query).
• Consulta do Grupo de Registros (Record Group Query) - contém o comando Select

associado ao Grupo de Registros(Record Group) se o Tipo do Grupo de Registros(Record
Group) for Consulta (Query).
• Tamanho de Extração do Grupo de Registros (Record Group Fetch Size) - determina a

quantidade de registros a serem lidos do banco de dados de cada vez.
• Especificações da Coluna (Column Specifications) – corresponde ao mapeamento das

colunas de um Record Group estático ou as colunas selecionadas pelo comando Select em
um Record Group Query. No caso do Record Group do tipo Query não precisamos nos
preocupar com o mapeamento pois o Form Builder obtém esta especificação da coluna
correspondente no banco de dados. Isto só seria necessário se o comando Select tivesse uma
expressão. Neste caso poderíamos determinar o tipo do dado e tamanho das expressões
incluídas.

STATIC RECORD GROUP

Um Record Group estático corresponde à montagem de uma tabela, passando pela definição das colunas:
tamanho, tipo, nome e valor.
Neste caso escolheríamos a opção “Valores Estáticos” no diálogo da

figura 57. Ao aceitarmos este diálogo nos é apresentado um outro
diálogo, como o da figura 58, que deve ser preenchido da seguinte
forma:
• Para o campo Nomes de Coluna (Column Names)

preencheríamos com as colunas da tabela (no caso
escolhemos nr_git e ds_git).
• Se desejarmos remover uma linha da lista devemos usar

CTRL+SHIFT+< e para incluir uma nova linha no meio
de outras devemos usar CTRL+SHIFT+>.
• Para o campo Tipo de Dados devemos preencher com o

tipo correspondente à coluna selecionada na parte
superior e para o campo Tamanho devemos informar o Fig. 58 – Especificação de
tamanho do campo (para os campos alfanuméricos). Coluna para Record Groups.
• O último campo deste diálogo (Valores de Coluna) corresponde aos valores a serem
atribuídos a cada coluna. Desta forma, quando selecionamos a coluna nr_git no campo
superior, devemos preencher neste local os valores relativos, no caso do exemplo, ao código
de grau de instrução e quando selecionamos ds_git no vampo superior, devemos preencher
com as descrições de grau de instrução.
CRIANDO LOVS A PARTIR DOS RECORD GROUPS

Após a criação dos Record Groups podemos crias listas de valores que façam referência a estes grupos
de registros.
Para tal devemos selecionar o nó Lov, pressionar o botão Criar (Create) e no diálogo apresentado (figura
54) marcar a opção Grupo de Registros Existentes (Existing Record Group).
Em seguida, pressionar o botão Selecionar (Select) para escolher, na lista apresentada, o grupo de
registros desejado.
NON-QUERY RECORD GROUP

Este tipo de Grupo de Registro (Record Group) é todo montado a tempo de execução.
Devemos usar as seguintes rotinas para a criação do grupo:
• Create_Group - para a criação do Record Group.
• Add_Group_Column – para a anexação de uma coluna.
• Add_Group_Row – para a inclusão de linhas.
• Set_Group_Char_Cell, Set_Group_Date_Cell ou Set_Group_Number_Cell - para definir o

valor das colunas.
Após a criação podemos usá-lo para pesquisa, inclusão e exclusão de valores.

CAPÍTULO 11 : LOBS E OBJETOS

Neste capítulo trataremos, especificamente da utilização no Forms dos novos elementos do banco de
dados Lobs e Objetos.
Nesta versão ainda não está disponível a utilização de coleções, desta forma nos objetos utilizados não
poderemos manipular com Nested Tables ou Varrays.
Lobs
No Oracle8 temos a possibilidade de criar objetos muito grandes, chamados Lobs (Large Objects).
Estes tipos de dados podem ser utilizados em uma aplicação Form que estabeleça conexão com um
banco de dados Oracle8.
Em nosso ambiente já contamos com uma tabela (Tlob) disponível para trabalho com este tipo de objeto.
Ao criamos uma aplicação utilizando os tipo Lobs, observaremos que :
• Um item Lob (por exemplo C_Clob1) é criado com tamanho 240 (é o default), mas pode ser
ampliado até 65534 bytes (limite para o ambiente cliente, por enquanto).
• A propriedade Tipos de Dados (Datatype) recebe o valor de Lob, porém, no ambiente cliente o
item é texto(ou imagem), ou seja, na aplicação Forms temos o dado a ser armazenado.
• Internamente o Form armazena o Locator (que será utilizado para indicação da localização
exata da parte de dado no banco de dados).
• Desta forma o pacote Dbms_Lob não é aplicável aos itens Lob no ambiente cliente, porém
podemos utilizar as demais rotinas de PL/SQL como se ele fosse um texto escalar(varchar2,
char, etc) ou uma imagem (read_image_file, write_image_file).
A inclusão e alteração de itens deste tipo é feita com o uso da cláusula Returning.
Restrições
Como restrição ao uso de Lobs (nesta versão) temos:
• Os lobs do tipo Bfiles são read-only uma vez que são arquivos armazenados fora do banco de
dados (no ambiente servidor).
O servidor armazena apenas o endereçamento do arquivo, desta forma, os Bfiles não podem
participar de transações do banco de dados e, portanto, podem ser utilizados apenas para leitura
em aplicações Forms.
• Como restrição adicional os Lobs não podem exceder 65534 bytes.
CAPÍTULO 11: LOBS E OBJETOS - 104

Objetos
No Oracle8 além de Lobs podemos criar objetos e armazená-los em uma Object Table.
O Form Builder 6i além de ter acesso e atualizar Lobs também permite a manutenção de objetos criados
no banco de dados, de acordo com as seguinte regras:
• uma Object Table onde toda a tabela é baseada em um único objeto.
• uma coluna objeto em uma tabela relacional, onde esta coluna está baseada em um objeto.
• uma coluna REF em tabelas relacionais ou tabelas objeto.
Fig. 59 - Assistente
de Bloco de Dados
(Objetos)
Observe, na figura 59, que no campo Colunas Disponíveis foram apresentadas as colunas cd_mat (com
um ícone à esquerda indicando que se trata de um escalar numérico), nm_depto (com um ícone à
esquerda indicando que se trata de um escalar alfanumérico), cd_depto_ctb (com um ícone à esquerda
indicando que se trata de uma referência pois aponta para outra linha) e cd_gerente (idêntico a
cd_depto_ctb).
Para as duas colunas de referência você também encontra o sinal de + do lado esquerdo indicando que
temos um nó e que podemos expandi-lo.
Na figura 59, apresentamos o nó cd_gerente já expandido. Observe que podemos escolher colunas da
tabela Tb_Depto diretamente ou colunas da tabela tb_Func (apontada pelo atributo REF cd_gerente).
Desta forma, com muita facilidade, podemos apresentar na tela, os dados do Departamento e dados do
gerente do departamento correspondente, sem que tenhamos de manter esta informação com triggers
(post-query, por exemplo).
Esta expansão de atributos não pára no primeiro nível. O objeto apontado pelo REF também possui um
REF(cd_depto) que aponta para outro objeto(Tb_Depto), podemos expandi-lo e repetir esta operação
diversas vezes, enquanto encontrarmos referências.
O atributo Nr_Tel (em Tb_Func), no entanto, não está disponibilizado para expansão, pois se trata de uma
coleção (ainda não disponível para uso nesta versão).

Quando criamos um bloco que utiliza um item REF para outro objeto, surge um diálogo durante a
construção do bloco para que indiquemos se desejamos que seja criada uma Lov para acesso aos dados
referenciados que venham a permitir a atualização da referência (endereço).
Fig. 60 - Paleta de Propriedades (Grupo de Registros).
Na figura 60 encontramos as propriedades do Record Group associado à Lov.
Observe que o comando Select obtém a referência da linha para que quando o usuário escolha um novo
gerente, sua referência seja atualizada no item cd_gerente do bloco.
O campo de retorno deste OID (veja na especificação da LOV) é o item cd_gerente, presente na lista de
itens criados subordinado ao bloco Tb_Depto.
Se abrirmos a tela de propriedades deste item verificaremos que sua propriedade Tipo de Dados
(Datatype) está preenchida com REF do Objeto, indicando que se trata de um item do tipo REF.

CAPÍTULO 12: ÁRVORE HIERÁRQUICA

Este tipo de item permite a apresentação dos dados com o aspecto do Object Navigator, ou seja, com nós,
sub nós e elementos.
Os usuários poderão expandir ou contrair nós na hierarquia, obtendo visualização de sub nós e elementos
folha.
Podemos preencher esta árvore com valores oriundos de um Record Group ou com dados obtidos
diretamente por uma query.
Além da árvore hierárquica contamos com um pacote chamado Ftree que contém diversas rotinas para
que possamos manipular, a tempo de execução, os elementos da árvore, permitindo a adição, remoção,
modificação ou avaliação destes elementos.
Criando uma árvore hierárquica

No nó Blocos devemos incluir um bloco, no qual criarmeos um item com tipo Árvore Hierárquica.
Um item do tipo Árvore Hierárquica deve estar presente em um bloco com 1 linha e como único item. Caso
contrário, a tempo de execução receberemos a mensagem apresentada na listagem 17.
FRM-32089: As árvores devem estar em blocos de apenas uma linha e item.

Listagem 17
Nas propriedades relativas ao grupo Funcional deste item Árvore Hierárquica(as demais são similares a
itens de um modo geral), encontramos:
• Ativado (Enabled) – determina se o usuário final poderá usar o mouse para manipular o item.
• Permitir Ramificações Vazias (Allow Empty Branches) – indica se podem existir nós sem
filhos. Se esta opção estiver habilitada, os nós sem filhos serão convertidos para elementos
(ou seja “folhas”). Caso esta propriedade esteja desabilitada, um nó vazio será apresentado
como um nó não expandido.
• Multisseleção (Allow Multiselect) – indica se o usuário poderá ou não selecionar mais de um

elemento na árvore.
• Mostrar Linhas (Show Lines) – determina se as linhas de ligação entre os nós devem ser
apresentadas.
• Mostrar Símbolos (Show Symbols) – indica se os símbolos + ou – devem ser apresentados

na frente de um nó vazio. O símbolo + indica que o nó tem filhos mas não está expandido. O
símbolo – indica que o nó está expandido.
• Grupo de Registros (Record Group) – indica o nome do Record Group de onde os dados
serão originados para o preenchimento do item.
• Consulta de Dados (Data Query) – indica o texto da query de onde os dados serão
originados para o preenchimento do item.
CAPÍTULO 12: ÁRVORE HIERÁRQUICA - 107

O layout da query ou do Record Group para preenchimento da árvore hierárquica deve obedecer ao
especificado na tabela a seguir:
Coluna Conteúdo Descrição

1 Estado Inicial Pode ser preenchido com 0 (indicando que este é um elemento não é
um nó), 1 (indicando que este nó deve ser apresentado inicialmente
expandido), -1(indicando que este nó deve ser apresentado
inicialmente contraído).
2 Profundidade do Nó Esta posição indica o nível do nó na hierarquia, sendo o nível 1
considerado raiz e quanto maior o número maior o nível de
subordinação.
3 Label Indica o texto a ser mostrado para o usuário.
4 Ícone para o Nó Determina o nome de um arquivo (.ICO) a ser usado ao lado dos
símbolos + e -. O arquivo deve estar presente em um dos diretórios
nomeados pela variável de ambiente UI_ICON. Não preencha a
extensão no nome do arquivo.
5 Dado Valor interno do elemento.
Tabela 9 – Layout Linha Árvore Hierárquica
O comando SELECT (incluído na propriedade Consulta de Dados - Data Query do item Árvore
Hierárquica) e descrito na listagem 18 simula a montagem de uma árvore para os dados da tabela Depto.
SELECT DECODE(LEVEL, 1, 1, 2, -1, 3, 0), LEVEL, UPPER(CD_DEPTO),

DECODE(LEVEL,1, 'CLEAR', 2, 'CLEAR',3, 'CLEAR'), CD_DEPTO
FROM DEPTO
CONNECT BY PRIOR CD_DEPTO=CD_DEPTO_CTB
START WITH CD_DEPTO = 'A00'
Listagem 18
Simulamos a hierarquia com o uso da cláusula Connect By em nossa tabela Depto (temos um auto-
relacionamento nesta tabela).
Na primeira coluna fizemos uso da pseudo-coluna Level para indicar o estado inicial do nó. Portanto, se o
nível for 1, o nó aparecerá expandido, se o nível for 2, o nó aparecerá contraído e se o nível for 3
indicamos que se trata de uma “folha” (um elemento).
Da mesma forma para a indicação do ícone escolhemos três ícones quaisquer no diretório default
(c:\orawin95\tools\devdem60\bin\icon) e os associamos a cada um dos níveis.
PREENCHENDO UMA ÁRVORE HIERÁRQUICA

Para a carga devemos executar uma rotina (apresentada
na listagem 19) que preenche o controle com os dados
obtidos do Record Group ou da Query.
FTREE.POPULATE_TREE ('arvore');
Listagem 19
Na figura 61 encontramos o resultado visto pelo usuário.
Observe que existem elementos na árvore sem o sinal de

+ à esquerda (são os elementos “folha” ).
Fig. 61 - Árvore Hierárquica
CAPÍTULO 12: ÁRVORE HIERÁRQUICA - 108

CAPÍTULO 13: A DEPURAÇÃO DO PL/SQL

A depuração no Form significa que vamos acompanhar a execução do programa passo a passo e,
eventualmente, poderemos intervir no processo. Estamos depurando o código PL/SQL do programa.
A depuração pode ser feita de duas formas:
• Dinâmica – quando iniciamos a execução do programa e, neste momento, definimos os

pontos de interrupção. É a forma mais comum de utilização no Form 4.5.
• Estática – definimos os triggers ou unidades de programa que desejamos analisar e usamos o

pacote Debug para forçar uma interrupção. A utilização do pacote é feita a tempo de
desenvolvimento, ainda no Form Builder.
Nota
A rotina Break do pacote Standard Extensions era a forma utilizada na versão 4.5 para produzirmos uma
interrupção definida estaticamente.
DOWN;
FOR I IN 1..10 LOOP
:NR_GIT := :NR_GIT + 1;
IF I >= 7 THEN
DEBUG.SUSPEND;
END IF;
END LOOP;
Listagem 20
Para entrarmos em estado de depuração devemos executar a aplicação usando o botão Executar
Depuração de Form, presente na paleta de ferramentas do Navegador.
A Janela de Depuração
Fig. 62 – Janela de
Depuração
Quando a execução se inicia, aparece uma

janela intitulada “Depurador de Forms”
(Form Debugger).
Esta janela está subdividida em três painéis:
• Painel de Fonte – O painel superior nos mostrará trechos dos blocos de PL/SQL presentes na
aplicação quando fizermos a seleção da unidade de programa.
CAPÍTULO 13: A DEPURAÇÃO PL/SQL - 109

• Painel de Navegação – O painel central mostra a árvore hierárquica do Navegador,

subdividida nos seguintes nós principais:
- Módulos – Expandindo este nó veremos as aplicações abertas no ambiente de

desenvolvimento. Poderemos expandir cada uma delas e visualizar os blocos, os itens e
seus valores, os triggers, os parâmetros e valores, as unidades de programa internas e
externas (bibliotecas anexadas), ou seja, toda a parte de código e dados dos módulos.
- Variáveis Globais – Nome e conteúdo de todas as variáveis globais existentes até o

momento.
- Variáveis de Sistema – Nome e valor de todas as variáveis de sistema.
- Parâmetros da Linha de Comando – Nome e valor de todos os parâmetros recebidos

pelo Form Runtime, sejam eles criados pelo usuário ou parâmetros padrões de sistema.
- Lista dos pacotes embutidos – semelhante àquela presente no Form Builder.
- Ações de Depuração – este nó será preenchido quando definirmos os pontos de

depuração.
- Stack – este nó será preenchido pelo Form durante a depuração de um trecho de PL/SQL.
Estarão presentes todas as variáveis locais com seus respectivos valores e também todas
as rotinas (procedures e funções) em execução na ordem de chamada, como uma pilha.
- Objetos do Banco de Dados – semelhante ao nó de mesmo nome presente no Form

Builder.
• Painel de Comandos – Neste painel aparece uma linha de comando em que podemos
executar comandos diretamente no ponto de interrupção, alterando o valor de variáveis,
executando ações, etc. Corresponde a uma linha de comando de PL/SQL.
Com este painel teremos acesso a todas as variáveis e a toda a parte de código da aplicação.

Marcando um ponto de Interrupção

A interrupção é feita em relação a uma das linhas do código. Podemos interromper o código de duas
maneiras diferentes:
• Ponto de Interrupção (BreakPoint) – determina um ponto em que o código será interrompido

para análise. É uma interrupção incondicional.
• Gatilho (Trigger) – determina um ponto em que o código poderá ser interrompido se a lógica
definida no trigger determinar.
Quando a interrupção ocorre o controle sai da aplicação e passa para o depurador permitindo uma
verificação da execução passo a passo.
BREAKPOINT
Para a marcação de um ponto de
interrupção devemos selecionar a
linha em que ocorrerá a interrupção
(posicionando o cursor sobre a linha) e
escolher no menu Depurar (Debug) a
opção Interromper (Break).
Fig. 63 – Ponto
de Interrupção
Neste diálogo temos as seguintes

informações:
• Ponto de Interrupção (Breakpoint) – indica se este é um ponto de interrupção novo ou já

existente. Se for um já existente aparecerá um número.
• Ativado (Enabled) – indica se este ponto está habilitado ou não.
• Unidade de Programa (Program Unit) – identifica a unidade de programa. Nome dado pelo
Forms.
• Linha (Line) – especifica a linha dentro da unidade de programa em que o ponto de

interrupção foi marcado.
• Gatilho (Trigger) – define um código de PL/SQL para o ponto de interrupção. Este código
será acionado cada vez que o ponto de interrupção for atingido.
O pacote Debug contém rotinas que nos permitirão alterar o valor das variáveis locais do trecho de código
que estamos analisando. No caso do exemplo, quando o ponto de interrupção for atingido, a variável local
V1 receberá o valor 5.
Quando pressionarmos o botão OK (no diálogo da figura 58), o ponto de interrupção é criado. No Painel de
Fonte aparecerá o texto B(01) em vez do número da linha. No nó Ações de Depuração no Painel do
Navegador, encontraremos a criação do ponto de interrupção.
Se não desejarmos preencher nenhum texto a ser executado juntamente com o ponto de interrupção,
podemos selecionar a linha que desejamos interromper e efetuar um click duplo. O ponto de interrupção
será marcado da mesma forma.
Para desmarcar o ponto de interrupção devemos selecionar a linha em que o ponto está marcado e efetuar
um click duplo.

TRIGGER
Um gatilho funciona ligeiramente diferente de um ponto de interrupção. No gatilho escreveremos uma
lógica que determinará se a interrupção ocorrerá ou não.
A criação do gatilho é similar à criação do ponto de interrupção. Selecionamos a linha desejada,

escolhemos no menu Depurar (Debug) a opção Gatilho (Trigger).
Fig. 64 – Gatilho de PL/SQL na depuração
Neste diálogo encontramos:
• Gatilho (Trigger) – indica se este é um gatilho novo ou já existente. Se for um já existente

aparecerá um número.
• Ativado (Enabled) – indica se este gatilho está habilitado ou não.
• Local (Location) – especifica a localização do gatilho de depuração. Pode ser preenchido

com:
- Unidade de Programa (Program Unit) – indica que o gatilho de depuração estará

localizado exatamente na unidade de programa especificada e na linha especificada.
Somente nesta opção estes dois campos estarão preenchidos.
- Depurar Entrada (Debug Entry) – nesta situação o depurador é acionado quando a

execução do programa for interrompida por um ponto de interrupção, gatilho de unidade
de programa, etc.
- Toda Instrução (Every Statement) – faz com que o trecho de PL/SQL seja avaliado antes
de cada linha de PL/SQL da aplicação.
• Unidade de Programa (Program Unit) – identifica a unidade de programa. Nome dado pelo
Forms.
• Linha (Line) – especifica a linha dentro da unidade de programa em que o gatilho foi marcado.
• Corpo do Gatilho (Trigger Body) – especifica o código de PL/SQL para o gatilho.
Quando aceitarmos este diálogo (OK), retornaremos à janela de depuração com a linha selecionada
preenchida com T(01) no lugar do número da linha.

Acompanhando uma Depuração

Para realizarmos um acompanhamento passo a passo da depuração retornaremos à situação em que
utilizamos um ponto de interrupção que contém um texto de código de PL/SQL anexado.
DEPURANDO COM UM PONTO DE INTERRUPÇÃO

Após aceitarmos o diálogo e definirmos a interrupção em uma linha, devemos fechar a janela de
depuração, pressionando o botão Fechar (o ícone é um X em vermelho).
Isto fará com que o controle retorne ao programa normalmente. Devemos, então, forçar a execução da
parte do programa em que marcamos o ponto de interrupção.
Fig. 65 – Depuração com

ponto de interrupção
Na figura 65 podemos verificar que o ponto em que o programa está parado é marcado no Painel de Fonte
com o sinal =>.
O nó Stack contém o valor das variáveis locais deste trecho de código. A variável V1 possui o valor 5. Isto
significa que o código anexado ao ponto de interrupção já foi executado.
Na parte superior da janela encontramos diversos botões, agora habilitados, que nos permitirão executar
uma linha de cada vez. São eles:
• Entrar (Step Into) – esta opção executa cada linha do programa passo a passo. Ocorre a
interrupção a cada comando. Se o código acionar uma unidade de programa esta também é
acompanhada passo a passo.
• Transpor (Step Over) – esta opção também executa cada linha do programa passo a passo,
porém se houver chamada a uma unidade de programa, esta não é detalhada. A subrotina é
executada como se fosse uma linha simples.
• Sair (Step Out) – esta opção é para ser usada dentro de uma unidade de programa chamada,
pois ela termina a unidade de programa atual e retorna a quem a chamou. Se estivermos no
código principal esta opção encerrará a depuração. O trecho de código final é executado.
• Ir (Go) – esta opção encerra a execução passo a passo voltando para a forma normal do
programa. O restante do código é executado.
• Reinicializar (Reset) – esta opção desiste da execução passo a passo. O restante do código
não é executado.

DEPURANDO COM UM TRIGGER

A mesma situação anterior pode ser realizada usando-se o gatilho da figura 59.
Para tal, devemos:
• Marcar o gatilho de acordo com o apresentado na figura 59.

• Seguir a execução do programa, isto é, retornar ao modo de execução.
• Executar a ação que causa a execução da depuração.
• Acompanhar passo a passo a execução da trigger interrompida.
No gatilho criado utilizamos a condição de erro Debug.Break, existente no pacote Debug.
Todas estas formas de interrupção vistas até o momento se perdem quando retornamos ao
desenvolvimento, porque não foram criadas no fonte da aplicação e sim durante a execução.
São pontos de controle temporários.
Se tivermos, porém, um problema mais complexo para analisar desejaremos que o ponto de interrupção
se fixe para que possamos executar mais de uma vez a ação até descobrirmos o problema.
Criando uma interrupção Estática

Na trigger de Key-Down (listagem 21) criamos um ponto de interrupção que não precisará ser definido a
tempo de execução.
DOWN;
FOR I IN 1..10 LOOP
:NR_GIT := :NR_GIT + 1;
IF I >= 7 THEN
DEBUG.SUSPEND;
END IF;
END LOOP;
Listagem 21
Para testá-lo bastará que

executemos a aplicação,
façamos uma consulta e
pressionemos a tecla Seta
para baixo em qualquer item.
Nota
Esta forma de utilização
também pode ser utilizada
com a procedure Break
presente no pacote
Extensões Padrões (já
disponível no Forms 4.5).
Fig. 66 – Depuração Estática
A figura 66 mostra o surgimento do depurador exatamente quando o valor de I é igual a 7.
As demais ações de depuração (acompanhamento passo a passo, avaliação do valor das variáveis, etc)
se desenvolvem da mesma forma que anteriormente.

O Forms Runtime Diagnostics

Este utilitário pode ser usado como auxiliar na depuração de aplicações.
Quando uma aplicação executa com a característica FRD habilitada, é gerado um arquivo contendo ações
internas e ações externas(ações do usuário como por exemplo teclas acionadas) em ordem cronológica
que nos permitirão acompanhamento das ações realizadas.
SINTAXE DE GRAVAÇÃO DAS INFORMAÇÕES

As informações gravadas no arquivo para depuração possuem as seguintes regras:
Para Triggers (de qualquer nível)

<nome do trigger> Trigger Fired:
Form: <nome do Form>
Block: <nome do bloco>
Item: <nome do item>
Listagem 22
Se o trigger estiver incluído a nível de bloco a linha referente ao item não será apresentada. A nível de
Form, as linhas de bloco e item não serão apresentadas.
Além destas informações é apresentado um conjunto de informações sob o título de State Delta (como no
exemplo da listagem 23), onde é apresentado o nome da aplicação, do bloco, do item corrente (se houver),
o estado do Form, do bloco, do registro, o nome de cada item e seu valor.
Este “State Delta” é gravado para o arquivo após o trigger ser acionado. Corresponde a um dump das
informações que tenham sido alteradas desde a ocorrência do estado delta anterior. O primeiro estado
delta faz um dump de todo o Forms para o arquivo.
State Delta:
FORM TESTE_FRD
CURFIELD ""
STATUS QUERY
BLOCK FUNC
STATUS QUERY
RECSTATUS QUERY
FIELD ROWID
VALUE 000000D2.0000.0002
FIELD NM_FUNC
VALUE CRISTINA
Listagem 23
Para Built-ins
Executing <nome da Built-in> Built-in:
In Argument 0 - Type: <tipo do argumento> Value: <valor do argumento>
In Argument 1 - Type: <tipo do argumento> Value: <valor do argumento>
...
Out Argument 0 - Type: <tipo do argumento> Value: <valor do argumento>
...
Listagem 24
Quando uma built-in é executada, são mostrados seus argumentos de entrada e saída incluindo os valores
informados e recebidos, de acordo com o padrão mostrado na listagem 24.

Para Mensagens
Error Message: <mensagem>
Listagem 25
Qualquer mensagem produzida pela opção aparece no arquivo de acordo com o padrão mostrado na
listagem 25.
Para Arquivos
Opened file : <nome do arquivo>
ou
Failed to open file: <nome do arquivo>
Listagem 26
A abertura de arquivos externos é gravada incluindo a indicação de sucesso ou não na abertura.
Exceptions
UNHANDLED EXCEPTION: <NOME DA EXCEPTION>
ou
UNHANDLED EXCEPTION: ORA-<NÚMERO DA EXCEPTION>
Listagem 27
Uma unhandled exception é seguida por um State Delta.
Eventos externos
Os eventos externos efetuados pelo usuário a tempo de execução são registrados precedidos pelo
caracter # seguido de um número que indica a ordem cronológica do evento.
Cada evento contém dois blocos de informação: no primeiro é caracterizado o evento e no segundo o
State Delta.

CONSTRUÇÃO DE UM EXEMPLO
Para verificarmos o conteúdo de um arquivo produzido, criaremos uma aplicação que contenha as colunas
Nm_Func, Cd_Depto, Nr_Ramal, Dt_Adm e In_Sexo, formato tabular com 3 registros na tela.
Para ativarmos esta opção devemos incluir na linha de comando os parâmetros Record=Collect e
Log=<nome de um arquivo>, como apresentado na listagem 28 a seguir.
C:\ORACLE\BIN\IFRUN60.EXE MODULE=TESTE_FRD.FMX
USERID=ALUNO/ALUNO@ORACLE
RECORD=COLLECT LOG=FRD.TXT
Listagem 28
Executamos, então, esta aplicação e efetuamos as seguintes operações:
• Consulta a todos os dados;

• Navegação entre o primeiro item e o segundo;
• Alteração do nome de um dos funcionários.
• Salva e saída da aplicação.
Resultado Gerado
Na listagem 29 apresentamos o trecho final do arquivo gerado.
# 6 - TESTE_FRD:FUNC.NM_FUNC
VALUE TESTE_FRD FUNC NM_FUNC 4 João
# 7 - TESTE_FRD:FUNC.NM_FUNC - MENU
FORM TESTE_FRD
STATUS CHANGED
BLOCK FUNC
STATUS CHANGED
RECSTATUS CHANGED
END
MENU DEFAULT Ação Salvar
Error Message: FRM-40400: Transação completa: 1 registros aplicados e

salvos.
# 8 - TESTE_FRD:FUNC.NM_FUNC - MENU
FORM TESTE_FRD
STATUS QUERY
BLOCK FUNC
STATUS QUERY
RECSTATUS QUERY
END
MENU DEFAULT Ação Sair
Listagem 29
No registro 6 encontramos a modificação do item nm_func.
No primeiro registro 7 encontramos o State Delta indicativo do estado em que o registro ficou após a
modificação. No segundo registro 7 encontramos a execução da ação Salvar presente no submenu Ação
do menu padrão (Default).
Em seguida encontramos a mensagem fornecida pelo programa e o State Delta posterior à gravação.
Finalmente no registro 8 encontramos a última ação executada (Sair do submenu Ação do menu Default).

CAPÍTULO 14: PACOTES, VBX, OCX E OLE
VBX ,OCX e OLE

A tecnologia Object Linking and Embedding (OLE) foi criada a fim de permitir que em um único documento
tivéssemos acesso a informações de diferentes aplicações (por exemplo no Form acesso à calculadora do
Windows ou ao Word).
Esta forma de trabalho resolvia parte dos problemas de integração, pois permitia a utilização de objetos de
diferentes aplicações em um único documento.
Esta tecnologia foi estendida para uma maior interface e compartilhamento de serviços, passando a se
chamar Component Object Model (COM) conhecida como OLE2.
Hoje ActiveX substitui OLE como o termo indicativo de tecnologia baseada em COM. OLE voltou a ser
considerado apenas Object Linking and Embedding em documentos.
Controles ActiveX, originalmente conhecidos como controles OLE ou OCX fazem uso de ambas as
tecnologias ActiveX e OLE.
Um controle ActiveX é um componente padrão de software que fornece uma interface para o usuário e
envia eventos de acordo com os padrões definidos pelo COM.
Ele é uma aplicação OLE Server inteiramente embutida em uma aplicação com capacidades de OLE
cliente.
OLE, OCX E VBX NO FORM BUILDER

O Form Builder fornece suporte a controles ActiveX. Ele age como um ActiveX Control Container.
Um item do tipo ActiveX cria um container para o controle ActiveX. O controle não é uma aplicação em
separado, devemos considerá-la como um serviço ligado (conectado, plugado) a um ActiveX container
(que é o nosso item).
Cada controle ActiveX possui um conjunto de propriedades, métodos e eventos que caracterizam lógica e
fisicamente o controle e permitem que executemos ações e percebamos alterações na situação do
controle.
Uma aplicação cliente manipula um controle ActiveX fazendo acesso diretamente a suas propriedades
(obtendo e modificando), acionando métodos e interceptando ou causando eventos.
Um arquivo OCX é uma biblioteca. Pode conter uma ou mais classe de objetos ActiveX. Um VBX é similar
a um OCX em muitos aspectos:
• Um arquivo VBX pode conter diversos controles.

• Um VBX é desenvolvido por terceiros e podemos anexá-los em nossas aplicações para suprir
ou adicionar funcionalidade à nossa aplicação.
• Cada controle contém propriedades, métodos e eventos para que possamos efetuar a
manipulação de suas características e ações.
O que fundamentalmente muda de um para o outro é a tecnologia, ActiveX é baseado no modelo COM.
Como restrição para os controles VBX (no Form Builder) temos que um controle VBX funciona
estritamente em aplicações 16 bits, não funciona sob um ambiente 32. Podemos, porém fornecer a mesma
funcionalidade de um controle VBX em um ambiente de 32 bits ao utilizarmos OCX.
Este tipo de tecnologia pode tornar uma aplicação Form altamente sofisticada e complexa. Necessita,
porém de um pleno conhecimento das propriedades, métodos e eventos dos objetos que viermos a anexar
à aplicação.
CAPÍTULO 14: PACOTES, VBX, OCX E OLE - 118

VBX
Infelizmente não poderemos fazer um exemplo que execute perfeitamente, pois, o nosso ambiente é de 32
bits (Windows95), porém podemos estudar a nível teórico e mostrar onde podemos interferir.
A interface de um VBX em uma aplicação Form é feita através de um item do tipo VBX. No conjunto de
propriedades deste item é que preenchemos as informações necessárias para que o Form Builder faça a
ligação com o controle desejado.
Na paleta de propriedades deste tipo de item, no grupo funcional, encontraremos as seguintes

propriedades (Windows 3.11):
• VBX Control File – onde definiríamos o nome do arquivo físico cuja extensão é VBX.
• VBX Control Name – onde definiríamos o nome do controle pertencente ao arquivo VBX que
desejaríamos usar.
• VBX Control Value – onde definiríamos o nome da propriedade do controle que é a

responsável pelo armazenamento do valor.
Estas propriedades não estão visíveis no conjunto de propriedades no item criado, provavelmente pelo fato
de estarmos em um ambiente de 32bits. Se você estiver num ambiente de 16-bits (Windows 3.11),
provavelmente encontrará as propriedades referenciadas aqui.
Na propriedade VBX Control Value devemos indicar o nome da propriedade do controle que recebe o valor
do item. É desta forma que poderemos atribuir valor ao item, como fazemos com os demais itens em
PL/SQL.
Suponhamos, então que tivéssemos um item do tipo VBX chamado IVBX.
Se desejássemos atribuir um valor a este item faríamos: “:IVBX := 30;”.
Esta é a sintaxe padrão da PL/SQL. O controle, no entanto, precisa que o valor seja atribuído à
propriedade “TEXT” (por exemplo), sendo assim, preencheríamos a propriedade VBX Control Value com o
valor “TEXT”.
Desta forma, quando executarmos o comando de atribuição na PL/SQL o Form faz a atribuição à
propriedade “TEXT” do controle.
Além das propriedades no Forms, o controle possui suas próprias propriedades, métodos e eventos.
A manipulação deste item é feita com o uso do pacote VBX, que possui :
• Rotinas para manipulação de propriedades: Get_Property, Get_Value_Property, Set_Property

e Set_Value_Property.
• Rotina para acionamento de métodos: Invoke_Method.
• Rotina para disparo de eventos: Fire_Event.
Para que o item VBX fique sensível a um evento causado, devemos criar um trigger (em qualquer nível),
chamado When-Custom-Item-Event que será causado todas as vezes que um evento do controle for
causado.
Para sabermos qual o evento e, termos condições de tomar as medidas adequadas, devemos utilizar a
variável de sistema System.Custom_Item_Event que identificará o evento acionado.

OLE CONTAINER
Este item implementa um controle container de objetos, ou seja, um controle que poderá receber objetos
dentro dele.
Este item armazena objetos de uma das categorias OLE registradas no Windows (por exemplo uma
planilha do Excel, documento do Word, figura do PaintBrush ou qualquer objeto de uma aplicação que
implemente OLE como Server).
Estes objetos armazenados no item da aplicação podem ser de dois tipos:
• Embedded – quando o objeto estiver armazenado internamente. Este armazenamento poderá

ser no próprio Form (FMB ou FMX) ou em uma coluna do banco de dados.
• Linked – quando o objeto estiver num arquivo em disco independente do Form ou do banco
de dados. Dentro da aplicação (ou da coluna do banco de dados) estão armazenadas apenas
as informações de identificação do objeto.
Para estudarmos estas características básicas devemos analisar as propriedades de um item deste tipo.
No grupo funcional, encontraremos:
• Ativado (Enabled) - indica se o objeto poderá receber foco, seja através da navegação
padrão (tecla TAB) ou através de rotinas pré definidas (Next_Item, Go_Item, etc).
• Classe OLE (OLE Class) – indica a classe do objeto. Se deixarmos esta propriedade sem
valor (Null), podemos inserir qualquer tipo de objeto registrado por uma aplicação OLE Server
instalada no computador. Se preenchermos com algum valor somente objetos com a classe
especificada poderão ser inseridos neste container.
• Estilo de Ativação de OLE (OLE Activation Style) – aqui definiremos qual o evento que
acionará o objeto OLE. As opções válidas são:
- Click Duplo (Double Click) – esta é a forma de ativação default.

- Focado (Focus-in) – quando ocorrer a navegação para o item, o objeto OLE se tornará
ativo.
- Manual – para que o objeto OLE se torne ativo o usuário deverá usar o botão direito do
mouse sobre o objeto e escolher a opção Editar (Edit) ou Abrir(Open). Para que isto seja
possível, a propriedade Mostrar Menu Pop up de OLE (Show OLE Popup Menu) deve ser
preenchida com Sim (True) e o item deve estar visível(visible) e ativado (enabled).
• Ativação Local de OLE (OLE In-place Activation) – especifica se a ativação será local, isto
é, se o PaintBrush(por exemplo) será ativado dentro do espaço delimitado pela definição do
item na Canvas. Se preenchermos com Não, o PaintBrush (por exemplo) abrirá uma outra
janela para que o usuário possa desenhar.
• Suporte Interno-Externo de OLE (OLE Inside-Out Support) – esta propriedade só é válida

para ativação In-Place, isto é quando a ativação do objeto é dentro dos limites da dimensão do
item na Canvas. Ela especifica se, nesta situação, pode abrir mais de um objeto
simultaneamente (do mesmo tipo). Quando trabalhamos com Word ou Excel, é comum
abrirmos mais de um documento simultaneamente.

• Tipos de Inquilinos de OLE (OLE Tenant Types) – Esta propriedade identifica os tipos de
objetos que podem ser inseridos, ou seja inquilinos do item OLE Container. Os valores válidos
são:
- Qualquer (Any) – é a opção default. Qualquer objeto OLE pode ser residente do
Container.
- Nenhum (NONE) – nenhum objeto pode ser residente do Container.
- Estático (STATIC) – somente objetos OLE estáticos podem ser residentes. Um objeto
OLE estático é uma imagem congelada de um objeto Linked cuja ligação foi perdida de
sua origem. Este tipo de objeto não pode ser modificado.
- Embutido (Embedded) – somente um objeto OLE embutido pode ser residente.
- Ligado (LINKED) – somente um objeto Linked pode ser residente.
• Mostrar Tipo Inquilino de OLE (Show OLE Tenant Types) – determina se uma borda em
torno do OLE deve ser apresentada. O tipo de borda varia de acordo com o tipo de objeto.
• Aspecto Inquilino de OLE (OLE Tenant Aspect) – indica o aspecto (aparência) do objeto
OLE no Container (item). As opções válidas são :
- Conteúdo (Content) – o conteúdo do objeto é mostrado no item.

- Ícone (Icon) – um ícone do objeto é mostrado no item.
- Pré-Visualização de Miniatura (Thumbnail) – uma visão reduzida do objeto é
apresentada.
• Estilo de Redimensionamento de OLE (OLE Resize Style) – indica como o objeto OLE será
mostrado na área reservada para ele (quando ativo). Os valores válidos são:
- Corte (Clip) – É apresentada uma parte do objeto. Ele é cortado. A navegação é feita com
barra de rolagem.
- Escala (Scale) – O objeto é escalado.
- Inicial (Initial) – O objeto é redimensionado a tempo de criação.
- Dinâmico (Dynamic) – O objeto é redimensionado toda vez que seu tamanho muda.
• Mostrar Menu Pop up de OLE (Show OLE Popup Menu) – indica se um menu (apresentado
com o botão direito do mouse) deve ou não ser apresentado para o Container (Item). As ações
deste menu estão ligadas ao OLE Server.
• Itens de Menu Pop up de OLE (OLE Popup Menu Items) – nesta opção poderemos definir
quais as ações pré – definidas desejamos habilitar. Quando selecionarmos esta opção será
apresentada uma lista para que indiquemos para cada item da lista se ele estará ativo e
habilitado.
Podemos, também, fazer a manipulação de um item do tipo OLE por programação. O Form Builder possui
um pacote chamado Forms_Ole para executar determinadas ações:
• rotinas para manipulação do OLE Server – Active_Server (ativá-lo), Server_Active (para

verificar se está ativo), Close_Server (encerrar o OLE Server).
• rotinas para manipulação de ações (da lista de ações disponíveis no menu popup) –
Exec_Verb (executar uma ação específica), Get_Verb_Count(para obter a quantidade de
ações disponíveis), Get_Verb_Name(para obter o nome do verbo ou da ação em função de um
indexador seqüencial), Find_OLE_Verb (retorna o índice em função do nome do verbo).
• rotina para inclusão de um objeto no Container – Initialize_Container.

OCX (ACTIVEX CONTROL)

Já vimos anteriormente que o Form Builder suporta ActiveX e que esta é a forma atual para interface com
objetos externos ao Forms.
As interfaces VBX e OLE Container estão mantidas em função de versões anteriores do produto, mas num
ambiente 32-bits passaremos a trabalhar com a interface OCX.
Para incluirmos um objeto OCX em nossa aplicação, devemos:
• Passo 1 - Criar o item OCX ,no navegador ou diretamente na Canvas.
A Oracle recomenda que este item seja criado em um bloco single-record para que sua
inicialização ocorra tão logo o foco recaia sobre o bloco.
Se o criarmos em um bloco multi-record somente a primeira instância do objeto é inicializada

(como ocorre com os itens, de um modo geral). Se a criação for feita no navegador, você deverá
modificar a propriedade de tipo do item para Controle X Ativo (ActiveX Control) e preencher a
canvas correspondente.
• Passo 2 - Inserir um objeto dentro deste Container (como fizemos com o item OLE).
No editor de Layout, devemos pressionar o botão direito do mouse e selecionar a opção Insert
Object. A partir da lista apresentada escolher um item.
• Passo 3 - Identificar a classe dos objetos residentes neste Container.
Na paleta de propriedades devemos expandir o grupo Funcional e selecionar a propriedade Classe

OLE (OLE Class). Será apresentada uma lista de
classes.
• Passo 4 - Os controles ActiveX exportam interfaces

que discriminam os métodos e eventos do objeto.
No Form Builder podemos (e devemos) importar os

métodos e eventos na PL/SQL, para que possamos
interagir com o controle no ambiente do Forms.
Para realizar esta tarefa devemos utilizar o menu

Programa (program), opção Importador de OLE (OLE
Importer). Se estivermos com o objeto selecionado, na
janela superior já aparecerá apenas a classe de OLE do
nosso objeto.
Nas janelas inferiores serão mostrados os métodos e os

eventos associados ao objeto.
Fig. 67 – Importar Interface OLE
• Passo 5 - preencher as propriedades do objeto criado.
A propriedade do grupo Funcional chamada Propriedades de Controle (Control Properties) quando

selecionada deve mostrar um diálogo para que possamos definir as propriedades adequadas para
o objeto.
Se esta opção falhar, deveremos atribuir as propriedades por programação.
Para, mais facilmente, sabermos os nomes das propriedades e sua utilidade, devemos selecionar
a propriedade Ajuda de Controle (Control Help), no grupo Funcional. Esta propriedade acionará o
Help do fabricante do controle. Devemos, então, procurar o texto de ajuda relativo ao controle
incluído.

-- Primeira forma de atribuição/obtenção do valor das propriedades

:item('spin').OCX.forms.spinbutton.1.max := 5;
:item('spin').OCX.forms.spinbutton.1.min := 1;
:item('spin').OCX.forms.spinbutton.1.value := 1;
-- Segunda forma de atribuição/obtenção do valor das propriedades

message(to_char(:form.cursor_item.OCX.forms.spinbutton.1.max));
message(to_char(:form.cursor_item.OCX.forms.spinbutton.1.min));
message(to_char(:form.cursor_item.OCX.forms.spinbutton.1.value));
-- Terceira forma de atribuição/obtenção do valor das propriedades

Listagem 30 - código para atribuir ou alterar o valor de uma propriedade
A primeira forma utiliza a sintaxe “:item(‘<nome do item>’).OCX.<nome do OLE Server>.<nome da

propriedade>”. No nosso caso o nome do OLE Server é Forms.SpinButton.1 (classe do objeto).
A segunda forma sintática é a seguinte “:form.cursor_item.OCX.<nome do OLE Server>.<nome da

propriedade>”. Para que esta sintaxe funcione o objeto OCX tem de estar com o foco.
A terceira forma sintática é montada pelo Form Builder dentro dos pacotes adicionados à
aplicação. No nosso caso específico o pacote adicionado contém apenas referência aos eventos e
não às propriedades.
• Passo 6 - escrever o código de PL/SQL apropriado para acionar o objeto.
• Passo 7 – criar o trigger On-Dispatch-Event para controlar os eventos do objeto.
Este trigger (On-Dispatch-Event) será acionado se algum dos eventos do objeto for acionado.
Quando criarmos este gatilho. O Form Builder, automaticamente, o preenche com uma lista dos
possíveis eventos associados a este objeto, se o trigger for criado a nível de item.
Se este gatilho for criado a nível de bloco ou de módulo o preenchimento deve ser manual.
No nó Unidades de Programa (Program Units) que encontraremos um conjunto de pacotes. Estes

pacotes são dependentes do tipo de objeto criado. A criação do pacote se dá no momento que
importamos os métodos, eventos e propriedades do objeto.
Na trigger On-Dispatch-Event modificamos o código criado pelo Form Builder e acrescentamos o

trecho apresentado na listagem 31.
ELSIF eventname = 'EVENT4294966692' THEN

-- Code for KeyUp
NULL;
if :item('spin').OCX.forms.spinbutton.1.value between 1 and 5 then
:nr_git := nvl(:nr_git, 0) + 1;
message (to_char(:item('spin').OCX.forms.spinbutton.1.value));
end if;
-- Code for SpinDown
NULL;
ELSE
message('Unknown Event: ' || eventname);
end if;
Listagem 31
A propriedade básica do controle Spin é a propriedade Value. Cada vez que pressionamos o botão
da direita o valor desta propriedade é adicionado de 1 e cada vez que pressionamos o botão da
esquerda a propriedade Value é subtraída de 1. Os valores mínimo e máximo são fornecidos pelas
propriedades Min e Max, que nós atribuímos 1 e 5 respectivamente. Assim sendo enquanto o
botão for sendo acrescido, fizemos uma adição ao item da canvas nr_git e da mesma forma
quando este foi sendo decrementado.
Para a utilização de um objeto OCX é indispensável que você conheça bem o que faz o objeto que
você incluiu na sua aplicação.

Pacotes Embutidos
Falaremos, agora, nos pacotes que aparecem sob o nó Pacotes Embutidos (Built-in Packages).
Conheceremos o objetivo de todos eles, mas exemplificaremos apenas alguns.
STANDARD EXTENSIONS
Este é o pacote que contém as rotinas básicas para utilização dentro de uma aplicação Forms.
Com ele podemos alterar as propriedades de um objeto (item, janela, canvas, etc), obter propriedades,
navegar na aplicação e muitas outras funcionalidades, algumas delas já utilizadas ao longo dos exemplos
e exercícios.
DDE
Este pacote permite a utilização do suporte a Dynamic Data Exchange (DDE) dentro dos componentes do
Oracle Developer 6.
DDE é um mecanismo pelo qual aplicações podem se comunicar e trocar dados em um ambiente
Windows.
As funções DDE habilitadas para as aplicações Oracle (Client) se comunicarem com outras aplicações do
ambiente Windows compatíveis com DDE (Server) compreendem 3 ações:
• Importação de dados.
• Exportação de dados.
• Execução de comandos para o servidor DDE (a outra aplicação).
DEBUG
O pacote Debug oferece um conjunto de rotinas, funções e condições de erro para realizarmos depuração
em aplicações Forms.
OLE2
Conjunto de rotinas PL/SQL APIs para criação, manipulação e acesso a tributos de objetos OLE2
Automation.
Os objetos OLE2 Automation encapsulam um conjunto de atributos e métodos que podem ser
manipulados ou invocados de um OLE2 Automation Client. O pacote OLE2 permite que façamos acesso
aos objetos OLE2 Automation Servers diretamente do PL/SQL.
ORA_FFI
Este pacote provê uma interface de uso de funções C (terceira geração) diretamente dentro do PL/SQL.
No ambiente Windows as funções externas devem ser DLLs que, depois de registradas via funções
ORA_FFI podem ser usadas em uma aplicação Forms.
Para utilização de uma DLL em uma aplicação Forms, devemos:
• usar a função Load_Library para obter um handle da DLL, ou seja, uma identificação física
(nome diretório, etc).
• usar a função Register_Function para obter um handle da função, ou seja, uma identificação
no ambiente da função (C) a ser usada. Deve-se especificar o nome da função e sua
localização (o handle da DLL).
• usar a função Register_Parameter para registrar cada parâmetro e estabelecer a paridade com
os tipos de parâmetro da PL/SQL.
• usar a função Register_Return para registrar o tipo de retorno da função C e estabelecer a

paridade com o equivalente PL/SQL.

ORA_NLS
Este pacote permite que obtenhamos informações sobre o ambiente corrente.
DECLARE
ALERTA ALERT := FIND_ALERT('ALERTA');
BOTAO NUMBER;
BEGIN
IF NOT ORA_NLS.AMERICAN_DATE THEN
CHANGE_ALERT_MESSAGE(ALERTA, 'Formato local da data : '||
ORA_NLS_GET_LANG_STR(ORA_NLS.LOCAL_DATE_FMT));
BOTAO := SHOW_ALERT(ALERTA);
END IF;
CHANGE_ALERT_MESSAGE(ALERTA, 'Linguagem : '||
ORA_NLS_GET_LANG_STR(ORA_NLS.LANGUAGE));
CHANGE_ALERT_MESSAGE(ALERTA, 'Território : '||
ORA_NLS.GET_LANG_STR(ORA_NLS.TERRITORY));
END;
Listagem 32
Na listagem 32 utilizamos duas rotinas do pacote Ora_Nls: a função American_Date, que retorna um
boleano indicando se o formato de data corresponde ao padrão americano e a função Get_Lang_Str que
pode fornecer diversas características do ambiente, tais como o nome da linguagem, do território, do
character set, abreviaturas de dias, de meses, etc.
O parâmetro recebido por esta rotina corresponde a uma constante definida no pacote. Os nomes e
significados destas constantes estão na a ajuda do Form Builder sob o título Ora_Nls Character Constants.
ORA_PROF
Este pacote contém procedimentos, funções e condições de erro que nos permitirão verificar o tempo de
execução de uma determinada unidade de programa.
DECLARE
BOTAO NUMBER := 0;
TEMPO NUMBER;
BEGIN
ORA_PROF.CREATE_TIMER('TEMPO');
ORA_PROF.START_TIMER('TEMPO');
FOR I IN 1..10000 LOOP
BOTAO := BOTAO + 1;
END LOOP;
ORA_PROF.STOP_TIMER('TEMPO');
TEMPO := ORA_PROF.ELAPSED_TIMER('TEMPO');
ORA_PROF.DESTROY_TIMER('TEMPO');
CHANGE_ALERT_MESSAGE(ALERTA, 'Tempo transcorrido : '||TEMPO);
END;
Listagem 33
Na listagem 33 decidimos determinar o tempo total de somar 1 a uma variável 10000 vezes. Para isto
criamos o timer, iniciamos a contagem (start), executamos a operação desejada, interrompemos a
contagem (stop), destruímos a área de contagem do tempo e obtivemos o valor do tempo transcorrido
(retornado em milisegundos).
Poderíamos criar este controle no início da aplicação e contabilizar diversas ações internas que
julgássemos muito demoradas. Para reinicializar o contador de tempo devemos usar a rotina Reset_Timer
deste pacote.

TEXT_IO
Este pacote permitirá que venhamos a ler ou gravar informações para um arquivo do ambiente. É
equivalente ao pacote Utl_File da PL/SQL, com a diferença que o arquivo lido ou gravado se encontra no
ambiente cliente.
DECLARE
ARQ TEXT_IO.FILE_TYPE;
BUFFER VARCHAR2(1000);
BEGIN
ARQ := TEXT_IO.FOPEN('C:\TESTE\SAIDA.TXT', 'A');
FIRST_RECORD;
LOOP
BUFFER := LPAD(:CD_MAT, 3) || RPAD(:NM_FUNC,12) ||
LPAD(:NR_CARGO,3)|| LPAD(:NR_GIT,3);
TEXT_IO.PUT_LINE(ARQ, BUFFER);
IF :SYSTEM.LAST_RECORD = 'TRUE' THEN
EXIT;
END IF;
NEXT_RECORD;
END LOOP;
TEXT_IO.FCLOSE(ARQ);
END;
Listagem 34
A listagem 34 nos mostra a criação de um arquivo com o nome de saída com todos os registros que
estiverem no buffer naquele momento.
É executada a rotina First_Record (do pacote Standard) para que seja feito o posicionamento do cursor no
primeiro registro e a cada registro navegado é feita a gravação no arquivo até que a variável de sistema
Last_Record (é uma variável caracter, não é boleana) indicará se atingimos o último registro do buffer.
Após a gravação deste últimos registro, então, fechamos o arquivo.
TOOL_ENV
Permite que obtenhamos informações das variáveis de ambiente do Oracle.
DECLARE
BUFFER VARCHAR2(1000);
TEXTO VARCHAR2(1000);
BOTAO NUMBER;
BEGIN
TOOL_ENV.GETVAR('ORACLE_HOME', BUFFER);
TEXTO := BUFFER || '; ';
TOOL_ENV.GETVAR('ORACLE_SID', BUFFER);
TEXTO := TEXTO || BUFFER || '; ';
TOOL_ENV.GETVAR('NLS_LANG', BUFFER);
TEXTO := TEXTO || BUFFER || '; ';
CHANGE_ALERT_MESSAGE(ALERTA, TEXTO);
END;
Listagem 35
Na listagem 35 utilizamos a única rotina do pacote, na qual solicitamos o nome de algumas variáveis do
ambiente.
Podemos ver o nome destas variáveis no registrador do Windows com o RegEdit (nó
Hkey_Local_Machine, subnó Software, subnó Oracle).
A rotina permite a obtenção destas informações dinamicamente.

TOOL_ERR
O pacote Tool_Err fornece um conjunto de informações a respeito do erro acontecido em uma área
chamada “Error Stack”. Esta área contém códigos e mensagens de erro organizadas em uma área
indexada de 0 a n-1 (onde n é o número de erros). Este pacote permitirá a manipulação desta área de
stack.
Não desenvolveremos exemplos com este pacote. Para maiores informações utilize a ajuda do Form
Builder para exemplos e forma de utilização.
TOOL_RES
Este pacote fornece um mecanismo para extrairmos informações de um arquivo de recursos.
Os arquivos de recursos são providos pelas ferramentas (Form Builder, Report Builder, etc) e contém
informações diversas utilizadas pelos softwares.
Podemos gerar nossos próprios arquivos de recursos com o utilitário ResPa21 a partir de um texto com
extensão PRN. Este utilitário é fornecido juntamente com o Oracle*Terminal.
PECS
Este pacote fornece ao desenvolvedor ou ao administrador do sistemas meios de análise da performance
tanto do Form Builder quando das aplicações geradas.
VBX
Este pacote contém um conjunto de rotinas relacionadas à interface com controles VBX, que podem ser
anexadas a uma aplicação de 16-bits.
WEB
Este pacote, composto por uma única rotina, tem a finalidade de definir a URL do documento a ser
carregado em aplicações Web.
FORMS_OLE
Este pacote contém um conjunto de rotinas para acionamento e manipulação de um item do tipo OLE
Container.
STANDARD
Este pacote é utilizado implicitamente por nós todas as vezes que trabalhamos com PL/SQL, corresponde
ao conjunto de rotinas de PL/SQL válidas no ambiente.
Está sendo utilizado em praticamente todos os exemplos e exercícios vistos até agora.

CAPÍTULO 15: CARACTERÍSTICAS GERAIS
Estudando o Módulo
Neste capítulo estudaremos as propriedades da aplicação como um todo. Algumas das propriedades
apresentadas já foram comentadas em outros níveis. As informações que estabelecermos a nível de
módulo podem vir a funcionar como default.
No grupo funcional vemos diversas propriedades relativas a menu. São elas: Origem de Menu (Menu
Source), Módulo de Menu (Menu Module), Menu Inicial (Initial Menu), Estilo de Menu (Menu Style).
Estas propriedades têm o objetivo de definir qual o menu a ser utilizado com a aplicação atual. Até o
momento trabalhamos sempre com o menu padrão do Form (Default&SmartBar). Quando criarmos nosso
próprio menu voltaremos a estudar estas propriedades com mais detalhes.
As demais propriedades deste grupo são:
• Janela Console (Console Window) – indica o nome da janela em que serão mostradas as
mensagens e a linha de status.
No Microsoft Windows, a janela de console é sempre a MDI, ou seja, a janela do Form Runtime.
No entanto, devemos deixar esta propriedade preenchida se quisermos manter a informação
visível. Caso contrário podemos atribuir Null.
• Diferir Imposição Obrigatória (Defer Required Enforcement) – esta propriedade afeta o

modo como a aplicação fará validação.
Se a preenchermos com Sim (Yes), para todos os itens que possuam a propriedade Obrigatório
(Required) preenchida com Sim (Yes), haverá o adiamento da validação até que ocorra a
validação do registro.
Isto modifica a funcionalidade default relativa a validação que ocorre tão logo ocorra a navegação
para fora daquele item. Quando marcamos esta propriedade o usuário poderá navegar livremente
entre os itens, sendo a verificação de preenchimento verificada apenas a tempo de validação de
registro.
No grupo Navegação, temos as propriedades:
• Limite de Navegação do Mouse (Mouse Navigation Limit) – que indica qual ação de
navegação o usuário poderá fazer com o mouse. Os valores válidos são:
- Form - permite ao operador navegar para qualquer item no Form corrente, mudando de
bloco, de registro, etc com o mouse.
- Bloco de Dados(Data Block) - permite ao operador navegar para qualquer item dentro de
um mesmo bloco, não é possível a troca de bloco com o mouse.
- Registro(Record) - neste caso o usuário poderá navegar apenas entre itens de um

mesmo registro; não é possível a troca de registros com o mouse.
- Item - esta opção impede que o usuário navegue para fora do item com o mouse, ou seja,
impede o uso do mouse.
• Primeiro Bloco de Dados de Navegação (First Navigation Block) – nesta propriedade

indicamos qual o primeiro bloco da seqüência de navegação.
Se esta propriedade não for preenchida, será utilizada a seqüência do Navegador. Podemos modificar
esta propriedade a tempo de execução até a trigger When-New-Form-Instance, antes da navegação
para o primeiro bloco ocorrer.
CAPÍTULO 15: CARACTERÍSTICAS GERAIS - 128

No grupo Registros encontramos a propriedade Grupo de Atributos Visuais do Registro Corrente (Current
Record Visual Attribute Group), que funciona como um valor default para os níveis inferiores.
No grupo Database temos:
• Unidade de Validação (Validation Unit) – esta propriedade determina quando os eventos de

validação serão acionados durante o processamento default.
Indica o que o usuário poderá digitar antes de iniciar o processo de validação. O default é Item, ou
seja, o usuário poderá digitar o texto de um item. Tão logo ele navegue para outro haverá o
disparo dos eventos de validação.
• Modo de Interação (Interaction Mode) – esta propriedade determina qual o comportamento

do Form durante uma interação com o banco de dados. Se o valor for preenchido com
Bloqueio (Blocking), todos os registros da consulta deverão ser lidos (Fetched) do banco de
dados antes dos usuários poderem interagir com o Form ou qualquer outra aplicação. Será
mostrado um diálogo que permitirá ao usuário cancelar a consulta.
As propriedades Tempo máximo para Consulta (Maximum Query Time) e Máximo de Registros
Extraídos (Maximum Records Fetched) quando declaradas a nível de Form funcionam como um
valor default.
• Modo de Isolamento (Isolation Mode) – Esta propriedade indica se as transações serão ou

não realizadas em série (Serializable – Serializável).
Com esta opção é possível a execução de leituras repetidas (repeatable reads) e obtenção dos
mesmos resultados. Ela não é recomendada para ambientes de alta concorrência. O valor default
é Submetido a Commit de Leitura (Read Committed), o que indica que em uma leitura consistente
serão vistas todas as modificações Commited antes do início da leitura e todas as modificações
realizadas pela transação atual.
O último grupo das propriedades do módulo é chamado de Físico e contém:
• Sistema Coordenado(Coordinate System) – indica a unidade de trabalho no Form, que pode

ser Caracter ou Real (ponto, píxel, centímetro, etc).
As propriedades Canvas da Barra de Ferramentas Horizontal (Form Horizontal ToolBar Canvas) e

Canvas da Barra de Ferramentas Vertical (Form Vertical ToolBar Canvas) indicam o nome da
canvas que será a barra de ferramentas vertical ou horizontal da janela MDI.

Preferências
Para obtermos as preferências do Form Builder, devemos escolher o menu Ferramentas e neste a opção
Preferências.
Será apresentado um diálogo composto de 4 pastas que estudaremos separadamente.
PASTA GERAL
A pasta Geral contém características que afetam a salva e compilação dos módulos desenvolvidos
utilizando este Form Builder.
Fig. 68 – Preferências
(Pasta Geral)
Na figura 68 encontramos as seguintes opções:
• Salvar Antes de Desenvolver (Save Before Building) – esta opção, se marcada, indica que
antes de gerar um FMX, o Form Builder deverá salvar o fonte da aplicação.
• Desenvolver Antes de Executar (Build Before Running) – esta opção, se marcada, indica
que quando solicitarmos a execução da aplicação o Form Builder deverá, automaticamente,
gerar o FMX. Esta opção, porém, não compila automaticamente nem Menus e nem Bibliotecas
(Libraries) associadas ao módulo. Esta compilação deve ser feita em separado.
• Suprimir Dicas (Suppress Hints) – indica se os hints (dicas) serão mostradas ou não na linha
de mensagem no Form Builder.
• Executar Módulos Assincronamente (Run Modules Asynchronously) – esta opção quando

marcada indica que quando executamos um módulo podemos deixar a janela de execução
(Form Runtime) ativa e retornar ao Form Builder. Se esta opção estiver desmarcada só
poderemos retornar ao Form Builder se encerrarmos o Form Runtime.
• Usar Editor do Sistema (Use System Editor) – esta opção determina se o Form Builder deve
apresentar seu editor default ou o editor default do sistema quando acionarmos o editor de um
campo multi-line.
• Paleta de Cores(Color Palette) – indica o nome da paleta de cores que deve ser carregada
quando criamos uma nova aplicação. Se esta opção estiver em branco será carregada a
paleta de cores default do Form. A extensão de uma paleta de cores é Pal.
• Impressora (printer) – determina a impressora default.

• Modo das Cores (Color Mode) – esta opção determina como será feita a carga da paleta de
cores para a aplicação. Quando criamos ou abrimos ou carregamos uma aplicação a paleta de
cores associada a ela é carregada na tabela de cores do sistema. Como esta tabela possui
uma quantidade de espaços limitado, o Form Builder pode encontrar dificuldade em dar
manutenção a aplicações utilizando diferentes paletas. Os valores válidos para esta opção
são:
- Editável (Editable) – indica que desejamos editar, ou seja, criar nossas próprias
combinações de cores.
Quando a propriedade Color Mode está preenchida com este valor a paleta de cores fica
vulnerável a modificações, da nossa parte e involuntariamente em função da necessidade de
carga de uma nova paleta.
Somente devemos utilizá-la quando desejarmos fazer uma modificação na paleta. Ao término
devemos retornar ao estado normal, que é Read Only – Shared. Para que esta opção tenha
efeito devemos salvar as preferências e fechar o Form Builder.
Ao ativarmos novamente o Form Builder, devemos acionar o Editor de Layout e usar no menu
Formato (Formato), opções de Layout (Layout Options), Paleta de Cores (Color Palette).
O Form Builder utiliza uma paleta de cores padrões cujo arquivo se chama default.pal com as
seguintes características:
A primeira parte da paleta (região superior esquerda) é composta de 16 cores básicas

nomeadas como:
black white green darkgreen

gray darkgray cyan darkcyan
red darkred blue darkblue
yellow darkyellow magenta darkmagenta
Tabela 10 – Cores Básicas
A segunda parte da paleta (região inferior esquerda) é composta de 8 células vazias em que
podemos definir cores customizadas.
As próximas 5 colunas são compostas de variações de cinza. Cada cor tem o formato
‘gray<valor>’, onde o valor varia de acordo com a percentagem de cinza. Os valores válidos
estão no intervalo de 4 a 96, com incremento de 4. Por exemplo: ‘gray4’, ‘gray8’, ‘gray12’,
‘gray16’, ‘gray20’, ‘gray24’, ‘gray28’, ‘gray32’, ...., ‘gray96’.
O restante da paleta de cores contém cores especificadas por variações percentuais das cores
vermelha, verde e azul (RGB). Sendo que os valores percentuais para vermelho ou verde são:
0, 25, 50, 75, 88 ou 100, enquanto que os valores percentuais para a cor azul são: 0, 50, 75,
88 ou 100.
Cada cor é nomeada de acordo com o formato: ‘r<valor>g<valor>b<valor>’ de acordo com

seus valores RGB. Por exemplo uma cor composta de 100% de vermelho, 88% de azul e 0%
de verde teria o nome: ‘r100g0b88’.
Para sabermos o nome de uma determinada cor basta que a selecionemos na paleta.

Para editar uma cor, selecione uma das cores na parte vazia (branca), click sobre o botão
editar. Será apresentado um diálogo com cores básicas e matizes. Selecione uma cor básica,
varie seu matiz, saturação e luminosidade, clique sobre o botão Adicionar Cores
Personalizadas e dê OK. A cor definida ocupará a posição selecionada inicialmente na tabela.
Salve esta nova paleta de cores (Menu Arquivo – File, opção Exportar - Export, Paleta de
Cores – Color Palette), volte ao modo Read Only – Shared, preencha o nome do novo arquivo
na opção Paleta de Cores, feche o Form Builder e torne a abri-lo com esta nova paleta.
• Somente Leitura – Compartilhado (Read Only – Shared) – nesta opção ao fazer a carga da
paleta de cores para a tabela de cores do sistema o Form Builder verifica através do nome se
uma determinada cor já existe na tabela de cores do sistema para fazer o posicionamento
similar.
Se a cor não existir, será adicionada à tabela de cores do sistema. Isto diminui a probabilidade de
ao utilizarmos aplicações com paletas de cores diferentes termos problemas de falta de espaço na
tabela de cores.
• Somente Leitura – Privado (Read Only – Private) – esta opção não tem efeito no Form
Builder, é apenas para compatibilidade com o Graphics Builder.
PASTA ACESSO (SUBCLASS)

Esta pasta definirá opções para as ações de abertura ou salva de uma aplicação:
(Pasta Acesso)
• Acesso – indica se os módulos serão lidos / gravados em arquivo (file) do sistema

operacional, no banco de dados ou arquivo/banco de dados. Esta última opção indica que a
cada abertura ou salva será mostrado um diálogo que questionará o usuário do local de
armazenamento (arquivo ou banco de dados).
• Mostrar – esta opção filtra o que deve ser apresentado no caso de uma leitura.
• Caminho da Divisão em Subclasses – esta opção indica se o caminho (path) deve ser
retirado dos objetos referenciados. Podemos escolher remover, manter ou solicitar (causará o
aparecimento de um diálogo cada vez que indicarmos que um objeto na aplicação é uma
referência a outro).

PASTA ASSISTENTES (WIZARDS)

Esta pasta indica se desejamos ou não que o diálogo de abertura dos assistentes seja mostrado como
primeiro diálogo.
(Pasta Assistentes)
PASTA RUNTIME
As opções desta pasta afetam à execução de uma aplicação através do Form Builder. Cada uma das
opções marcadas aqui possui uma palavra chave que pode ser passada como parâmetro para Form
Runtime e que é enviada automaticamente quando iniciamos a execução através do Form Builder. São
elas:
(Pasta Runtime)
• Armazenar Registros no Buffer do Arquivo (Buffer Records In File) - Atribui o número de

registros armazenados em memória para o mínimo de linhas mostradas mais 3 (para cada
bloco). Se um bloco recupera mais registros que este valor determinado, o Form guarda estes
registros adicionais em um arquivo temporário no disco. Se esta opção não estiver marcada,
será considerada a propriedade Buffered de cada bloco.
• Modo de Depuração (Debug Mode) – Esta opção ativará o Depurador a tempo de execução.
Com esta opção marcada ocorrerá uma interrupção se a procedure Break do pacote Debug for
usada em algum trigger ou se usarmos o comando Ajuda, Depurar (Help, Debug) do menu
principal do Form Runtime.
• Depurar Mensagens (Debug Messages) - Esta opção fará com que a tempo de execução
sejam mostradas mensagens que indiquem qual o trigger em execução atualmente.

• Processamento de Array(Array Processing) - Quando marcamos esta opção, o Form utiliza

o mecanismo de array processing e quando desmarcamos ele irá retornar uma única linha a
cada interação entre o servidor e a estação cliente.
• Otimizar Processamento SQL (Optimize SQL Processing) - Especifica que o Form irá
otimizar os comados SQL processados no estilo V2 pelo compartilhamento de cursores. Por
default o Form associa um cursor para cada comando SQL executado em V2. Isto otimiza a
performance, uma vez que o parse só é executado uma vez, ou seja, somente a primeira vez
for executado para a sessão.
Quando desmarcamos esta opção, o Form associa um único cursor para todos os comandos SQL
executados em V2. Isto economiza memória, por outro lado perde-se em performance uma vez
que o parse será executado cada vez que o comando for executado. Esta opção não tem efeito
para triggers escritos em PL/SQL.
• Otimizar Processamento do Modo da Transação (Optimize Transaction Mode

Processing) - Por default, o Form associa um cursor separado para cada comando SQL que
um Form executa implicitamente num Post ou Query.
Quando desmarcamos esta opção, o Form irá associar um cursor separado apenas para cada
query Select. Todos os outros comando SQL implícitos compartilharão cursores. Isto significa que
todos os Insert, Update, Delete e Select For Update devem ser parsed cada vez que forem
executados.
• Estatística(Statistics) - Mostra uma mensagem ao fim da sessão que apresenta o número

máximo de cursores usados simultaneamente durante a sessão. Esta mensagem aparece na
tela do terminal e não na linha de mensagem.
Esta opção também habilita a seguinte informação para o database: Alter Session Set Sql-Trace =
True. Este comando habilita o acompanhamento do Sql Trace no servidor.
• Exibir Menu do Bloco (Display Block Menu) - Automaticamente mostra o Menu de Blocos
como primeira tela (após a tela de login).
• Modo Somente Consulta (Query Only Mode) - Executa o Form em modo somente de
consulta.
• Modo Silencioso (Quiet Mode) – Neste modo as mensagens não produzem Beep audível. Se
desejarmos chamar a atenção do usuário em determinado momento podemos acionar a rotina
Bell que produzirá um som, se esta opção estiver desmarcada.
O usuário pode criar um arquivo de preferências utilizando a sintaxe: Keyword = <Valor> | ON | OFF

OPÇÕES DE EXECUÇÃO
Estas opções determinam as características de execução para o Form Runtime. Podemos definir estas
opções de duas formas:
• a primeira, já vista anteriormente,

através do diálogo Form Runtime
Options.
• a segunda, na linha de comando, a
tempo de execução do Form
Runtime.
Neste item trataremos da segunda forma de

especificação. A sintaxe para definição de cada
uma das opções (parâmetros) precisa de uma
palavra chave seguida do sinal de igual e do
valor, como na figura 72.
Não deve haver espaço entre o parâmetro e o

sinal de igual e nem entre o sinal de igual e o
valor.
Fig. 72 – Parâmetros de Execução (Atalho)
No exemplo, utilizamos apenas os parâmetros Module e Userid. A lista a seguir relaciona todos os
parâmetros disponíveis:
Palavra-Chave Descrição
Term Este parâmetro determina o nome do arquivo de recursos para o Oracle terminal. Se não for especificado o
Form Runtime utilizará o padrão específico para a plataforma. Por exemplo FrmUsw para ambientes Windows.
Debug Executar em modo de Depuração.
Debug_Messages Depurar Mensagens.
Keyout Determina o nome de um arquivo onde serão gravadas todas as teclas utilizadas durante a execução da
aplicação. Só aplicável a terminais Character Mode.
Keyin Determina o nome de um arquivo de onde serão lidas todas as ações a serem executadas durante a execução
da sessão. Este arquivo deve conter toda a seqüência de teclas para execução, salva, navegação, etc.
Aplicável apenas a terminais Character Mode.
Output_File Determina o nome de um arquivo onde todas as respostas para o vídeo serão gravadas. Aplicável apenas a
terminais Character Mode.
Interactive Boleano (True ou False). Indica se as respostas (telas de saída) deverão ou não ser mostradas no vídeo. Pode
ser utilizada juntamente com as opções Keyin e Output_File. Aplicável apenas a terminais Character Mode.
Array Mecanismo de Array Processing.
Buffer_Records Armazenar Registros no Buffer do Arquivo.
Logon_Screen Este parâmetro, quando True, força a presença da tela de Login. Neste caso o Form Runtime ignora o userid e
password informados.
Block_Menu Exibir Menu do Bloco.
OptimizeSQL Otimizar Processamento SQL (estilo V2)
OptimizeTP Otimizar Processamento do Modo da Transação.
Quiet Modo Silencioso
Statistics Estatística.
UseSdi Indica se o Form Runtime deve utilizar o padrão SDI. O default é NO, indicando que o padrão a ser utilizado é o
MDI, onde a janela do Form Runtime é visível. No padrão SDI será mostrada apenas a janela da aplicação.
Query_Only Modo Somente Consulta.
Help Mostra diálogos com a sintaxe destes parâmetros.
Window_State Determina o estado da janela MDI no início da aplicação. Podemos informar: Maximize, Minimize ou Normal .
Pecs Executa o Form Runtime com Performance Event Collection Services (Pecs) habilitada para coleta de
informações para análise de performance.
Options_Screen Mostra a janela com esta lista de opções a tempo de execução.
Session Especifica se será possível a execução de uma operação de Open_Form com uma sessão em separado. O
valor default para esta opção é NO. A forma mais segura, no entanto, de efetuarmos esta operação é através
da variáveis de ambiente Forms50_Session, que habilita esta situação para todas as aplicações que vierem a
executar daquela estação.
Tabela 11 – Parâmetros de Execução

CAPÍTULO 16: REUSO DE CÓDIGO E PADRONIZAÇÃO

O Form Builder possui diversas formas de aproveitarmos partes da aplicação já definidas e
estabelecermos um padrão, tanto aproveitando código quanto aproveitando layouts de canvas, definições,
objetos diversos.
Este tópico abordará as diversas formas de reutilização seja com objetivo de padrão ou de simples
aproveitamento de código.
Template
Quando iniciamos uma aplicação a tela inicial do Wizard pergunta se queremos criar uma aplicação
baseada em um gabarito.
Fig. 73 – Bem Vindo ao Form Builder
Isto significa que criaremos uma aplicação copiando todas as informações de outra aplicação, (exceto seu
nome).
Esta forma de trabalho é similar a abrir a outra aplicação e usar a opção Salvar Como (Save As) do menu
Arquivo (File), com a diferença que oferece mais segurança. Não corremos o risco de esquecer e salvar
por cima do original.
Para estabelecer um padrão poderíamos criar um esqueleto com objetos padrões de uso da sua
instalação, por exemplo, a barra de ferramentas, o bloco de controle com os botões da barra e suas
respectivas triggers, atributos visuais mais comuns, alertas, etc.
CAPÍTULO 16: REUSO DE CÓDIGO E PADRONIZAÇÃO - 136

Classe de Propriedades
A Classe de Propriedades é uma outra forma de estabelecermos uma padronização a nível de objeto.
Suponhamos que desejemos que todos os botões sejam apresentados no formato icônico, com um
tamanho padrão de 18 por 18 e que não sejam navegáveis nem por teclado e nem por mouse.
Com este objetivo devemos criar um padrão (classe de propriedades) e em seguida atribuir esta classe a
todos os objetos da aplicação compatíveis com a classe criada.
A criação de uma classe é feita no nó Classes de Propriedade (Property Class). Quando abrimos as
propriedades de uma classe recém criada observamos que esta só contém o grupo Geral. Não aparecem
outras propriedades.
USANDO O BOTÃO INCLUIR PROPRIEDADE (ADD PROPERTY)
Uma forma de adicionar novas propriedades na classe é a utilização

do botão Incluir Propriedade da janela de propriedades da classe.
Ao pressionarmos este botão nos é apresenta uma lista contendo

todas as propriedades de todos os objetos de uma aplicação Form
Builder.
A figura 74 mostra os resultados da tela de propriedades criada.
Fig. 74 – Classe de
Propriedades
USANDO O BOTÃO CLASSE DE PROPRIEDADE

(PROPERTY CLASS)
Outra forma de obtermos o mesmo resultado é a criação de uma classe a partir de um objeto pré-
existente.
Por exemplo, ao selecionarmos um botão qualquer de nossa aplicação, podemos abrir sua tela de
propriedades, expandir todos os nós em que se encontram as propriedades desejadas.
Com estas propriedades selecionadas (usando-se as teclas CTRL ou SHIFT simultaneamente), devemos
pressionar o botão Classe de Propriedades (Property Class) da barra de ferramentas da própria janela de
propriedades.
Ocorrerá a criação de uma classe contendo todas as propriedades marcadas além de todas as
propriedades do grupo geral.
OS BOTÕES COPIAR (COPY PROPERTIES) E COLAR (PASTE PROPERTIES)

Podemos, ainda, adicionar outras propriedades à classe, bastando, para isso que selecionemos as
propriedades originais e utilizemos o botão Copiar Propriedades (Copy Properties).
Em seguida, na janela de propriedades da classe de propriedades destino utilizemos o botão Colar

Propriedades.
O BOTÃO DELETAR PROPRIEDADE (DELETE PROPERTY)

Remove uma propriedade da lista de propriedades de uma classe de propriedades.

O BOTÃO INTERSEÇÃO/UNIÃO (INTERSECTION/UNION)

Com este botão podemos ver simultaneamente, na mesma janela de propriedades informações
pertencentes a mais de um elemento (mesmo que possuam tipos diferentes).
Se pressionarmos o botão para que seja mostrada a situação de União, todas as propriedades
pertencentes a cada um dos objetos selecionados é apresentada, mesmo que a propriedade pertença
apenas a um dos objetos.
O BOTÃO CONGELAR / DESCONGELAR (FREEZE/UNFREEZE)

Este botão permite uma forma de compararmos os valores de propriedades de dois elementos, abrindo
duas janelas de propriedades simultaneamente.
Para realizar esta operação, devemos selecionar um objeto. Na tela de propriedades serão apresentadas
as propriedades deste objeto. Ao congelarmos esta tela pressionando o botão Congelar/Descongelar a
seleção de outro elemento qualquer não alterará a lista de propriedades presente nesta janela.
Ao selecionarmos outro objeto da aplicação e utilizarmos o botão direito do mouse, abriremos outra paleta
de propriedades.
GATILHO EM UMA CLASSE DE PROPRIEDADES

Além de propriedades podemos padronizar também código.
Subordinado à uma classe de propriedades qualquer encontramos um nó Gatilhos (Triggers).
Isto significa que podemos criar gatilhos padrões e associá-los aos objetos que receberão a padronização
da classe.
Quando atribuirmos esta classe ao objeto desejado, este herda não só as propriedades como também o
trigger.
ATRIBUINDO A CLASSE DE PROPRIEDADES

Para associarmos a classe de propriedades ao objeto desejado, devemos abrir sua tela de propriedades e
marcar a propriedade Informações sobre a Divisão em Subclasses (Subclass Information). Será
apresentado o diálogo da figura 75.
Fig. 75 – Informações
sobre a Divisão
Devemos escolher o botão de rádio Classe de Propriedade (Property Class). Em seguida, escolher a
classe de propriedade desejada e dar OK.

Tanto na janela do Navegador quanto na janela de Propriedades verificamos um sinal indicativo de

herança.
O trigger criado pode ser modificado localmente. Isto dá uma enorme flexibilidade, pois podemos
estabelecer um padrão básico e completar com definições locais em cada objeto.
Fig. 76 – Herança no Form Builder
O BOTÃO HERDAR
Quando modificamos, no objeto destino uma das propriedades herdadas da classe, a indicação de
herança fica modificada.
Se desejarmos recuperar, novamente, o valor original a partir da classe, devemos selecionar a propriedade
desejada e pressionar o botão Herdar para que o valor seja restaurado.

Biblioteca de Objetos
Outra forma de padronização é a biblioteca de objetos. Uma biblioteca de objetos é um outro tipo de
arquivo gerado pelo Form Builder, não é parte integrante da aplicação. O objetivo desta biblioteca é
armazenar objetos que possam ser aproveitados em outras aplicações.
CRIANDO A BIBLIOTECA DE OBJETOS

A criação de uma biblioteca de objetos é feita pressionando-se o
botão criar (do Navegador) sobre o nó Biblioteca de Objetos (Object
Library).
Após a criação, observamos subordinado ao nó principal existe o nó

Tabs de Biblioteca.
Este nó temo objetivo de permitir que criemos pastas para separação

dos diversos objetos que viermos a armazenar. No exemplo da figura
77 incluímos a pasta Itens e a pasta Atrib_Visual.
As pastas possuem propriedades: Fig. 77 - Biblioteca

de Objetos
• Nome (Name) - determina o nome inteno da pasta.
• Etiqueta (Label) - determina o título da pasta.
Para visualizarmos a janela da biblioteca podemos efetuar um click duplo em uma das pastas ou usar a
opção Biblioteca de Objetos(Object Library) do menu Ferramentas(Tools). Inicialmente as pastas estão
vazias.
Para preenchê-las, devemos abrir uma aplicação Forms e arrastar objetos desta aplicação para a pasta
desejada. Ao realizarmos esta operação estamos criando objetos padrões que podem ser reusados em
outras aplicações.
USANDO OBJETOS DA BIBLIOTECA

Com a aplicação e a biblioteca abertas simultaneamente podemos arrastar os objetos armazenados nesta
biblioteca para a aplicação desejada.
Quando soltamos o objeto no nó

correspondente nos é apresentado
um diálogo para que indiquemos se
desejamos efetuar uma cópia ou
uma subclasse (referência).
Cópia
Com esta forma de reuso,
copiamos um objeto já existente
para dentro de nossa aplicação
sem vínvulo com o original.
O objeto da biblioteca pode ser

modificado sem afetar a aplicação e
vice-versa. Fig. 78 - Subclasse

Referência
Se utilizarmos, porém, a opção SubClasse ocorrerá um vínculo entre o objeto copiado e o original.
Qualquer modificação no item armazenado na Biblioteca afeta os objetos referenciados nas aplicações.
A figura 78 nos mostra a indicação da referência na propriedade Informações sobre a Divisão em

Subclasses (SubClass Information).
Podemos modificar qualquer das propriedades que desejarmos, inclusive aquelas com sinal indicativo de
referência.
O símbolo será apenas modificado indicando que a propriedade não é mais igual àquela presente na
Biblioteca de Objetos.
Excetuando-se o nó Bibliotecas Anexadas (Attached Libraries), objetos de todos os demais nós de uma
aplicação podem ser armazenados em uma Biblioteca de Objetos.
MODIFICANDO OS OBJETOS DE UMA BIBLIOTECA DE OBJETOS

Se desejarmos efetuar uma modificação no objeto armazenado na biblioteca, devemos arrastá-lo para
uma aplicação Forms, fazer a modificação e devolvê-lo para a biblioteca.
Não fazemos edição diretamente na Object Library.
SMARTCLASS
As bibliotecas de objetos podem ser usadas para a especificação de
classes que sejam freqüentemente utilizadas.
A opção SmartClass do menu Objeto (Object) faz esta indicação.
O elemento receberá um sinal à esquerda, como apresentado na figura

79.
Com a Classe Inteligente podemos:
• Arrastar um elemento da classe de objetos para a aplicação

(da mesma forma que para um objeto comum).
Fig. 79 - Biblioteca
• Alterar um elemento existente na aplicação para que receba as de Objetos
características da Classe Inteligente.
• Associar na propriedade Divisão em Subclasses (SubClass Information) a biblioteca de

objetos e o item marcado como Smart.
Se selecionarmos um elemento da aplicação que tenha tipo correspondente a uma das classes intelientes,
com o botão direito do mouse (na opção Classes Inteligentes) veremos a lista de classes disponíveis para
aquele tipo objeto. Esta situação não acontece com um objeto da biblioteca que não seja SmartClass.
Para que a indicação apareça é necessário que a biblioteca esteja aberta simultaneamente com a
aplicação.

Copiando dados de Outra Aplicação

Outra forma disponível de aproveitamento de código é a cópia ou referência a dados presentes em outra
aplicação.
Para tal devemos abrir simultaneamente duas aplicações.
REFERÊNCIA
Com o mouse, fazendo as operações de clicar e arrastar, devemos arrastar um objeto da aplicação origem
para a aplicação destino. No diálogo apresentado devemos escolher a opção Subclasse.
A propriedade Divisão em Subclasses (SubClass Information), quando o objeto faz referência a outro,
indica qual o objeto origem e de que módulo.
CÓPIA
Da mesma forma que anteriormente, podemos copiar objetos de uma aplicação para outra, porém, sem
estabelecer vínculo.
Ao arrastarmos os objetos escolheremos a opção de cópia no diálogo apresentado.
Quando realizamos uma cópia, são trazidos, juntamente com o objeto copiado, os objetos subordinados,
ou seja, triggers e itens.
Os demais objetos (referenciados) não são copiados. Após uma cópia devemos, portanto, fazer as
adaptações necessárias para que os objetos copiados estejam compatíveis com o novo ambiente.
Eles não tem nenhuma relação com os objetos originais. Se analisarmos a propriedade Divisão em
Subclasses (SubClass Information) comprovaremos esta situação.
Grupo de Objetos (Object Group)

O nó Grupo de Objetos (Object Group) tem a finalidade de facilitar o processo de cópia de diversos
elementos de uma aplicação para outra.
Na aplicação origem criamos o grupo de objetos e anexamos a este grupo diversos objetos, tais como:
triggers, blocos, alertas, unidades de programas, etc.
Em vez de arrastarmos um objeto de cada vez para outra aplicação, arrastamos todo o grupo de uma
única vez (para o nó Grupo de Objetos na aplicação Destino).
Quando concluímos o processo, veremos que na aplicação destino, o nó Grupo de Objetos está
preenchido e também todos os nós originais dos objetos copiados (ou referenciados), ou seja, cada objeto
é incluído em seu próprio nó.
Conclusões
O Form Builder pôs a nossa disposição diversas formas de aproveitarmos as especificações de objetos
pertencentes a outras aplicações ou presentes em uma biblioteca de objetos.
Podemos estabelecer todos os tipos de padrões desejados, desde cópia de uma aplicação esqueleto
(template), grupos de objetos ou um único objeto.

CAPÍTULO 17: O MÓDULO LIBRARY

Uma Biblioteca (Library) é uma coleção de programas PL/SQL incluindo procedimentos, funções e
pacotes.
Estas rotinas grupadas em um arquivo podem ser compartilhadas, no ambiente cliente, por diversas outras
aplicações sejam elas Forms, Menus, outras Biblioteca (Libraries) ou até mesmo Reports.
A biblioteca criada deve ser associada a cada módulo no qual desejamos utilizá-la (Attach).
Uma vez anexada, podemos fazer referência às rotinas presentes na biblioteca em qualquer gatilho
(trigger), unidade de programa (program unit) ou itens de menu (inclusive de popup menu).
Criando uma Biblioteca (Library)

Para criarmos a biblioteca devemos selecionar o nó Bibliotecas PL/SQL (PL/SQL Libraries) e pressionar o
botão Criar (Create).
No Navegador encontraremos o objeto contendo a biblioteca criada, porém vazia.
Para adicionarmos uma rotina à biblioteca, devemos selecionar o nó Unidades de Programa (Program
Units) e usar o botão Criar.
No diálogo apresentado informaremos se desejamos criar uma Função, Procedure, Especificação de

Pacote ou Corpo de Pacote.
FUNCTION NOME(CODIGO IN VARCHAR2) RETURN VARCHAR2 IS

VTEXTO VARCHAR2(200);
BEGIN
SELECT NM_DEPTO INTO VTEXTO FROM DEPTO
WHERE CD_DEPTO = CODIGO;
RETURN VTEXTO;
EXCEPTION
WHEN NO_DATA_FOUND THEN
VTEXTO := 'Departamento Inexistente';
RETURN VTEXTO;
END;
Listagem 36
A listagem 36 mostra a função Nome criada na biblioteca.
Quando salvarmos a biblioteca, estaremos salvando todas as rotinas criadas dentro desta biblioteca.
Para executar esta ação devemos utilizar a opção do menu Arquivo (File), Salvar Como (Save As).
Associando uma Biblioteca a uma Aplicação

Para anexarmos e, consequentemente, podermos
utilizar as rotinas embutidas neste pacote, devemos
selecionar o nó Bibliotecas Anexadas (Attached
Libraries) dentro do módulo fonte da aplicação
Forms e pressione o botão Criar (Create).
A figura 80 mostra o diálogo que será apresentado

quando efetuarmos esta ação.
Fig.80 - Anexar Biblioteca
CAPÍTULO 17: O MÓDULO LIBRARY - 143

Pressionaremos o botão Pesquisar (Select) para encontrar a biblioteca em disco. Após identificarmos a
biblioteca, devemos pressionar o botão anexar.
Neste momento será apresentado um diálogo indicando que podemos armazenar internamente na
aplicação apenas o nome da biblioteca (no nosso caso LibPL.PLL) ou podemos armazenar todo o caminho
(no nosso caso C:\Teste\LibPL.PLL).
De um modo geral é preferível que façamos a remoção do caminho (Path), ou seja, que a informação
armazenada contenha apenas o nome da biblioteca, porque esta aplicação certamente será executada em
um ambiente de produção com características de diretório diferentes daquelas encontradas no ambiente
de teste.
Quando retiramos o diretório do nome da biblioteca, a tempo de execução o Form Runtime procurará esta
biblioteca nos diretórios que estiverem preenchidos na variável de ambiente Forms60_Path.
Após a anexação a utilização das rotinas presentes na biblioteca é similar à utilização de uma Unidade de
programa local.
Uso de variáveis em Bibliotecas

Uma vez que uma biblioteca é compilada independentemente de qualquer aplicação não poderemos fazer
referência direta aos seguintes elementos:
• itens de uma aplicação

• variáveis globais
• variáveis de sistema
• parâmetros
Podemos, porém, fazer referência indireta a estes elementos usando a função Name_In para obter o valor
de variáveis ou a função Copy para atribuir valor a variáveis.
De uma forma geral, se você deseja ter independência de código, isto é, suas rotinas ficarem totalmente
independentes da aplicação, o ideal é tratar toda e qualquer informação por parâmetro.
Considerações sobre Armazenamento

Repetiremos aqui as considerações que fizemos anteriormente quando falamos de rotinas e suas diversas
formas de armazenamento: dentro da aplicação, no banco de dados ou em bibliotecas.
Quando decidimos pelo cadastramento de uma determinada rotina em bibliotecas da rede, desejamos o
compartilhamento apenas para o ambiente cliente. Aquele código pode ser aproveitado (reutilizado) por
diversas aplicações no ambiente cliente (módulos de tela ou relatório).
Escolheríamos seu armazenamento em um biblioteca porque:
• a rotina poderá ser compartilhada por mais de um módulo.
• a rotina não utiliza estruturas do banco de dados ou utiliza apenas para atualização, não
causando impacto no tráfego da rede.
• a rotina está associada a ações específicas do ambiente cliente (usa built-ins do Form ou do
Report).
CAPÍTULO 17: O MÓDULO LIBRARY - 144

CAPITULO 18: O MÓDULO MENU

Neste capítulo trataremos de dois tipos de Menus.
Sobre o módulo menu, que é um tipo de arquivo totalmente à parte da

sua aplicação e sobre o Menu Popup, que faz parte integrante do
módulo Forms.
Ao longo do tópico estudaremos o módulo Menu, porém,

sintaticamente e funcionalmente os dois são iguais.
Na figura 81 encontramos o nó Menus (no mesmo nível do nó Forms)

preenchido com um objeto chamado Menu_Principal. O Navegador
apresentado contém os seguinte nós principais:
• Form (vazio)
• Menus (Menu_Principal)
• Bibliotecas PL/SQL (vazio) Fig. 81 - Módulo Menu
• Bibliotecas de Objetos (vazio)
Lembramos que Menu_Principal é um módulo totalmente independente das aplicações Form.
Se, após a criação do módulo Menu, pesquisarmos no Windows Explorer encontraremos um arquivo com
a extensão MMB (o “executável” é MMX). Os nós internos do Menu são:
• Bibliotecas Anexadas – se desejarmos associar alguma biblioteca de PL/SQL ao menu.

Módulo Library.
• Menus – nó onde desenvolveremos, na verdade, este módulo.
• Grupos de Objetos – se desejarmos grupar objetos deste módulo para enviar para outros
módulos ou tivermos copiado dados de outro módulo para o atual.
• Parâmetro – quando desejamos que um item deste módulo receba parâmetro (será visto).
• Unidades de Programas – local onde desenvolveremos códigos de PL/SQL para estruturação

do código.
• Classes de Propriedades – para estabelecermos padrões dentro deste módulo.
• Atributos Visuais – para estabelecermos padrões visuais dentro deste módulo.
Desta lista identificada, a novidade é o nó Menu. Os demais já foram vistos no estudo do módulo Form e
são exatamente iguais àqueles presentes em uma aplicação deste tipo.
Objetos de um Módulo Menu

Se você observar atentamente verificará que existem 4 objetos diferentes que merecem o nosso estudo
neste tópico:
• O módulo Menu.
• Menus (subordinados ao nó Menus).
• Itens de Menu (subordinados a cada Menu criado).
• Parâmetros (utilizados pelos itens de menu).
A criação destes elementos pode ser feita de duas formas: via Navegador ou via Editor.
Faremos, inicialmente, a criação pelo Navegador e, em seguida pelo Editor.
CAPÍTULO 18: O MÓDULO MENU - 145

Criando Itens de Menu via Navegador

No exemplo da figura 82 criamos cinco itens subordinados ao
menu criado anteriormente na aplicação.
O nome do menu é Raiz e o nome dos itens são : Aplicação,

Editar, Atualizar, Consultar e Janela.
Podemos alterar o nome de cada elemento dentro do próprio

Navegador, bastando clicar o mouse sobre o nome do elemento
que desejamos alterar.
Nesta situação o Form Builder ativa o editor de texto (não abre

janela).
Para entendermos o funcionamento de um módulo Menu,

iniciaremos analisando as propriedades de um item de menu.
Fig. 82 - Itens de Menu
Propriedades dos Itens de Menu

No grupo Funcional encontramos:
• Etiqueta(Label) – determina o texto a ser apresentado para o usuário.
• Tipo de Item de Menu (Menu Item Type) – determina o aspecto visual do item. Pode receber
um dos seguintes valores:
- Plano (Plain) – O usuário verá o texto que preenchemos na propriedade etiqueta (label). É
a situação mais comum. É a opção default.
- Verificar (Check) – O texto da propriedade etiqueta (label) também será apresentado,

porém, ao lado será mostrado um símbolo indicando que o item está marcado ou não.
- Rádio (Radio) – Este item também mostra o texto da etiqueta (label). Lateralmente será
apresentado um indicador de selecionado ou não. Este tipo de item pertence a um grupo,
dentro do qual somente um dos itens de rádio pode estar selecionado de cada vez.
- Separador (Separator) – Este item não mostra o texto da etiqueta, em vez disso o que é
mostrado no menu é uma linha separadora. Normalmente utilizada para separar ações de
menu não relacionadas.
- Mágico (Magic) – este tipo de item de menu, possui algum tipo de funcionalidade padrão
em relação ao ambiente Windows, tal como Copy ou Cut. Algumas das ações possíveis são
implementadas implicitamente e não precisaremos efetuar programação para o item.
• Grupo de Rádios de Item de Menu (Menu Item Radio Group) – se o item de menu for do
tipo Radio, esta propriedade deve ser preenchida com o nome de um Item de Menu que
corresponderá ao grupo de Radios. Devemos preencher o mesmo nome para todos os itens
Radio que pertençam ao mesmo conjunto lógico.
Existem duas restrições relativamente a esta propriedade:
- os itens de menu do tipo radio devem ser adjacentes, uns em relação aos outros;
- somente um item de menu correspondente ao grupo poderá ser indicado por Menu.
• Item Mágico (Magic Item) – Se o tipo de item for Magic, devemos preencher esta propriedade
com um dos apresentados na lista. Alguns deles já possuem uma funcionalidade implícita, não
precisando de programação.

• Tipo de Comando (Command Type) – esta propriedade determina o tipo de ação a ser
realizada quando o usuário escolher o item em questão. Os valores válidos para esta
propriedade são:
- Nulo (Null) – indica que nenhuma ação será realizada por aquele item de menu. Devemos
escolher esta opção para todos os itens do tipo separador (separator).
- Menu (Menu) – indica que este item de menu acionará um outro menu. Na área reservada
para o texto do comando deveremos preencher com o nome do menu.
- PL/SQL – neste caso poderemos escrever um bloco de PL/SQL que realize uma ação, tal
como, acionar um Form, um Report, efetuar um cálculo, executar um procedimento, etc.
As demais opções da lista foram mantidas para compatibilidade com versões anteriores e não devem ser
usadas.
• Nome do SubMenu (SubMenu Name) – indica o nome do submenu, quando o tipo de

comando é Menu.
• Código do Item de Menu (Menu Item Code) – indica o texto do PL/SQL quando o tipo do
comando é PL/SQL.
As próximas 4 propriedades determinam se o item de menu será mostrado em uma barra de ferramentas
horizontal e/ou vertical e com que ícone.
Criando Itens de Menu via Editor

Um módulo Menu também possui um editor para criação visual dos objetos de menu.
Fig. 83 - Editor de Menu
A figura 83 apresenta o editor com um menu preenchido. As seguintes características são apresentadas
no desenho:
• Aparecem duas linguetas: uma na linha principal (ao lado do item Aplicação) e outra abaixo do
item Aplicação. Elas representam a presença de Menus (um Raiz) e o outro Aplic_Submenu.
No navegador encontraríamos subordinado ao nó Menus um objeto com o nome de Raiz (veja a

figura 83) e outro objeto com o nome Aplicação_Menu (contendo os itens Salvar, barra Sair).
A associação entre o menu Aplicação_Menu e o item de menu Aplicação é feito através das
propriedades do item Aplicação, que é do tipo Menu e cujo comando se refere ao menu
Aplicação_menu.
• Na barra de Ferramentas aparecem dois botões para a criação de submenus : Create Down e
Create Right. Com estes botões podemos criar itens de menu ou novos menus.
• O texto que aparece para cada item é o texto da etiqueta(label). Não é o nome do item.
Para efetuarmos a compilação de um módulo menu (a fim de gerarmos o arquivo extensão MMX),
devemos escolher CTRL+T ou Menu Arquivo, Administração, Compilar Arquivo.

Associando um Módulo de Menu a um Form

Só podemos executar um Menu se ele estiver associado a uma aplicação. Um Menu não é executado
isoladamente pelo Form Runtime.
Na tela de propriedades do módulo Form, no grupo Funcional existem três propriedades a serem
preenchidas neste momento:
• Origem de Menu(Menu Source) – Indica se o nome do módulo preenchido na próxima

propriedade será encontrado em disco ou no banco de dados.
• Módulo de Menu (Menu Module) – Devemos preencher com o nome do módulo |gerado, ou
seja, o módulo que possui a extensão MMX. No caso do exemplo seria Menu_Principal.MMX.
• Menu Inicial (Initial Menu) – Devemos indicar o nome do nó menu (dentro do módulo Menu)
que deve ser apresentado inicialmente. No exemplo escolheríamos Raiz.
Fig. 84 - Associação
de Menu
DEMAIS PROPRIEDADES RELATIVAS A MENU

O método de associação entre o menu e o Form que utilizamos acima chama-se Referência Direta (Direct
Reference) em função de termos informado diretamente no Form o nome do módulo menu MMX que
desejamos associar ao Form.
Existe, porém, outra forma de fazermos a associação chamada de Procura no Banco de Dados (Database
Lookup).
Nesta forma de associação as informações sobre nome e localização do módulo estão armazenadas no
banco de dados, dentro do módulo Menu.
Na tela de propriedades do Módulo, no grupo Funcional as três propriedades mencionadas anteriormente

seriam preenchidas com:
• Origem de Menu(Menu Source) – Indica se o nome do módulo preenchido na próxima

propriedade será encontrado em disco ou no banco de dados. Neste caso o preenchimento
seria com Banco de Dados (Database).
• Módulo de Menu (Menu Module) – Nesta propriedade continuaremos informando o nome do

módulo, porém como ele está armazenado no banco de dados, não tem extensão, sendo
então informado Menu_Principal.

A terceira propriedade Menu Inicial (Initial Menu) continua sendo preenchida com o nome do Menu a ser
apresentado como o Menu Principal (Inicial) da aplicação.
Estas informações, no entanto, são insuficientes para que o Form Runtime encontre o módulo MMX em
disco para executar. Desta forma há necessidade de informarmos o diretório e o nome do módulo gerado
(MMX).
Isto é feito nas propriedades do módulo Menu, portanto, abra a tela de propriedades do módulo Menu.
As seguintes propriedades devem ser preenchidas neste momento:
• Diretório do Menu (Menu Directory) – nesta propriedade indicamos o diretório onde o Form
Runtime deve procurar pelo MMX.
Se esta propriedade não for preenchida, o Form Runtime inicialmente pesquisará no diretório local
e, se não encontrar o MMX, procurará nos caminhos definidos pela variável de ambiente
Forms60_Path, presente no registrador do Windows.
• Nome do Arquivo do Menu (Menu Filename) – nesta propriedade informamos o nome do

arquivo MMX (sem diretório).
CALL_FORM X NEW_FORM
Neste tópico analisaremos a diferença na chamada das rotinas Call_Form e New_Form. Ambas as rotinas
acionam a execução de uma aplicação Form, mas possuem algumas diferenças na forma de chamada.
• A rotina Call_Form, ativa uma outra aplicação sem fechar a anterior. O Menu se mantém o
mesmo para todas as aplicações chamadas. Isto ocorre porque as aplicações subordinadas
herdam o menu da aplicação anterior.
• Quando usamos a rotina New_Form a aplicação anterior é fechada para que a atual seja
acionada. Não existe ligação entre as duas, assim o menu utilizado na segunda será o menu
que estiver preenchido nas propriedades do módulo desta aplicação. Não há herança.
Concluímos, então que Call_Form aciona outra aplicação sem fechar a atual, tendo como conseqüência a
herança do menu. Já a rotina New_Form aciona outra aplicação, fechando, primeiramente, a aplicação
atual.

Características Particulares de Alguns Itens de Menu

Neste tópico faremos alguns comentários sobre os comandos que associarmos a itens de menu do tipo
Check ou do tipo Radio.
CHECK MENU ITEMS

Quando um menu é carregado no momento de inicialização do Form, um item de menu do tipo Check
aparece no estado não checado (Unchecked), portanto, este estado deve refletir a situação da aplicação.
O comando associado a um item de menu do tipo Check é executado todas as vezes que o operador
coloca o item em um estado oposto ao atual.
A rotina Get_Menu_Item_Property pode ser usada para verificarmos se o estado atual do item é checado
ou não checado.
RADIO MENU ITEMS

Quando um menu é carregado no momento de inicialização do Form, um item de menu do tipo Radio
aparece no estado checado (Checked) se ele for o primeiro item do tipo Radio do grupo.
Caso contrário, seu estado será não checado (Unchecked). Em função disto devemos colocar em primeiro
lugar do grupo aquele item que reflete o estado inicial da situação em questão na aplicação.
O comando associado a um item de menu do tipo Radio é executado quando o operador seleciona o item.
Mesmo se o item escolhido for exatamente o que esteja atualmente checado.
A rotina Get_Menu_Item_Property pode ser usada para verificarmos se o estado atual do item é checado
ou não checado.
RESTRIÇÃO
Não devemos usar itens de menu do tipo Check, Radio ou Separator no menu principal ou em um menu
que venha a ser apresentado no nível mais alto.
Propriedades de um Menu
A seguir apresentamos as propriedades de um menu (não é do módulo):
• Título (Title) - Especifica o título a ser apresentado para o menu. Limitado a 40 caracteres.
Aparece no topo de um menu do tipo Full-Screen.
• Subtítulo (SubTitle) - Nesta propriedade especificamos um texto que será apresentado logo
abaixo do título para menus que usem o formato Full Screen. Está limitado a 40 caracteres.
• Título de Base (Bottom Title) - Nesta propriedade especificamos um texto que será
apresentado acima da linha de mensagem e da linha de status para menus que usem o
formato Full Screen. Está limitado a 72 caracteres.
• Menu Tirar (Tear-off Menu) - É um submenu que os operadores podem retirar da barra de
menu e reposicionar em qualquer lugar da tela. Pode-se habilitar a funcionalidade tear-off para
qualquer submenu, porém, somente no estilo pull-down e quando o gerenciador de janelas
suportar esta característica.

Propriedades do Módulo Menu

No grupo Funcional temos as seguintes propriedades:
• Menu Principal (Main Menu) - Nesta propriedade determinamos o nome de um menu definido
dentro deste módulo que será o menu principal ou inicial a tempo de execução. Útil para
menus apresentados no formato Full-Screen.
As propriedades Diretório do Menu (Menu Directory) e Nome do Arquivo do Menu (Menu Filename)
dizem respeito à forma como o Form Runtime estabelecerá a ligação entre o módulo Form e o
módulo Menu. Foram abordadas no tópico Associando um Módulo de Menu a um Form.
• Código de Inicialização (Startup Code) - Nesta propriedade definimos um texto de código de

PL/SQL que será executado a primeira vez que este módulo de menu for carregado em
memória a tempo de inicialização do Form.
• Compartilhar Biblioteca com o Form (Share Library with Form) - Esta propriedade indica
que o Menu deve utilizar a mesma cópia em memória da biblioteca associada (Attached
Library) se esta for a mesma em uso pelo Módulo Form ativo. Esta propriedade pode ser
interessante para economizar memória e aumentar a performance no ambiente cliente.
No grupo Segurança de Menu vemos:
• Usar Segurança (Use Security) - Marcando esta propriedade indicamos que o Form Runtime
deve assegurar a segurança do módulo menu através do uso de roles. Esta propriedade pode
ser marcada com Não (No) a tempo de desenvolvimento para que sejam possíveis os testes
das diversas opções de menu e com Sim (Yes) no momento em que o sistema for para
produção.
• Papéis do Módulo (Module Roles) - Nesta propriedade incluímos uma lista das Roles
(estabelecidas no banco de dados) que podem ter acesso a este módulo de menu.
Para que esta situação seja efetiva deve existir no banco de dados uma view de nome
Frm60_Enabled_Roles.
Caso esta view não seja encontrada em seu ambiente, o DBA da instalação deverá executar o
script Frm60sec.Sql (presente no CD de instalação) no usuário System.

Parâmetros para Menu

Os parâmetros no Menu são chamados de Substitution Parameters (Parâmetros de Substituição) e podem
ser utilizados nos textos dos códigos desenvolvidos para os itens de menu.
PARÂMETROS PRÉ DEFINIDOS

Existem 6 parâmetros de menu já pré definidos e com valores atribuídos pelo Form Runtime. São eles:
• UN – username corrente.
• PW – password corrente.
• AD – diretório onde o MMX está armazenado, obtido das propriedades Menu FileName e
Menu Directory.
• SO – item de menu corrente.
• TT – tipo de terminal utilizado para conexão.
• LN – linguagem corrente, obtido da variável de ambiente NLS_LANG.
PARÂMETROS DO USUÁRIO
No nó Parâmetros (Parameters) podemos criar nossos próprios parâmetros.
Podemos atribuir valor a eles ou solicitar que os operadores forneçam os dados necessários.
Quando um usuário seleciona um item de menu que faz menção a um parâmetro, o Form Runtime mostra
o diálogo Enter Parameter Values para que o usuário forneça o valor do parâmetro desejado. Em seguida
o Form Runtime executa o comando de menu solicitado.
No grupo Funcional, encontramos:
• Etiqueta (Label) – Indica um texto a ser apresentado para o parâmetro quando este for
solicitado.
• Restrição a Maiúsculas/Minúsculas (Case Restriction) – converte a informação digitada

pelo usuário se a propriedade receber o valor Superior (Upper) ou Inferior (Lower). O valor
Misto (None) não afeta a informação digitada.
• Ocultar Dados (Conceal Data) – esta propriedade determina se o valor informado pelo
usuário aparecerá ou não na tela.
• Menus Associados (Parameter Menus) – Aplicável somente a menus apresentados no

formato Tela Inteira (Full Screen). Indica os nomes dos menus com os quais o parâmetro deve
ser associado.
No grupo Dados encontramos:
• Tamanho Máximo (Maximum Length) - a indicação de seu tamanho máximo.
• Tamanho Fixo(Fixed Length) - se o usuário deve digitar um texto para o parâmetro do

mesmo comprimento de seu tamanho máximo.
• Valor Inicial do Parâmetro do Menu(Initial Value) - seu valor inicial.
• Obrigatório(Required) - finalmente, a indicação de obrigatoriedade de preenchimento.
No grupo Ajuda (Help) encontramos a propriedade Dica (Hint), na qual, podemos definir um texto descritivo
que indique ao usuário o que deve ser preenchido para o parâmetro, uma vez que esta informação ficará
visível quando o parâmetro for solicitado.

CAPÍTULO 19: RELATÓRIOS (REPORTS)

Este tópico será visto após termos estudado o Reports Builder. Retornaremos ao Form Builder para
construir a chamada de um relatório e, neste momento, veremos do que consiste este nó.
Neste ponto encerramos nosso estudo sobre uma aplicação Form.
CAPÍTULO 19: RELATÓRIOS - 153

Oracle Developer 6i Forms

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Oracle Developer 6i Forms

Caricato da

Copyright:

Formati disponibili

INTERNO

ORACLE DEVELOPER – FORMS6I

Rio de Janeiro, janeiro de 2007.

CAPÍTULO 1: CONHECENDO A FERRAMENTA ......................................................................................... 1

CAIXA DE VERIFICAÇÃO (CHECK BOX) .......................................................................................................................................36

O EDITOR DE PL/SQL .....................................................................................................................................................................59

RECOMENDAÇÕES A RESPEITO DE LOVS ...............................................................................................................................101

OPÇÕES DE EXECUÇÃO .............................................................................................................................................................135

CAPÍTULO 1: CONHECENDO A FERRAMENTA

• Form Builder – é a ferramenta para a construção de aplicações online para acesso e

• Procedure Builder – é a ferramenta que nos auxilia no desenvolvimento de programas

• Graphics Builder – é a ferramenta que permite que visualizamos os dados do banco de

• Project Builder – esta é uma ferramenta integradora e organizadora, permitindo que

• Query Builder – é uma ferramenta auxiliar na construção de consultas ao banco de dados.

• Translation Builder – esta é uma ferramenta para suporte e gerenciamento no processo de

CAPÍTULO 1: CONHECENDO A FERRAMENTA- 1

A ferramenta Form Builder é composta de 4 executáveis para cumprimento destas etapas:

• IFBLD60 – Form Builder – Este é o aplicativo para desenvolvimento e compilação individual de

• IFCMP60 – Form Compiler – Este aplicativo permite a conversão de aplicações construídas

• IFDBG60 – É acionado indiretamente através do Form Runtime ou do Form Builder para

CAPÍTULO 1: CONHECENDO A FERRAMENTA- 2

Ativando o Form Builder

Fig. 1 – Bem-Vindo ao Form Builder

A primeira tela apresentada contém:

Um conjunto de opções para a construção de aplicações, sob o grupo Projetando.

Um outro conjunto de opções para apresentação da ferramenta sob o grupo Aprendendo.

Antes da construção da primeira aplicação veremos como navegar na ferramenta.

Por este motivo escolheremos a opção “Desenvolver um novo Form manualmente”.

CAPÍTULO 1: CONHECENDO A FERRAMENTA- 3

O Navegador de Objetos (Object Navigator)

Ao aceitarmos o diálogo anterior é apresentada uma janela

Fig. 2 – Navegador de Objetos

• Forms – subordinado a este nó estarão os módulos de Form que viermos a desenvolver.

• Menus – subordinado a este nó estarão os módulos de Menu que viermos a desenvolver. Na

• Bibliotecas de Objetos – subordinado a este nó estará (ou estarão) a biblioteca de objetos

• Pacotes Embutidos – subordinado a este nó existem diversos pacotes (packages) contendo

• Objetos do Banco de Dados – subordinado a este nó serão visualizados os diversos objetos

A seguir veremos as diversas ações que podemos realizar no Navegador de Objetos:

CAPÍTULO 1: CONHECENDO A FERRAMENTA- 4

Para removermos um elemento, devemos selecioná-lo e pressionar a ferramenta Deletar ou pressionar o

COPIAR, RECORTAR E COLAR

• mover um elemento de um ponto para outro - quando selecionamos um elemento,

• copiar um elemento de um ponto para outro - quando selecionamos um elemento,

Como restrições temos:

• Os elementos devem ser colados em localização apropriada na hierarquia do módulo. Por

• Somente elementos de mesmo tipo podem ser copiados em conjunto.

EXECUTAR E EXECUTAR COM DEPURAÇÃO

• Botão Executar – aciona o Forms Runtime para execução da aplicação corrente.

CAPÍTULO 1: CONHECENDO A FERRAMENTA- 5

NOVO, ABRIR E SALVAR

• Botão Novo - criaremos um novo módulo Form.

Quando salvamos uma aplicação pela primeira vez, o

A partir do momento que definirmos o diretório e o nome

Fig. 8 - Diálogo Salvar Como

Para iniciarmos uma busca devemos digitar a string que

A cada caracter que digitado o Form Builder movimenta

Fig. 9 - Localizar do Navegador de Objetos

Ao abrirmos a lista deste campo, verificaremos que ele

Ele apresenta a árvore de subordinação do elemento

CAPÍTULO 1: CONHECENDO A FERRAMENTA- 6

Para tal devemos pressionar e arrastar o mouse sobre

Só podemos dividi-lo num sentido (vertical ou

Podemos realizar múltiplas subdivisões, desde que