[Notes2-team] Planos do n2 =?ISO-8859-1?Q?Vers=E3o_0=2E0=2E3?=

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

Ol=E1 pessoal,
estive dando umas modificadas no nosso planejamento, atualizando ele com
as discuss=F5es que tivemos ultimamente e dando uma meiorada.

Modifica=E7=F5es
- Adicionado se=E7=E3o EDITANDO TEXTO >> FAVORITOS, EDITANDO TEXTO >>=20
TASKLIST, E EDITANDO TEXTO >> CLIPBOARD HISTORY;
- Adicionada se=E7=E3o A AJUDA DO NOTES 2;
- Adicionada a se=E7=E3o NAVEGANDO NO C=D3DIGO {CLASSVIEW, COMBOS, ETC.}
- Modifica=E7=F5es na parte sobre o analisador de erros para incluir a=20
capacidade;
dele de auto completar (a parte sobre a implementa=E7=E3o est=E1 meio enr=
olada=20
ainda);
- V=E1rias modifica=E7=F5es tentando deixar o texto menor, mais objetivo =
e claro;


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 exatamente da mesma forma. As=
=20
capacidades dele s=E3o discutidas abaixo:

Colora=E7=E3o de c=F3digo
Este =E9 o pedido mais frequente dos usu=E1rios e, com a constru=E7=E3o d=
o novo=20
componente, poderemos atend=EA-lo. O componente usar=E1 defini=E7=F5es qu=
e=20
ficar=E3o todas em arquivos XML. Isto significa que a colora=E7=E3o de c=F3=
digo=20
ser=E1 altamente flex=EDvel, podendo ser configurada em detalhes pelo=20
usu=E1rio inclusive permitindo que a comunidade adicione ao Notes suporte=
=20
a linguagens n=E3o suportadas pela distribui=E7=E3o padr=E3o.

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, por dois 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 / auto-completar
O editor poder=E1 detectar erros no c=F3digo enquanto o usu=E1rio digita=20
dispensando o uso de compiladores e debugers para a localiza=E7=E3o e=20
corre=E7=E3o de erros simples de programa=E7=E3o. Al=E9m de detectar os e=
rros, o=20
editor poder=E1 sugerir corre=E7=F5es baseado nas estruturas padr=F5es da=
=20
linguagem que o usu=E1rio estiver usando. O corretor poder=E1 ser usado p=
elo=20
usu=E1rio para completar certas constru=E7=F5es. Por exemplo, um usu=E1ri=
o=20
poder=E1 digitar "if (x=3D=3Dy" e pedir para o editor auto-completar o c=F3=
digo,=20
o que o deixaria semelhante a "if (x=3D=3Dy) { }".

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 n=E3o=20
estiver de acordo com a estrutura que o analisador conhece ele marcar=E1 =
o=20
trecho de c=F3digo como errado. O usu=E1rio poder=E1 corrigir o erro=20
manaulmente ou atrav=E9s de sugest=F5es dadas pelo analisador. As sugest=F5=
es=20
ser=E3o feitas de forma a transformar o bloco reconhecido como errado na=20
estrutura que ele conhece que for mais 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 semelhante a usar o Windows Explorer (ou o=20
Konqueror/Nautilus no linux) s=F3 que no lugar de poder navegar certas=20
pastas e arquivos, pode-se navegar pelas partes do seu c=F3digo. O foldin=
g=20
poder=E1 ser controlado pelo usu=E1rio. Bastar=E1 selecionar algumas linh=
as de=20
c=F3digo que um pequeno =EDcone aparecer=E1: clicando nele aquela parte d=
o=20
c=F3digo ser=E1 escondida, bastando clicar nele novamente para mostrar a=20
parte escondida novamente.  As =E1reas de folding poder=E3o ser marcadas=20
tamb=E9m manualmente: bastar=E1 adicionar "{{{" para iniciar uma =E1rea d=
e=20
folding e "}}}" para fech=E1-la (sem as aspas). Selecionando as linhas e=20
clicando no =EDcone para esconder o trecho o Notes adicionar=E1 estes=20
marcadores automaticamente.

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, ser=E1 poss=ED=
vel=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 da linguagem que estiver sen=
do=20
editada.

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

*Favoritos*
O Notes 2 usar=E1 um modelo de bookmakers diferente do usado em algumas=20
IDEs (como o Delphi, Context, etc.). Ao inv=E9s de limitar o usu=E1rio a=20
nove bookmakers nomeados simplesmente com n=FAmeros de 0 a 9 - que for=E7=
am=20
o usu=E1rio a lembrar a correspond=EAncia entre nome do bookmaker e parte=
 do=20
