[Notes2-team] *Seja-bem vindo Robson!!!*

[Anderson R. B. <no...@ig...>]

Ol=E1 pessoal,

Digam "al=F4" a Robson, o cara que vai cuidar da documenta=E7=E3o do
Notes 2 (e espero que do Notes 3, Notes 4, Notes 5, etc.). Pessoas,
tenho andado meio "sumido"  - assim como boa parte dos membros -
por causa do "resto" da minha vida que andou me exigindo mais aten=E7=E3o
nas =FAltimas duas, tr=EAs semanas. Mas essa semana as coisas t=E3o volta=
ndo
ao normal e eu vou come=E7ar a encher o saco para finalizarmos o planejam=
ento.
At=E9 por que sei que alguns outros membros tamb=E9m j=E1 andam mais aliv=
iados...

Robson, estou enviando a=ED em baixo a =FAltima vers=E3o do nosso planeja=
mento
do Notes 2, ainda incompleto. =C9 bom tu dar uma lida e nos mandar tuas
sugest=F5es, d=FAvidas, etc. (Pra mandar mail pra lista, mande o e-mail p=
ara
not...@li... .)

Pessoas, ao trabalho!
Anderson

-----------------------------------------------------

Planejamento do Notes 2


Editando texto
Para poder atender a todas as sugest=F5es feitas pelos usu=E1rios, a Equi=
pe=20
do Notes decidiu construir um componente (controle) de edi=E7=E3o pr=F3pr=
io=20
(baseado no famoso componente de edi=E7=E3o SynEdit). Este componente de=20
edi=E7=E3o funcionara no Windows e no Linux da mesma forma. As capacidade=
s=20
dele s=E3o discutidas abaixo:

Colora=E7=E3o de c=F3digo
Esta foi a sugest=E3o mais feita pelos usu=E1rios e vamos finalmente pode=
r=20
atend=EA-la. E n=E3o vamos fazer isto de qualquer forma: o componente usa=
r=E1=20
defini=E7=F5es que ficar=E3o todas em arquivos XML. Isto significa que a=20
colora=E7=E3o de c=F3digo ser=E1 altamente flex=EDvel, podendo ser config=
urada em=20
detalhes pelo usu=E1rio - diferente da maioria dos editores, que s=F3=20
permitem que voc=EA configure as cores. Linguagens n=E3o suportadas por=20
padr=E3o pelo Notes 2 poder=E3o ser adicionadas facilmente e aquelas=20
suportadas poder=E3o ser configuradas de forma a atender as necessidades=20
do usu=E1rio.

Implementa=E7=E3o: a implementa=E7=E3o da colora=E7=E3o de c=F3digo se da=
r=E1 de forma=20
semelhante a de um editor para linux chamado Kate. Assim, o texto seria=20
dividido em blocos definidos atrav=E9s de arquivos XML (por exemplo:=20
coment=E1rio, string, inteiro, etc.) e n=E3o por simples tokens separados=
=20
por espa=E7os em branco. Para evitar que o parser fique lento, sugere-se=20
que, como no Kate, existam regras pr=E9-prontas para detectar alguns tipo=
s=20
de blocos: inteiros, hexadecimais, octais, ponto flutuante, keyword=20
(pr=E9-definindo que uma keyword =E9 uma string sem espa=E7os, iniciada p=
or=20
uma letra e que permite al=E9m de letras, n=FAmero e o caracter "_"; as=20
keywords s=E3o fornecidas pelo arquivo xml). Regras para diferenciar bloc=
o=20
de textos poder=E3o ser facilmente criadas tanto usando express=F5es=20
regulares como tags que permitem procurar por strings exatas, por um=20
=FAnico caracter, pordois caracteres, por qualquer um dos caracteres=20
listados, e pelo intervalo entre uma string/caracter e outra. Este=20
modelo foi escolhido por se encaixar perfeitamente nas id=E9ias da equipe=
=20
e por que o modelo =E9 altamente flex=EDvel podendo ser usado para defini=
r a=20
colora=E7=E3o de qualquer linguagem de programa=E7=E3o - seja de script, =
de=20
marca=E7=E3o, etc.