c=F3digo de cabe=E7a - a equipe optou por usar um modelo semelhante ao us=
ado=20
pelo editor jEdit.  O usu=E1rio simplesmente dir=E1 ao Notes 2 (clicando =
no=20
menu, usando atalhos, etc.) em que linha do c=F3digo ele quer que o Notes=
=20
2 crie o bookmaker. O Notes 2 criar=E1 um bookmaker para aquela linha e=20
permitir=E1 ao usu=E1rio voltar a aquela linha de v=E1rias formas: ele po=
der=E1=20
seleciona-lo na lista de bookmakers - cada item da lsita ter=E1 o formato=
=20
[n=FAmero da linha]: "[in=EDcio da linha]"... (por exemplo: 42 : "if (x=3D=
=3Dy){=20
// fechamos o prog"...) - ou usar itens como "pr=F3ximo bookmaker" e=20
"bookmaker anterior". Os bookmakers de cada arquivo ser=E3o salvos no=20
arquivo que cont=E9m o projeto que est=E1 sendo editado. Assim o usu=E1ri=
o=20
ter=E1 eles sempre =E0 m=E3o, mesmo ap=F3s fechar e abrir o arquivo.


*TaskList*
As tarefas ficar=E3o anotadas diretamente no c=F3digo fonte, atrav=E9s de=
=20
coment=E1rios iniciados por certas palavras chaves (como "TODO:" por=20
exemplo). Estes coment=E1rios ser=E3o coletados e mostrados no gerenciado=
r=20
de tarefas. Como as tarefas ficar=E3o no pr=F3prio c=F3digo, as tarefas=20
poder=E3o ser facilmente compartilhadas pela equipe mesmo que algu=E9m da=
=20
equipe resolva n=E3o usar o Notes 2.

*Clipboard History*
O Notes guardar os =FAltimos trechos de c=F3digo copiados para a =E1rea d=
e=20
transfer=EAncia, permitindo ao usu=E1rio colar estes trechos ou reenvi=E1=
-los=20
para a =E1rea de transfer=EAncia.

Split
O velho edit do DOS e outros editores atuais permitem que o componente=20
de edi=E7=E3o seja dividido em 2.
No Notes 2 est=E1 capacidade estar=E1 presente, podendo dividir o editor=20
tanto horizontalmente quanto verticalmente, quantas vezes o usu=E1rio qui=
ser.

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

Navegando no C=F3digo

*ClassView*
Permitir=E1 ao usu=E1rio visualizar a estrutura do c=F3digo e navegar por=
 ela.=20
O ClassView mostrar=E1 todas as classes do arquivo que estiver sendo=20
editado, com todos os m=E9todos, propriedades, campos, etc.

*Barra com combos para navega=E7=E3o*
O usu=E1rio poder=E1 navegar pelo c=F3digo usando uma barra de navega=E7=E3=
o. Esta=20
barra ter=E1 dois bombos - um listando todas as classes do c=F3digo e out=
ro=20
mostrando os m=E9tos/propriedades da classe selecionada no primeiro combo=
.=20
Selecionando os itens de cada combo o usu=E1rio poder=E1 pular rapidament=
e=20
para os trechos do c=F3digo que quiser editar.

* Incremental search*
O Incremental Search ser=E1 um localizar diferente: permitir=E1 ao usu=E1=
rio=20
ver os resultados da localiza=E7=E3o enquanto digita o que quer localizar=
.=20
Por exemplo, se o usu=E1rio quiser localizar "int", quando digitar "i" o=20
Notes 2 mostrar=E1 visualemnte todas as ocorr=EAncias de "i" no texto;=20
quando o usu=E1rio digitar o pr=F3ximo carater ("n") o Notes 2 mostrar=E1=
=20
todos os "in" existentes no texto; e assim por diante.

*Indo e vindo nos locais editados*
Com o Notes 2 o usu=E1rio poder=E1 voltar para as partes do c=F3digo que =
rec=E9m=20
editou. Toda vez que o usu=E1rio come=E7ar a editar uma parte de c=F3digo=
=20
muito distante daquela que ele estava editando anteriormente, o Notes=20
guardar=E1 a localiza=E7=E3o da regi=E3o que ele estava editando. Se o us=
u=E1rio=20
precisar voltar para ela, bastar=E1 clicar numa op=E7=E3o do menu - ele n=
=E3o=20
precisar=E1 lembrar em que linha que ele estava. O Notes guardar=E1 a=20
localiza=E7=E3o de todas as =FAltimas partes editadas permitindo ao usu=E1=
rio=20
trabalhar em partes diferentes do c=F3digo sem se perder.


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.

*A ajuda do Notes 2*
A ajuda do Notes 2 trar=E1 todas as informa=E7=F5es sobre como operar o N=
otes=20
2, tutoriais para os novos usu=E1rios e ferramentas que facilitar=E3o a =20
resolu=E7=E3o de d=FAvidas ligadas as linguagens suportadas pelo Notes. A=
=20
ajuda estar=E1 totalmente integrada a IDE, n=E3o tendo nenhuma depend=EAn=
cia=20
de sistemas exteriores e/ou propriet=E1rios. Em um painel - organizado de=
=20
forma semelhante ao toolbox - o usu=E1rio ter=E1 acesso a tr=EAs ferramen=
tas:=20
"NotesStart"; "Ajuda do Notes 2"; e "Ajuda das linguagens". O NotesStart=20
ser=E1 um painel que trar=E1 links para aquilo que quem est=E1 iniciando =
a=20
usar o Notes precisa - permitindo abrir os trechos mais importantes da=20
documenta=E7=E3o e realizar as tarefas mais comuns.  A "Ajuda do Notes"=20
possuir=E1 um =EDndice de toda a documenta=E7=E3o do Notes 2 e dar=E1 ao =
usu=E1rio a=20
possibilidade de procurar na documenta=E7=E3o. A "Ajuda das linguagens"=20
permitir=E1 ao usu=E1rio procurar por informa=E7=F5es nos sites mais impo=
rtantes=20
sobre a linguagem que est=E1 usando e trar=E1 links para f=F3rums, listas=
 de=20
discuss=E3o, etc. Em resumo: a Ajuda do Notes trar=E1 v=E1rias ferramenta=
s=20
permitindo ao usu=E1rio ir muito al=E9m do acesso a documenta=E7=E3o, pro=
curando=20
gui=E1-lo as melhores solu=E7=F5es para as suas d=FAvidas de forma r=E1pi=
da e=20
intuitiva.

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.