Analisador e corretor de erros
O editor poder=E1 tamb=E9m detectar erros no c=F3digo enquanto voc=EA dig=
ita.=20
Sim, isso mesmo - voc=EA n=E3o precisar=E1 mais compilar todo o c=F3digo =
para=20
descobrir que cometeu um erro simples de programa=E7=E3o. Claro, o Notes =
2=20
n=E3o substituir=E1 o seu debuger/compilador favorito, mas alguns erros e=
le=20
poder=E1 indentificar - salvando minutos, ou at=E9 horas de compila=E7=E3=
o! Al=E9m=20
disto, ele poder=E1 propor corre=E7=F5es para alguns problemas.

Implementa=E7=E3o: o analisador buscaria por estruturas chaves=20
(principalmente aquelas de controle, como if, while, for, etc.) que=20
estariam definidas em um arquivo XML da linguagem. Por exemplo, ao=20
encontrar a palavra-chave if, ele testaria o bloco de c=F3digo para ver s=
e=20
ele est=E1 de acordo com os modelos que ele conhece. Se o modelo for=20
desconhecido o analisador marca o trecho de c=F3digo como errado. O=20
usu=E1rio poder=E1 corrigir o erro manaulmente ou atrav=E9s de sugest=F5e=
s dadas=20
pelo analisador. As sugest=F5es ser=E3o feitas de forma a transformar o=20
bloco reconhecido como errado na estrutura que ele conhece que for mais=20
parecida com o bloco de c=F3digo.

Debugando
O editor teria a capacidade de setar breakpoints quando informado de que=20
a linguagem pode ser debugada pelo Notes. Al=E9m disto, erros de=20
compila=E7=E3o seriam marcados, quando poss=EDvel, de forma semelhante ao=
s=20
erros marcados pelo analisador.

Folding
Alguns dos editores mais novos permitem que o usu=E1rio esconda certas=20
partes do c=F3digo. =C9 como se voc=EA estivesse usando o Windows Explore=
r (ou=20
o Konqueror/Nautilus no linux) s=F3 que no lugar de poder navegar certas=20
pastas e arquivos, voc=EA pode navegar pelas partes do seu c=F3digo. O=20
folding poder=E1 ser controlado pelo usu=E1rio. Bastar=E1 voc=EA selecion=
ar=20
algumas linhas de c=F3digo que um pequeno =EDcone aparecer=E1: clicando n=
ele=20
aquela parte do c=F3digo ser=E1 escondida, bastando clicar nele novamente=
=20
para mostrar a partes escondida novamente. Voc=EA poder=E1 tamb=E9m marca=
r=20
manualmente as =E1reas de folding. Basta adcionar "{{{" para iniciar uma=20
=E1rea de folding e "}}}" para fech=E1-la (sem as aspas). Selecionando as=
=20
linhas e clicando no =EDcone para esconder o trecho o Notes adicionar=E1=20
para voc=EA estes marcadores.

Implementa=E7=E3o:  ser=E1 usado como base o c=F3digo para folding do edi=
tor=20
JediEdit, j=E1 que ele n=E3o difere muito das especifica=E7=F5es de foldi=
ng=20
desejado pela equipe. Modifica=E7=F5es ser=E3o feitas conforme necess=E1r=
io para=20
que o comportamento descrito acima seja alcan=E7ado.


Intellisense/Code completion, ToolTip com argumentos e Templates
O editor poder=E1 completar nomes de classes, constantes, etc. como nas=20
IDEs da Microsoft=AE e da Borland=AE.
Al=E9m disto, mostrar=E1 tooltips (dicas) mostrando os par=E2metros de m=E9=
todos=20
e fun=E7=F5es quando o usu=E1rio teclar "(" (ou outro caracter dependendo=
 da=20
linguagem). Para completar, o editor suportar=E1 templates. Estes s=E3o=20
palavras especiais definidas pelo usu=E1rio que s=E3o transformadas pelo=20
editor (quando invocado) em uma string maior. Por exemplo, voc=EA poder=E1=
=20
definir a palavra "class"  e ent=E3o  invocar a fun=E7=E3o para que o edi=
tor=20
substitua class pela defini=E7=E3o de classe de alguma linguagem.

Implementa=E7=E3o: ?????????????


Split
O velho edit do DOS e outros editores atuais permitem qeu voc=EA possa=20
dividir o componente de edi=E7=E3o em 2.
No Notes 2 est=E1 capacidade estar=E1 presente, podendo dividir o editor=20
tanto horizontalmente quanto verticalmente, quantas vezes voc=EA quiser.

Implementa=E7=E3o: ????????????


A Interface
A interface do Notes 2 ser=E1 altamente configur=E1vel. Isso ocorrer=E1 p=
or=20
que menus e toolbars ser=E3o criados a partir de arquivos XML, ao inv=E9s=
 de=20
estarem definidos dentro do bin=E1rio. Al=E9m disto, o Notes 2 suportar=E1=
=20
skins (temas) que poder=E3o alterar os controles (bot=F5es, campos de=20
edi=E7=E3o, combos, etc.) e os =EDcones padr=F5es. Apesar de altamente=20
configur=E1vel, continuar=E1 simples de usar, pois sua organiza=E7=E3o se=
guir=E1 a=20
forma a qual os programadores j=E1 est=E3o acostumados.

Implementa=E7=E3o: existir=E3o dois arquivos xml, um que define os menus =
e=20
outro que define as toolbars. As a=E7=F5es dos itens dos menus/toolbars=20
ser=E3o definidas pela tag "onClick" de cada um dos itens. Dito de outra=20
forma, a string definida em onClick =E9 que dir=E1 ao notes o que ele dev=
e=20
fazer quando o usu=E1rio clicar no item. O Notes trar=E1 muitos m=E9todos=
=20
pr=E9-definidos. Estes m=E9todos poder=E3o ser chamados usando uma string=
=20
contendo "Notes." seguido do nome do m=E9todo. Por exemplo, ao detectar u=
m=20
click no primeiro item do primeiro menu, o Notes l=EA a string contida na=
=20
tag onClick do item (seria bom guardar esta string no pr=F3prio intem).=20
Digamos que a string =E9 esta: "Notes.New()". Este m=E9todo faz o Notes=20
abrir o di=E1logo para novos arquivos e projetos - que =E9 o que ocorre=20
depois de um parser interno entender o que significa a string. Este=20
mesmo parser ser=E1 usado para enteder todos os m=E9todos onClick. Al=E9m=
 dos=20
m=E9todos providos pelo Notes, estar=E3o dispon=EDveis os m=E9todos das=20
extens=F5es instaladas pelo usu=E1rio. A extens=F5es ser=E3o sempre respo=
ns=E1veis=20
por adicionar itens a menus/toolbars usando as op=E7=F5es do Notes eXtens=
ion=20
Installer. Digamos que o usu=E1rio queira usar uma extens=E3o chamada=20
"SuperSearch" que adiciona ao Notes um di=E1logo para fazer pesquisa de=20
milh=F5es de formas diferentes. O usu=E1rio n=E3o ter=E1 muitos problemas=
 para=20
isto: basta chamar o Notes eXtension Installer e escolher que extens=E3o=20
ele quer instalar. De acordo com o script xml de instala=E7=E3o da extens=
=E3o,=20
o eXtension Installer adicionar=E1 itens aos menus, aos toolbars, ao=20
ToolBox, etc.  Estes itens tamb=E9m ter=E3o a tag onClick, exatamente com=
o=20
os itens que chamam os m=E9todos do Notes. Mas as strings onClick =20
come=E7ar=E3o com "Extension." ao inv=E9s de "Notes." e ser=E3o seguidas =
de sua=20
categoria (comandos, di=E1logos, etc.), de seu nome e, por =FAltimo, do=20
m=E9todo contido na extens=E3o a ser chamado. (Nem todas as extens=F5es=20
poder=E3o ser chamadas deste modo, pois algumas delas n=E3o adicionam nov=
os=20
m=E9todos ao notes, mas sim colora=E7=E3o de syntaxe para alguma nova=20
linguagem, templates, etc.) Um exemplo seria um comando, implementado na=20
forma de um script em PHP, que formata o c=F3digo Java de acordo com os=20
estilos recomendados pela Sun=AE. A string para chamar esta extens=E3o se=
ria=20
a seguinte: "Extension.Command.PhpJavaFormater.Execute()".  Todas as=20
extens=F5es que adicionam m=E9todos ao Notes poder=E3o ser chamadas pelo=20
m=E9todo "Execute()". Em scripts este m=E9todo n=E3o existe, mas o Notes=20
entende que a extens=E3o =E9 um script e o executa. No caso de plugins=20
(DLLs, DSOs, BPLs), este m=E9todo dever=E1 ser implementado ou ele dever=E1=
=20
usar o arquivo extension.xml para pedir ao Notes que chame outro m=E9todo=
=20
no lugar dele. As complexidades ficam sempre a cargo do Notes, pois os=20
usu=E1rios e os desenvolvedores de extens=F5es podem sempre usar um m=E9t=
odo=20
padr=E3o para chamar as extens=F5es.


Como ser=E1 a interface?
Num programa t=E3o configur=E1vel quanto o Notes 2, esta =E9 uma pergunta=
=20
dif=EDcil de responder. Temos pensando em uma estrutura assim (de cima=20
para baixo): menus; barra de ferramentas; tabs (para mudar entre os=20
arquivos abertos)  e um bot=E3o seletor de projetos (no Notes 2 voc=EA=20
poder=E1 abrir v=E1rios projetos ao mesmo tempo, clique no bot=E3o para m=
udar=20
de um para outro); na esquerda um painel vertical onde ficaram v=E1rias=20
ferramentas (gerenciador de projetos, gerenciador CVS, etc.) e na=20
direita a =E1rea de edi=E7=E3o; um painel horizotal (abaixo do editor, ma=
s n=E3o=20
abaixo do painel vertical) com outras ferramentas (sa=EDda de=20
compiladores, gerenciador de tarefas, etc.); e, por =FAltimo, a barra de=20
status.

Implementa=E7=E3o: ??? aguardando sugest=F5es sobre como os temas poder=E3=
o ser=20
implementados ???

Dando poder ao teclado
A maioria dos programadores usa muito mais o teclado que o mouse - o que=20
difere uma IDE como o Notes 2 de outros aplicativos.  Ent=E3o prometemos=20
desde  j=E1 dar uma aten=E7=E3o especial a ele. No caso do editor, AutoIn=
dent,=20
SmartIndent, SmartHome, SmartEnd, SmartPaste ajudar=E3o a diminuir o temp=
o=20
que um programador gasta escrevendo e formatando o c=F3digo.  Al=E9m dist=
o,=20
o editor poder=E1 usar features normalmente s=F3 encontradadas em editore=
s=20
da Borland=AE, como as setas que podem se movimentar livremente no texto.=
=20
Al=E9m disto tudo, as teclas de atalho poder=E3o ser totalmente=20
configuradas. Pensamos at=E9 em permitir que algumas delas mudem conforme=
=20
a linguagem que se est=E1 editando!!!

Implementa=E7=E3o: algumas destas caracter=EDsticas j=E1 vem implementada=
s no=20
SynEdit, componente que modificaremos para construir o controle de=20
edi=E7=E3o.  No caso do SmatIndent deveremos permitir que seja configurad=
o,=20
como todo o resto, atrav=E9s de um arquivo XML para cada linguagem.  O=20
arquivo poder=E1 conter at=E9 diferentes estilos de indenta=E7=E3o que po=
der=E3o=20
ser escolhidos pelo usu=E1rio como aquele que ele quer usar. No caso das=20
teclas de atalho, bastar=E1 reusarmos o parser das tags onClick referido=20
na descri=E7=E3o da implementa=E7=E3o da interface para que fa=E7amos ela=
s=20
altamente configur=E1veis.

Integra=E7=E3o
Sendo programadores, estamos cientes de que um editor de c=F3digo n=E3o =E9=
 a=20
=FAnica ferramenta necess=E1ria durante o desenvolvimento.  Por isto o No=
tes=20
2 ter=E1 uma boa integra=E7=E3o com compiladores, debugers, CVS, FTP, etc=
. =20
Outros IDEs fazem isto construindo novas ferramentas (quase sempre=20
propriet=E1rias)  diferentes daquelas que os programadores est=E3o=20
acostumados a usar. Queremos que o Notes 2 se integre com as ferramentas=20
que est=E3o a=ED e que voc=EA j=E1 sabe usar. Nada de inventar a roda e=20
obrig=E1-lo a aprender algo que voc=EA n=E3o quer.

Implementa=E7=E3o: a implementa=E7=E3o depende em larga escala aqui de um=
a=20
classe ou procedures que nos permitam ler e escrever em programas de=20
modo texto - ou seja, comunicarmos atrav=E9s de pipes. =C9 isto que=20
precisaremos para nos integrarmos com CVS, compiladores e debugers.=20
Alguns aplicativos (como o cvs e o jdb, debuger do java) exigem que voc=EA=
=20
al=E9m de ler sua s=E1ida (stdout) possam tamb=E9m escrever nela (stdin).=
 A=20
partir deste c=F3digo ser=E1 necess=E1rio criar o suporte para cada ferra=
menta=20
de forma separada, j=E1 que cada um deste possui comandos completamente=20
diferentes. No caso de debugers e compiladores este suporte poderia ser=20
feito atrav=E9s de extens=F5es: al=E9m de possibilitar que suporte a novo=
s=20
compiladores/debugers seja facilmente adicionado, isto diminuiria o=20
n=FAmero de forms linkados diretamente no bin=E1rio. As extens=F5es usari=
am=20
APIs do Notes para que pudessem se comunicarem com os aplicativos por=20
pipes de forma mais f=E1cil e multi-plataforma. No caso do CVS, o suporte=
=20
poderia ser interno, j=E1 que trata-se de algo amplamente usado. O mesmo=20
com o FTP - mas neste a implementa=E7=E3o n=E3o precisaria de um programa=
=20
externo para rodar (existe uma biblioteca SL chamada Synapse para=20
Delphi/Kylix que nos permitir=E1 fazer isto facilmente).

Compiladores e debugers
O Notes suportaria por padr=E3o os compiladores mais usados no windows=20
(vc++, delphi, free pascal, gcc,  java, etc.)  e no linux (gcc e suas=20
varia=E7=F5es, java, kylix, etc.). Para cada compilador (o compilador do=20
projeto ser=E1 escolhido pelo usu=E1rio nas propriedades do projeto) o No=
tes=20
exibir=E1 um di=E1lgo diferente, permitindo que o usu=E1rio configure tod=
as as=20
op=E7=F5es do compilador como se estivesse usando uma IDE espec=EDfica pa=
ra a=20
sua linguagem. Quanto aos debugers, seriam suportados aqueles mais=20
usados, como o GNU Debuger, o jdb, etc.=20


CVS
O gerenciado de CVS do Notes permitir=E1 que voc=EA use esta ferramenta d=
e=20
maneira f=E1cil e sem sair da IDE.  O gerenciador estar=E1 integrado ao=20
resto do Notes, permitindo por exemplo que um novo projeto seja criado a=20
partir do downlod (checkout) de fontes de um servidor local ou remoto. =20
Assim voc=EA podecom facilitade come=E7ar a participar de um dos muitos=20
projetos de software livre existentes!


Sites din=E2micos e Linguagens de Script
Os desenvolvedores de sites din=E2micos (php, jsp, asp, etc.) n=E3o foram=
=20
esquecidos. Voc=EA poder=E1 publicar o projeto para um ftp ou para uma pa=
sta=20
local e ver o resultado em um dos seus browser - tudo isto sem sair da=20
IDE. Da mesma forma, os desenvolvedores de script poder=E3o rodar seus=20
aplciativos facilmente. No caso de linguagens de script muito usadas e=20
que possuam um debuger padr=E3o, este ser=E1 suportado da mesma forma que=
 os=20
debugers para linguagens compiladas.


Extensibilidade
Por mais que nos esforcemos, nunca poderemos oferecer tudo o que um=20
usu=E1rio precisa. H=E1 ferramentas que s=E3o muito espec=EDficas, isto =E9=
, =FAteis=20
apenas para uma linguagem ou para alguns poucos usu=E1rios. H=E1 linguage=
ns=20
que n=E3o existem ainda ou outras, mais antigas, que poder=E3o n=E3o ser=20
suportadas por padr=E3o quando o Notes 2 for lan=E7ado. E al=E9m disto, t=
odos=20
os membros da equipe s=E3o humanos! Para resolver o problema, o Notes 2=20
ser=E1 altamente extens=EDvel: voc=EA poder=E1 adicionar suporte a novas=20
linguagens, criar novos comandos na sua linguagem de script preferida=20
para fazer pequenas modifica=E7=F5es no c=F3digo ou, at=E9 mesmo, escreve=
r novos=20
di=E1logos e ferramentas - plugins - em C/C++, Object Pascal, etc. Al=E9m=
 de=20
tudo isto, as extens=F5es poder=E3o ser instaladas atrav=E9s do Notes e f=
ar=E3o=20
todas as modifica=E7=F5es necess=E1rias para que voc=EA possa sair usando=
 elas=20
sem precisar ler manuais complicados.

Plugins
Os plugins ser=E3o as extens=F5es mais poderosas no Notes 2. Isto por que=
 os=20
plugins ter=E3o acesso a uma API do Notes, feita especialmente para eles.=
=20
Com isto poder=E3o conseguir todo tipo de informa=E7=F5es que precisarem,=
=20
poder=E3o alterar certos comportamentos, capturar eventos, usar=20
bibliotecas do Notes (como a de express=F5es regulares ou a de=20
configura=E7=F5es), etc. Um plugin poder=E1 implementar "servi=E7os" (um =
novo=20
comportamento, como inserir uma quebra de linha toda vez que voc=EA=20
digitar "{"), di=E1logos, novas ferramentas que podem ser dockadas aos=20
pain=E9is do Notes 2, etc.

Implementa=E7=E3o: o c=F3digo para a implementa=E7=E3o dos plugins j=E1 e=
xiste,=20
ent=E3o n=E3o h=E1 tanto trabalho pela frente. Talvez a maior dificuldade=
 seja=20
o que incluiremos na API - pois precisamos saber extamente de que=20
m=E9todos temos para poder permitir que plugins usem eles.

Scripts
No Notes 2 voc=EA poder=E1 usar a sua linguagem de scripts preferida para=
=20
adicionar novas ferramentas ao Notes (claro que voc=EA precisar=E1 ter o=20
interpretador j=E1 instalado, n=E3o d=E1 para querer que o Notes aprenda =
a=20
interpretar todas as linguagens de scripts existentes).  Outra novidade=20
=E9 que voc=EA poder=E1 ter interfaces simples para o seus scripts - usan=
do=20
apenas a sua linguagem de script e um pouco de XML (que =E9 f=E1cil). Com=
=20
isto voc=EA poder=E1 adicionar, por exemplo, um bot=E3o na barra de=20
ferramentas que, quando acionado, mostre ao usu=E1rio um di=E1logo com=20
v=E1rias op=E7=F5es permitindo a ele criar uma tabela HTML em poucos segu=
ndos.

Implementa=E7=E3o:  relativamente simples. O Notes l=EA primeiro o arquiv=
o XML=20
que define a gui. Cada membro da gui possui o nome de uma vari=E1vel=20
anexado a ele. Conforme o usu=E1rio manipula a GUI, estes valores s=E3o=20
armazenados nas vari=E1veis. Por exemplo, se a GUI possui um campo de=20
texto e o usu=E1rio preenche nele "Isto =E9 o valor da vari=E1vel" e a=20
vari=E1vel associada ao campo chama-se MinhaVari=E1vel, MinhaVari=E1vel=20
armazena a string "Isto =E9 o valor da vari=E1vel".  Quando o usu=E1rio c=
lcia=20
OK na GUI, o Notes abre o arquivo de script e substitu=ED nele as=20
vari=E1veis pelo valor que o usu=E1rio deu para elas. Por exemplo, achand=
o=20
%MinhaVari=E1vel% no script, o Notes a substituirpa por "Isto =E9 o valor=
 da=20
vari=E1vel". Depois disto, o Notes executa o script. O script cria ent=E3=
o=20
alguns arquivos: um com a sua sa=EDda (normalmente =E9 o texto modificado=
);=20
outro com erros, quando necess=E1rio; e um terceiro que definir=E1 o que =
o=20
Notes far=E1 com a suas sa=EDda.

Suporte a novas linguagens
Atrav=E9s das extens=F5es ser=E1 poss=EDvel tamb=E9m adicionar suporte a =
outras=20
linguagens e melhorar o suporte as linguagens que s=E3o suportadas no=20
Notes 2 por padr=E3o. Uma extens=E3o poder=E1 conter templates, o arquivo=
 de=20
colora=E7=E3o de c=F3digo para a linguagem, snippets, scripts, plugins, e=
tc.

Mais detalhes

ToolBox
O Notes SE incluia o menu inserir. Apesar de ser altamente funcional,=20
ele tinha um problema: voc=EA tinha que navegar pelos submenus at=E9 acha=
r o=20
que queria inserir. Para solucionar este problema, a equipe do Notes=20
incluir=E1 um ToolBox no painel vertical, que facilitar=E1 o acesso aos=20
c=F3digos do menu inserir.

Ferramentas para SQL e XML
O Notes 2 incluir=E1 tamb=E9m ferramentas para que voc=EA possa manipular=
=20
banco de dados, construir querys SQL com facilidade e editar visualmente=20
arquivos XML.