Re: [Notes2-team] Bem-vindos novos membros!

[Maidy <ma...@te...>]

OPA!!!
Primeiramente, obrigada por terem me aceito no grupo!! Espero poder =
contribuir com o pouco que sei e aprender com todos!!
Segundo, estamos ai para trabalhar.... j=E1 disse pro Anderson e repito: =
"Estou aqui pra botar a m=E3o na massa"....

Thanks!! :-))

  ----- Original Message -----=20
  From: Robson Cardoso dos Santos=20
  To: not...@li...=20
  Sent: Wednesday, September 17, 2003 12:20 AM
  Subject: Re: [Notes2-team] Bem-vindos novos membros!


    Est=E1 =F3timo, pelo menos pra n=F3s da documenta=E7=E3o,(n=E3o sei =
se a Maidy concorda) que entraremos em a=E7=E3o um pouco mais tarde. :)

    ----- Original Message -----=20
    From: Anderson R. Barbieri=20
    To: not...@li...=20
    Sent: Monday, September 15, 2003 9:53 PM
    Subject: [Notes2-team] Bem-vindos novos membros!


    Ol=E1 pessoar,

    Com a aprova=E7=E3o de voc=EAs, j=E1 adicionei oficalmente a Maidy e =
o Allan
    a Equipe. Quero aproveitar para ser o primeiro a dar as boas-vindas =
aso
    novos membros.

    Aos "velhos": estou no aguardo de coment=E1rios/id=E9ias/cr=EDticas =
a proposta=20
    que apresentei.
    Se n=E3o ouvir nada esta semana, tomarei isto como um "a proposta =
est=E1=20
    =F3tima, vamos
    trabalhar". Temos que correr contra o tempo, n=E3o d=E1 para enrolar =
mais...=20
    Afinal, voc=EAs querem
    trabalhar ou n=E3o???!

    Aos "novos": a tal proposta est=E1 anexa. Consiste em um "roadmap", =
um=20
    mapa que prop=F5e
    v=E1rias fases para o desenvolvimento do Notes, a=E7=F5es de =
marketing,=20
    cria=E7=E3o da documenta=E7=E3o,
    desenvolvimento do site, da imagem do Notes 2, etc. LEIAM! Junto =
est=E3o=20
    os planos do
    Notes 2 e especifica=E7=F5es t=E9cnicas que s=F3 interessam aos =
programadores,=20
    mas estou mandando
    junto caso queriam olhar :)

    Aguardo vossos coment=E1rios,
    Anderson R. Barbieri



-------------------------------------------------------------------------=
---


    Notes 2 Roadmap

    Este roadmap especifica cada uma das fases de desenvolvimento do =
Notes 2, tanto em rela=E7=E3o a cria=E7=E3o do programa quanto as =
a=E7=F5es de todos as =E1reas do projeto.

    FASE 1:
    - Cria=E7=E3o do planejamento do Notes 2 entre os membros da equipe =
levando em considera=E7=E3o todas as sugest=F5es dadas pelo usu=E1rio;
    - Cria=E7=E3o deste roadmap;
    - Constru=E7=E3o da Especifica=E7=E3o do Controle de Edi=E7=E3o do =
Notes;
    - Constru=E7=E3o da Especifica=E7=E3o do site de desenvolvimento - =
NotesDev.

    FASE 2:
    - Desenvolvimento do Controle de Edi=E7=E3o do Notes;
    - Desenvolvimento do NotesDev;
    - Cria=E7=E3o do logo do Notes 2 e indentidade visual b=E1sica;
    - A=E7=F5es de marketing para informar os usu=E1rios do in=EDcio de =
desenvolvimento e sobre o que est=E1 sendo planejado para o Notes 2 =
(manuten=E7=E3o dos usu=E1rios atuais);
    - Cria=E7=E3o de especifica=E7=F5es sobre como funcionar=E3o os =
menus e atalhos no Notes 2.

    FASE 3:
    - Implementa=E7=E3o dos menus e atalhos no Notes 2;
    - Lan=E7amento oficial do NotesDev;
    - Marketing mostrando o logo e indentidade visual do Notes 2 aos =
usu=E1rios atuais;
    - Divulga=E7=E3o do NotesDev;
    - Divulga=E7=E3o da primeira vers=E3o p=FAblica de desenvolvimento;
    - Cria=E7=E3o de uma pequena documenta=E7=E3o para beta-testers =
(readme, manual de instala=E7=E3o, como reportar bugs e sugest=F5es, =
capacidades j=E1 implementadas, etc.);

    FASE 4:
    - Lan=E7amento e divulga=E7=E3o da primeira vers=E3o de =
desenvolvimento ao p=FAblico;
    - Corre=E7=F5es dos bugs reportados, analise das primeiras =
sugest=F5es;
    - Cria=E7=E3o das especifica=E7=F5es relativas a interface do Notes =
2 (localiza=E7=F5es de bot=F5es,
    desenho de pain=E9is, desenhos de di=E1logos, etc.);
    - Cria=E7=E3o da Especifica=E7=E3o do suporte a extens=F5es;

    FASE 5:
    - Implementa=E7=E3o do suporte a extens=F5es (e algumas extens=F5es =
como o di=E1logo localizar);
    - Desenvolvimento das partes da documenta=E7=E3o relativas as =
extens=F5es;
    - Cria=E7=E3o das especifica=E7=F5es das ferramentas do Notes 2: =
tasklist, gerenciador CVS, gerenciador FTP, barra com combos de =
navega=E7=E3o e classview;

    FASE 6:
    - Lan=E7amento e divulga=E7=E3o da segunda vers=E3o de =
desenvolvimento p=FAblica do Notes 2;
    - Implementa=E7=E3o das ferramentas do Notes 2;
    - Desenvolvimento da documenta=E7=E3o das ferramentas do Notes 2;
    - Cria=E7=E3o da especifica=E7=E3o do gerenciamento de temas do =
Notes 2;

    FASE 7:
    - Lan=E7amento e divulga=E7=E3o da terceira vers=E3o de =
desenvolvimento p=FAblica do Notes 2;
    - Implementa=E7=E3o do gerenciamento de temas do Notes 2;
    - Desenvolvimento da documenta=E7=E3o relativa ao suporte a temas do =
Notes 2;
    - Cria=E7=E3o dos primeiros temas para teste;
    - Cria=E7=E3o da especifica=E7=E3o dos di=E1logos de =
configura=E7=E3o do Notes 2;

    FASE 8:
    - Lan=E7amento e divulga=E7=E3o da quarta vers=E3o de =
desenvolvimento p=FAblica do Notes 2;
    - Implementa=E7=E3o dos di=E1logos de configura=E7=E3o do Notes 2;
    - Desenvolvimento da documenta=E7=E3o relativa aos dos di=E1logos de =
configura=E7=E3o;
    - In=EDcio da cria=E7=E3o do site do Notes 2;
    - Cria=E7=E3o do instalador do Notes 2;
    - Grande divulga=E7=E3o do lan=E7amento da vers=E3o alpha do Notes =
2;

    FASE 9:
    - Lan=E7amento e divulga=E7=E3o da vers=E3o alpha do Notes 2;
    - Corre=E7=F5es de bugs e analise das =FAltimas sugest=F5es;
    - Cria=E7=E3o da especifica=E7=E3o das modifica=E7=F5es para a =
vers=E3o beta do Notes 2;

    FASE 10:
    - Desenvolvimento da vers=E3o beta;
    - Grande divulga=E7=E3o da vers=E3o beta;
    - Cria=E7=E3o da campanha de marketing do Notes 2;
    - Finaliza=E7=E3o da documenta=E7=E3o;

    FASE 11:
    - Lan=E7amento da vers=E3o beta;
    - Per=EDodo de Freeze (2 meses apenas fazendo corre=E7=F5es de =
bugs).
    - Finaliza=E7=E3o do site;
    - =DAltimas corre=E7=F5es na documenta=E7=E3o, instalador, etc.
    - In=EDcio da divulga=E7=E3o da vers=E3o final do Notes 2;

    FASE 12:
    - Lan=E7amento do Notes 2, do site e da campanha de =
marketing!!!!!!!!!
    - F=E9rias :)







-------------------------------------------------------------------------=
---


    Especifica=E7=E3o do Controle de Edi=E7=E3o do Notes (CEN)




    O Controle de edi=E7=E3o do Notes (CEN) ser=E1 um componente =
desenvolvido em Object Pascal para ser o "editor" do Notes 2. Ele ser=E1 =
baseado no componente de edi=E7=E3o SynEdit (synedit.sf.net), mas ter=E1 =
muitas coisas diferentes dele, principalmente, um modo totalmente =
diferente de colorir o c=F3digo, suporte a folding e detec=E7=E3o de =
erros no c=F3digo. O CEN ser=E1 um componente da CLX, ou seja, poder=E1 =
funcionar exatamente da mesma forma no linux e no windows. O modo como o =
CEN far=E1 a colora=E7=E3o do c=F3digo =E9 totalmente inspirada na =
colora=E7=E3o de c=F3digo do editor Kate. O c=F3digo para suporte a =
folding provavelmente vir=E1 do editor JeditEdit.




    O CEN n=E3o ter=E1 meios de indentificar a linguagem que estiver =
sendo editada - ser=E1 de responsabilidade do Notes 2 setar a linguagem =
antes de carregar um documento. Da mesma forma que muitos controles do =
Delphi, o CEN disponibilizar=E1 os m=E9todos LoadFromFile e SaveToFile =
que ser=E3o otimizados em rela=E7=E3o a colora=E7=E3o de sintaxe, =
foldings, analise de erros, convers=E3o entre codifica=E7=F5es de texto, =
etc para abrir e salvar arquivos.=20




    Este documento visa especificar cada uma das capacidades do CEN =
quanto ao seu comportamento, dando, quando poss=EDvel id=E9ias para a =
implementa=E7=E3o do mesmo. Abaixo s=E3o explicadas cada uma das =
capacidades do CEN.







    1) Capacidades b=E1sicas de edi=E7=E3o




    Ao n=EDvel do entendimento do usu=E1rio, o CEN ter=E1 apenas 3 =
capacidades de edi=E7=E3o: a inser=E7=E3o de texto; drag and drop de =
texto; e sele=E7=E3o de texto com o mouse. Ele n=E3o responder=E1, =
sozinho, a nenhum tipo de atalho (del, teclas direcionais, etc.) nem =
ter=E1 popups pr=E9-definidas, pois estas coisas ser=E3o todas =
configur=E1veis no Notes 2. Ou seja, =E9 do Notes 2 a responsabilidade =
de chamar os m=E9todos necess=E1rios para que estas coisas sejam =
realizadas. Por outro lado, ao n=EDvel do programador o CEN ter=E1 =
m=E9todos para todas as tarefas de edi=E7=E3o - menos a localiza=E7=E3o =
de texto, que ser=E1 de responsabilidade de outro m=F3dulo. Uma =
sugest=E3o para os m=E9todos e propriedades b=E1sicos est=E1 abaixo:




          M=E9todo/Propriedade
         Par=E2metros
         Descri=E7=E3o
        =20
          Undo
        =20

         Desfaz a =FAltima opera=E7=E3o.
        =20
          Redo
        =20

         Refaz a =FAltima opera=E7=E3o.
        =20
          CanUndo
        =20

         True se a =FAltima opera=E7=E3o pode ser desfeita. Caso =
contr=E1rio, retorna false.
        =20
          CanRedo
        =20

         True se a =FAltima opera=E7=E3o pode ser refeita. Caso =
contr=E1rio, retorna false.
        =20
          Cut
        =20

         Recorta o texto selecionado.
        =20
          Copy
        =20

         Copia o texto selecionado.
        =20
          Paste
        =20

         Colar da =E1rea de transfer=EAncia.
        =20
          Delete
        =20

         Deleta o pr=F3ximo caracter ou a sele=E7=E3o.
        =20
          SelectAll
        =20

         Seleciona todo o texto.
        =20
          SelectWordAtCursor
        =20

         Seleciona a palavra na qual estiver o cursor.
        =20
          GetWordAtCursorAsStr
        =20

         Retorna a palavra na qual est=E1 o cursor em uma string.
        =20
          SelectCurrentLine
        =20

         Seleciona a linha em que est=E1 o cursor.
        =20
          SelectLine
         Line: integer;
         Seleciona a linha indicada no par=E2metro line.
        =20
          SelectRange
         AStart, AEnd: integer;
         Seleciona o texto entre Astart e Aend.
        =20
          SelPos
        =20

         Permite pegar/setar a posi=E7=E3o do cursor.
        =20
          SelLength
        =20

         Permite pegar/setar a quantidade de caracteres selecionados.
        =20
          Length
        =20

         N=FAmero de caracteres no texto.
        =20
          LinesCount
        =20

         N=FAmero de linhas do texto.
        =20
          Lines
        =20

         Propriedade que retona/seta o texto como uma TStringList e/ou =
permite manipular o texto linha a linha.
        =20
          Text
        =20

         Propriedade que retorna/seta o texto como string.
        =20
          SelText
        =20

         Propriedade que retorna/seta o texto selecionado como string.
        =20
          Modified
        =20

         Propriedade que permite saber se o texto foi modificado (deve =
ser setada como true ao carregar/salvar texto).
        =20
          LineLength
         Line: integer
         Retorna/seta o n=FAmero de caracteres da linha.
        =20
          GetFirstVisibleLine
        =20

         Retorna o n=FAmero da primeira linha vis=EDvel.
        =20
          GetLastVisibleLine
        =20

         Retorna o n=FAmero da =FAltima linha vis=EDvel.
        =20
          HideSelection
        =20

         Especifica se a sele=E7=E3o deve ser escondida.
        =20
          SelMode
         ASelMode: TCENSelMode;
         Especifica o modo de sele=E7=E3o (coluna, normal).
        =20
          CurrentLine
        =20

         Permite setar/pegar a linha em que est=E1 o cursor.
        =20
          PosToChar
         Pos: Tpoint;
         Retorna o n=FAmero do caracter que est=E1 na posi=E7=E3o =
especificada por Pos (X, Y).
        =20
          PosFromChar
         CharPos: integer;
         Retorna a posi=E7=E3o do caracter especificado em CharPos.
        =20













    2) Colora=E7=E3o de c=F3digo




    A colora=E7=E3o de c=F3digo ser=E1 feita pelo CEN unindo duas fontes =
de dados - ambas no formato XML. Uma trar=E1 regras que permitir=E3o =
dividir o texto conforme a sintaxe da linguagem que estiver sendo =
colorida (arquivo LangRules.xml). Outra dir=E1 ao CEN como pintar cada =
parte da sintaxe e como se comportar quando o usu=E1rio estiver editando =
o c=F3digo (arquivo LangConfig.xml). O CEN ter=E1 ent=E3o um "parser =
gen=E9rico" - ou seja, um parser capaz de entender qualquer formato =
desde que os dados lhe digam como ele est=E1 estruturado.




    a) LangRules.xml

    O CEN n=E3o dividir=E1 o c=F3digo em tokens separados por espa=E7os =
em branco. O texto ser=E1 separado por linhas e cada linha poder=E1 ter =
uma ou mais regi=F5es. As regras contidas em LangRules.xml ser=E3o =
aplicadas uma a uma na linha corrente e o resultado desta analise ser=E1 =
guardado na mem=F3ria. Cada vez que o controle for pintado, os =
resultados desta an=E1lise ser=E3o lidos e mostrados usando as =
configura=E7=F5es do usu=E1rio para aquela linguagem na tela. Um arquivo =
LangRules.xml ser=E1 parecido com o texto abaixo:




    ----------------- LangRules.xml -------------------

<LangRules>
 =20
  <info>
    <authors>
      <author>
        <name>Equipe do Notes</name>
        <email>no...@ig...</email>
        <site>http://notes.codigolivre.org.br</site>
      </author>
    </authors>
    <version>1.0</version>
  </info>
 =20
 =20
  <regions>
    <region>comentario</region>
    <region>palavrachave</region>
    <region>inteiro</region>
  </regions> =20

  <rules>
    <rule region=3D"comentario" EndAt=3D"EOL">
       <find2chars str=3D"//" />
    </rule>

    <rule region=3D"palavrachave" EndAt=3D"Self">   =20
      <keyword str=3D"if" />=20
      <keyword str=3D"for" />      =20
      <keyword str=3D"while" />      =20
      <keyword str=3D"function" />      =20
      <keyword str=3D"until" />      =20
      <keyword str=3D"die" />      =20
    </rule>
  =20
    <rule region=3D"inteiro" EndAt=3D"Self">
      <findInteger />
    </rule>
  </rules>

</LangRules>
    --------------- fim de LangRules.xml --------------

    O arquivo =E9 dividido em tr=EAs partes. A primeira =E9 um "header", =
um cabe=E7alho com informa=E7=F5es sobre o(s) autor(es) do arquivo, =
vers=E3o, etc. A segunda parte define as regi=F5es que existem no =
formato e a =FAltima cont=E9m as regras que ser=E3o usadas para analisar =
cara linha do c=F3digo.

    A tag "rule" cont=E9m o atributo "region" que informa qual regi=E3o =
a regra est=E1 procurando e a tag "EndAt" que diz ao CEN onde a regi=E3o =
ir=E1 acabar se a regra obtiver sucesso (no exemplo, EOL diz que o =
coment=E1rio vai at=E9 o fim da linha e Self indica que a regi=E3o acaba =
na string encontrada mesmo). Logo depois disto vem a tag que diz qual =
=E9 a regra. O CEN ter=E1 tags pr=E9-definidas para encontrar certos =
tipos de elementos comuns a diversas sintaxes (como a tag "findInteger") =
e tags que permitem fazer v=E1rios tipos de buscas (como a =
"find2Chars").




    Valores poss=EDveis para o atributo EndAt:

          Nome:
         Descri=E7=E3o:
        =20
          EOL
         Indica que a regi=E3o acaba ao fim da linha.
        =20
          Self=20
         A regi=E3o acaba na pr=F3pria string encontrada.
        =20
          ID:[ValorDaID]=20
         Indica o ID de outra "rule" (regra) que o CEN dever=E1 usar =
para encontrar o fim da regi=E3o.
        =20
          Space
         Pr=F3ximo espa=E7o.
        =20
          Tab
         Pr=F3ximo caracter TAB.
        =20
          BlankSpace
         Pr=F3ximo espa=E7o, TAB ou quebra de linha.
        =20




    Regras:

          Nome:
         Atributos:
         Descri=E7=E3o:
        =20
          FindInteger
         --
         Encontra os inteiros da linha.=20
        =20
          FindHex
         --
         Encontra Hexadecimais.
        =20
          FindOct
         --
         Encontra octais.
        =20
          FindFloat
         --
         Encontra pontos flutuantes.
        =20
          FindChar
         str
         Encontra o caracter especificado em str.
        =20
          Find2Chars
         str
         Encontra os dois caracteres especificados em str.
        =20
          FindAnyOfChars
         str
         Encontra qualquer um dos caracteres especificados em str.
        =20
          FindStr
         Str, CaseSensitive
         Encontra a string especificada em str. =C9 casesensitive se o =
atributo CaseSensitive for "true".
        =20
          RegEx
         Str, CaseSensitive
         Busca a express=E3o regular especificada em str. =C9 =
casesensitive se o atributo CaseSensitive for "true".
        =20
          Keyword
         str
         Procura pela keyword especificada em str.
        =20
          FindRangeStr
         StrBegin, strEnd
         Procura pelo intervalo entre StrBegin e StrEnd.
        =20
          FindRangeChar
         StrBegin, strEnd
         Procura o intervalo de texto entre os caracteres definidos em =
StrBegin e strEnd.
        =20
          FindRange2Chars
         StrBegin, strEnd
         Procura o intervalo de texto entre duas strings com 2 =
caracteres StrBegin e StrEnd.
        =20




    b) LangConfig.xml=20

    Guarda as configura=E7=F5es do usu=E1rio para a linguagem. No que =
diz respeito a colora=E7=E3o de c=F3digo, o importante =E9 a parte =
nomeada "RegionsStyles". Exemplo:







    ----------- LangConfig.xml -----------

    <LangConfig>

 =20
  <RegionsStyles>
    <RegionStyle>
      <RegionName>Comentario</RegionName>
      <Color>0</Color>
      <bold>false</bold>
      <italic>true</italic>
      <underline>false</underline>
    </RegionStyle>
    <RegionStyle>
      <RegionName>palavraschaves</RegionName>
      <Color>0</Color>
      <bold>true</bold>
      <italic>false</italic>
      <underline>false</underline>
    </RegionStyle>
    <RegionStyle>
      <RegionName>inteiro</RegionName>
      <Color>0</Color>
      <bold>false</bold>
      <italic>false</italic>
      <underline>false</underline>
    </RegionStyle>
  </RegionsStyles>

</LangConfig>
    -------- fim de LangConfig.xml --------

    Com este arquivo, combinado ao exemplo dado de LangRules.xml, o CEN =
mostraria ao usu=E1rio todas as strings "if" em negrito e com a cor =
preta (0).=20




    O CEN precisar=E1 dividir o texto em suas regi=F5es em dois momentos =
distintos: ao carregar o texto e ao texto ser editado. Ao fazer essa =
divis=E3o durante a edi=E7=E3o, o CEN dever=E1 re-analisar apenas as =
regi=F5es pr=F3ximas a regi=E3o que est=E1 sendo editada - precisaremos =
testar se o melhor =E9 re-analisar apenas as linhas mais pr=F3ximas ou =
as regi=F5es mais pr=F3ximas e qual a quantidade destas.=20







    3) Analisador de erros




    O CEN poder=E1 descobrir erros no c=F3digo enquanto o usu=E1rio =
digita. O CEN ter=E1 um mecanismo de verifica=E7=E3o do c=F3digo que =
analisar=E1 o texto de tempos em tempos e cada trecho com erros ser=E1 =
guardado na mem=F3ria e, posteriormente, pintado pelo CEN com uma linha =
colorida em forma de ondas - como os erros de ortografia no MS Word ou =
OpenOffice. O analisador ainda ter=E1 dois m=E9todos: um permitir=E1 =
retornar corre=E7=F5es para certo erro na forma de uma lista de strings =
- que provavelmente ser=E1 apresentada ao usu=E1rio pelo Notes 2 como um =
submenu - e outro que permitir=E1 aplicar uma destas corre=E7=F5es.=20







    4) Debug




    O CEN ter=E1 uma barra lateral (gutter) onde o usu=E1rio poder=E1 =
clicar para setar Breakpoints. O breakpoint ser=E1 mostrado como um =
pequeno =EDcone nesta barra lateral. O programador podera usar a =
fun=E7=E3o GetBreakPoints para pegar um array contendo o n=FAmero de =
cada uma das linhas que possui breakpoints. Outros m=E9todos =
(SetBreakPoint, DelBreakPoint, ClearBreakPoints, CanSetBreakPoints) =
estar=E3o dispon=EDveis para gerenciar os breakpoints.




    Al=E9m dos Breakpoints, o CEN poder=E1 indicar linhas com erros (a =
linha ter=E1 o fundo trocado para uma cor especificada pelo usu=E1rio, =
vermelho por padr=E3o).







    5) Folding




    O CEN ter=E1 a capacidade de esconder/mostrar parte do texto. Isto =
funcionar=E1 do seguinte modo:




    A) O usu=E1rio especifica o inicio e o fim do trecho que quer =
esconder (para isto ele dever=E1 usar duas strings diferentes para =
indicar o in=EDcio e o fim do trecho de folding, por padr=E3o estas =
strings ser=E3o "{{{" e "}}}" respectivamente).




    B) Logo que isto =E9 especificado o CEN identifica o trecho de =
folding e adiciona na barra lateral (gutter) um =EDcone com o sinal de =
menos [-]. Quando este sinal for clicado, o trecho de folding ser=E1 =
escondido.




    C) Quando um trecho est=E1 escondido, um =EDcone de mais [+] aparece =
na barra lateral e, ao lado disto no campo de edi=E7=E3o, um trecho que =
contem os primeiros caracteres escondidos e o n=FAmero da primeira e da =
=FAltima linha escondida.




    D) O usu=E1rio dever=E1 clicar no =EDcone de [+] para mostrar =
novamente o trecho de folding.




    =C9 importante observar que o trecho de folding ser=E1 sempre =
constitu=EDdo por linhas inteiras e que estas linhas ser=E3o apenas =
escondidas da vis=E3o no momento em que o CEN for pintado na tela. O =
texto estar=E1 sempre dispon=EDvel, sempre inteiro. M=E9todos =
especificos dever=E3o permitir saber quais trechos est=E3o escondidos, =
setar/deletar trechos de folding, etc.




    Podemos usar o c=F3digo do editor JediEdit para iniciar essa =
funcionalidade.







    6) Indenta=E7=E3o autom=E1tica de c=F3digo




    Para cada uma das linguagens o usu=E1rio por=E1 escolher usar entre =
o AutoIndent e o SmartIndent, ou ainda desabilitar a indenta=E7=E3o =
autom=E1tica. Estas configura=E7=F5es ser=E3o guardadas no arquivo =
LangConfig.xml. Um modelo de como devem funcionar o autoindent e o =
smartindent pode ser retirado da edi=E7=E3o atual do Notes (1.5.4).=20




    a) Autoindent

    Quando a op=E7=E3o autoindent estiver ativada, o CEN manter=E1 a =
indenta=E7=E3o da linha atual ao criar uma nova linha.=20




    b) SmartIndent

    Quando a op=E7=E3o SmartIndent estiver ativada, o CEN indentar=E1 o =
c=F3digo automaticamente enquanto o usu=E1rio digita. Para cada =
linguagem um ou mais iniciador de bloco e um ou mais finalizador de =
bloco dever=E1 ser definido. Por exemplo, poder=EDamos ter "{" e "}" =
como iniciadores e finalizadores de bloco em PHP. Quando o usu=E1rio =
teclar <ENTER> ap=F3s um iniciador de bloco, o CEN criar=E1 uma nova =
linha com indenta=E7=E3o maior do que a indenta=E7=E3o da linha atual. =
Ao teclar <ENTER> ap=F3s um finalizador, o CEN primeiro diminuir=E1 a =
indenta=E7=E3o da linha atual em rela=E7=E3o a linha superior e depois =
criar=E1 uma nova linha com a mesma indenta=E7=E3o da linha atual.







    7) Autoclose




    Cada linguagem ter=E1 uma lista de strings que ser=E3o =
automaticamente "fechadas" pelo CEN. Por exemplo, ao digitar "<HTML>" o =
CEN automaticamente inseriria "</HTML>" logo depois, se o usu=E1rio =
estivesse editando HTML. A lista de strings ser=E1 guarda da seguinte =
forma, em um arquivo denominado LangAutoClose.xml:




    ------- LangAutoClose.xml ------------------




<LangAutoClose>
  <!-- Lista de caracteres que chamam o mecanismo de autoclose -->
  <FireAutoCloseChars><![CDATA[<>-"]]></FireAutoCloseChars>

  <!-- Fecha tags automaticamente quando true. Use em HTML, XMl, etc. =
-->
  <AutoCloseTags>true</AutoCloseTags>

  <!-- Lista de strings que devem ser fechadas -->
  <AutoCloseStr>
    <Open><![CDATA[<!--]]></Open>
    <Close><![CDATA[-->]]></Close>
  </AutoCloseStr>
  <AutoCloseStr>
    <Open><![CDATA["]]></Open>
    <Close><![CDATA["]]></Close>
  </AutoCloseStr>
</LangAutoClose>
    -----fim de LangAutoClose.xml --------------




    A tag fireAutoClose tags define uma lista de caracteres que invocam =
o mecanismo de autoclose ao serem digitados. No exemplo, quando o =
usu=E1rio digitar uma aspa (") o mecanismo ser=E1 invocado. Ele =
descobrir=E1 que a aspa est=E1 na lista de strings a serem fechadas =
(est=E1 na tag Open, dentro de uma tag AutocloseStr), e que ela dever=E1 =
ser fechada com outra aspa. A tag AutocloseTag permite dizer ao CEN para =
fechar tags no estilo de XML e HTML de forma autom=E1tica - ou seja, =
assim n=E3o =E9 necess=E1rio especificar as tags a serem fechadas. No =
caso de AutocloseTag estar setado como true, o CEN automaticamente =
incluir=E1 os caracteres "<" e ">" a lista de caracteres que chama o =
mecanismo de autoclose - no exemplo eles foram adicionados manualmente =
para manter a clareza, mas isto n=E3o era obrigat=F3rio.







    7) Outras capacidades do CEN




    a) Mostrar linhas na gutter

    O CEN ter=E1 a habilidade de mostrar o n=FAmero de cada uma das =
linhas na gutter (tanto come=E7ando a numera=E7=E3o por zero quanto por =
1). Essa numera=E7=E3o dever=E1 levar em conta o folding. Nas linhas em =
que existir folding ou breakpoint, o n=FAmero da linha n=E3o ser=E1 =
mostrado - no lugar disto estar=E1 o =EDcone correspondente a estas =
fun=E7=F5es.




    b) Setas direcionais livres (estilo editor do Delphi)

    O CEN poder=E1 ter setas direcionais que se movem livremente como no =
editor do Delphi. Esta capacidade j=E1 faz parte do SynEdit - precisamos =
apenas mant=EA-la.




    c) SmartHome e SmartEnd

    O SmartHome permite que ao teclar <HOME> (ou outro atalho =
configurado para fazer a fun=E7=E3o desta tecla) o cursor v=E1 para o =
primeiro caracter da linha que n=E3o seja um espa=E7o e/ou tab. O =
SmartEnd faz o mesmo com a tecla <END>.




    d) Wrap autom=E1tico e trim de espa=E7os ao fim da linha

    O Wrap autom=E1tico faz o CEN quebrar a linha toda a vez que a linha =
chegar a um n=FAmero m=E1ximo de

    caracteres. O "trim de espa=E7os ao fim da linha" faz o CEN retirar =
os caracteres espa=E7o e tab que restam ao final da linha.




    e) Formato do texto

    O CEN dever=E1 suportar UNICODE e ASCII com finais de linha estilo =
Windows, Unix e Mac. O CEN dever=E1 poder abrir, editar, salvar e =
converter entre estes formatos.




    f) =CAnfase da linha atual e de iniciadores/finalizadores de bloco

    O CEN dever=E1 poder enfatizar a linha que o usu=E1rio estiver =
editando (mudando a cor do fundo). Da mesma forma, o CEN dever=E1 poder =
enfatizar os iniciadores/finalizadores de bloco. Se est=E1 op=E7=E3o =
estiver ativada, quando o cursor chegar ao iniciador/finalizador de =
bloco, o inicializador e o finalizador daquele bloco dever=E1 ser =
pintado com um fundo diferente. Por exemplo, em um script PHP, quando o =
cursor estiver no caracter "{" este caracter e o finalizador do bloco =
"}" dever=E3o ser pintados com fundo diferente.




    g) Espa=E7os e Tabs

    O CEN dever=E1 poder inserir espa=E7os no lugar do caracter TAB (o =
n=FAmero de espa=E7os dever=E1 ser ajust=E1vel). Quando o usu=E1rio =
quiser usar o caracter TAB, ele dever=E1 poder escolher o tamanho visual =
deste caracter em rela=E7=E3o ao caracter espa=E7o - ou seja, o caracter =
tab poder=E1 ter o tamanho de x espa=E7os.






-------------------------------------------------------------------------=
---


    Planejamento do Notes 2=20


    Editando texto
    Para poder atender a todas as sugest=F5es feitas pelos usu=E1rios, a =
Equipe do Notes decidiu construir um componente (controle) de edi=E7=E3o =
pr=F3prio (baseado no famoso componente de edi=E7=E3o SynEdit). Este =
componente de edi=E7=E3o funcionara no Windows e no Linux exatamente da =
mesma forma. As 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 do novo componente, poderemos atend=EA-lo. O componente =
usar=E1 defini=E7=F5es que ficar=E3o todas em arquivos XML. Isto =
significa que a colora=E7=E3o de c=F3digo ser=E1 altamente flex=EDvel, =
podendo ser configurada em detalhes pelo usu=E1rio inclusive permitindo =
que a comunidade adicione ao Notes suporte 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 dar=E1 de forma semelhante a de um editor para Linux chamado Kate. =
Assim, o texto seria dividido em blocos definidos atrav=E9s de arquivos =
XML (por exemplo: coment=E1rio, string, inteiro, etc.) e n=E3o por =
simples tokens separados por espa=E7os em branco. Para evitar que o =
parser fique lento, sugere-se que, como no Kate, existam regras =
pr=E9-prontas para detectar alguns tipos de blocos: inteiros, =
hexadecimais, octais, ponto flutuante, keyword (pr=E9-definindo que uma =
keyword =E9 uma string sem espa=E7os, iniciada por uma letra e que =
permite al=E9m de letras, n=FAmero e o caracter "_"; as keywords s=E3o =
fornecidas pelo arquivo xml). Regras para diferenciar bloco de textos =
poder=E3o ser facilmente criadas tanto usando express=F5es regulares =
como tags que permitem procurar por strings exatas, por um =FAnico =
caracter, pordois caracteres, por qualquer um dos caracteres listados, e =
pelo intervalo entre uma string/caracter e outra. Este modelo foi =
escolhido por se encaixar perfeitamente nas id=E9ias da equipe e por que =
o modelo =E9 altamente flex=EDvel podendo ser usado para definir a =
colora=E7=E3o de qualquer linguagem de programa=E7=E3o - seja de script, =
de 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 dispensando o uso de compiladores e debugers para a =
localiza=E7=E3o e corre=E7=E3o de erros simples de programa=E7=E3o. =
Al=E9m de detectar os erros, o editor poder=E1 sugerir corre=E7=F5es =
baseado nas estruturas padr=F5es da linguagem que o usu=E1rio estiver =
usando. O corretor poder=E1 ser usado pelo usu=E1rio para completar =
certas constru=E7=F5es. Por exemplo, um usu=E1rio poder=E1 digitar "if =
(x=3D=3Dy" e pedir para o editor auto-completar o c=F3digo, o que o =
deixaria semelhante a "if (x=3D=3Dy) { }".

    Implementa=E7=E3o:o analisador buscaria por estruturas chaves =
(principalmente aquelas de controle, como if, while, for, etc.) que =
estariam definidas em um arquivo XML da linguagem. Por exemplo, ao =
encontrar a palavra-chave if, ele testaria o bloco de c=F3digo para ver =
se ele est=E1 de acordo com os modelos que ele conhece. Se o modelo =
n=E3o estiver de acordo com a estrutura que o analisador conhece ele =
marcar=E1 o trecho de c=F3digo como errado. O usu=E1rio poder=E1 =
corrigir o erro manaulmente ou atrav=E9s de sugest=F5es dadas pelo =
analisador. As sugest=F5es ser=E3o feitas de forma a transformar o bloco =
reconhecido como errado na 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 a linguagem pode ser debugada pelo Notes. Al=E9m disto, erros de =
compila=E7=E3o seriam marcados, quando poss=EDvel, de forma semelhante =
aos erros marcados pelo analisador.=20

    Folding
    Alguns dos editores mais novos permitem que o usu=E1rio esconda =
certas partes do c=F3digo. =C9 semelhante a usar o Windows Explorer (ou =
o Konqueror/Nautilus no linux) s=F3 que no lugar de poder navegar certas =
pastas e arquivos, pode-se navegar pelas partes do seu c=F3digo. O =
folding poder=E1 ser controlado pelo usu=E1rio. Bastar=E1 selecionar =
algumas linhas de c=F3digo que um pequeno =EDcone aparecer=E1: clicando =
nele aquela parte do c=F3digo ser=E1 escondida, bastando clicar nele =
novamente para mostrar a parte escondida novamente.  As =E1reas de =
folding poder=E3o ser marcadas tamb=E9m manualmente: bastar=E1 adicionar =
"{{{" para iniciar uma =E1rea de folding e "}}}" para fech=E1-la (sem as =
aspas). Selecionando as linhas e clicando no =EDcone para esconder o =
trecho o Notes adicionar=E1 estes marcadores automaticamente.

    Implementa=E7=E3o:  ser=E1 usado como base o c=F3digo para folding =
do editor JediEdit, j=E1 que ele n=E3o difere muito das =
especifica=E7=F5es de folding desejado pela equipe. Modifica=E7=F5es =
ser=E3o feitas conforme necess=E1rio para 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 IDEs da Microsoft=AE e da Borland=AE.
    Al=E9m disto, mostrar=E1 tooltips (dicas) mostrando os par=E2metros =
de m=E9todos e fun=E7=F5es quando o usu=E1rio teclar "(" (ou outro =
caracter dependendo da linguagem). Para completar, o editor suportar=E1 =
templates. Estes s=E3o palavras especiais definidas pelo usu=E1rio que =
s=E3o transformadas pelo editor (quando invocado) em uma string maior. =
Por exemplo, ser=E1 poss=EDvel definir a palavra "class"  e ent=E3o  =
invocar a fun=E7=E3o para que o editor substitua class pela =
defini=E7=E3o de classe da linguagem que estiver sendo editada.=20

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

    Favoritos
    O Notes 2 usar=E1 um modelo de bookmakers diferente do usado em =
algumas IDEs (como o Delphi, Context, etc.). Ao inv=E9s de limitar o =
usu=E1rio a nove bookmakers nomeados simplesmente com n=FAmeros de 0 a 9 =
- que for=E7am o usu=E1rio a lembrar a correspond=EAncia entre nome do =
bookmaker e parte do c=F3digo de cabe=E7a - a equipe optou por usar um =
modelo semelhante ao usado pelo editor jEdit.  O usu=E1rio simplesmente =
dir=E1 ao Notes 2 (clicando no menu, usando atalhos, etc.) em que linha =
do c=F3digo ele quer que o Notes 2 crie o bookmaker. O Notes 2 criar=E1 =
um bookmaker para aquela linha e permitir=E1 ao usu=E1rio voltar a =
aquela linha de v=E1rias formas: ele poder=E1 seleciona-lo na lista de =
bookmakers - cada item da lsita ter=E1 o formato [n=FAmero da linha]: =
"[in=EDcio da linha]"... (por exemplo: 42 : "if (x=3D=3Dy){ // fechamos =
o prog"...) - ou usar itens como "pr=F3ximo bookmaker" e "bookmaker =
anterior". Os bookmakers de cada arquivo ser=E3o salvos no arquivo que =
cont=E9m o projeto que est=E1 sendo editado. Assim o usu=E1rio 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 coment=E1rios iniciados por certas palavras chaves (como =
"TODO:" por exemplo). Estes coment=E1rios ser=E3o coletados e mostrados =
no gerenciador de tarefas. Como as tarefas ficar=E3o no pr=F3prio =
c=F3digo, as tarefas poder=E3o ser facilmente compartilhadas pela equipe =
mesmo que algu=E9m da equipe resolva n=E3o usar o Notes 2.=20

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

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

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

    Navegando no C=F3digo

    ClassView
    Permitir=E1 ao usu=E1rio visualizar a estrutura do c=F3digo e =
navegar por ela. O ClassView mostrar=E1 todas as classes do arquivo que =
estiver sendo 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=E3o. Esta barra ter=E1 dois bombos - um listando todas as =
classes do c=F3digo e outro mostrando os m=E9tos/propriedades da classe =
selecionada no primeiro combo. Selecionando os itens de cada combo o =
usu=E1rio poder=E1 pular rapidamente para os trechos do c=F3digo que =
quiser editar.

    Incremental search
    O Incremental Search ser=E1 um localizar diferente: permitir=E1 ao =
usu=E1rio ver os resultados da localiza=E7=E3o enquanto digita o que =
quer localizar. Por exemplo, se o usu=E1rio quiser localizar "int", =
quando digitar "i" o Notes 2 mostrar=E1 visualemnte todas as =
ocorr=EAncias de "i" no texto; quando o usu=E1rio digitar o pr=F3ximo =
carater ("n") o Notes 2 mostrar=E1 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 editou. Toda vez que o usu=E1rio come=E7ar a editar uma =
parte de c=F3digo muito distante daquela que ele estava editando =
anteriormente, o Notes guardar=E1 a localiza=E7=E3o da regi=E3o que ele =
estava editando. Se o usu=E1rio precisar voltar para ela, bastar=E1 =
clicar numa op=E7=E3o do menu - ele n=E3o precisar=E1 lembrar em que =
linha que ele estava. O Notes guardar=E1 a localiza=E7=E3o de todas as =
=FAltimas partes editadas permitindo ao usu=E1rio 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 por que menus e toolbars ser=E3o criados a partir de arquivos =
XML, ao inv=E9s de estarem definidos dentro do bin=E1rio. Al=E9m disto, =
o Notes 2 suportar=E1 skins (temas) que poder=E3o alterar os controles =
(bot=F5es, campos de edi=E7=E3o, combos, etc.) e os =EDcones padr=F5es. =
Apesar de altamente configur=E1vel, continuar=E1 simples de usar, pois =
sua organiza=E7=E3o seguir=E1 a forma a qual os programadores j=E1 =
est=E3o acostumados.=20

    Implementa=E7=E3o: existir=E3o dois arquivos xml, um que define os =
menus e outro que define as toolbars. As a=E7=F5es dos itens dos =
menus/toolbars ser=E3o definidas pela tag "onClick" de cada um dos =
itens. Dito de outra forma, a string definida em onClick =E9 que dir=E1 =
ao notes o que ele deve fazer quando o usu=E1rio clicar no item. O Notes =
trar=E1 muitos m=E9todos pr=E9-definidos. Estes m=E9todos poder=E3o ser =
chamados usando uma string contendo "Notes." seguido do nome do =
m=E9todo. Por exemplo, ao detectar um click no primeiro item do primeiro =
menu, o Notes l=EA a string contida na tag onClick do item (seria bom =
guardar esta string no pr=F3prio intem). Digamos que a string =E9 esta: =
"Notes.New()". Este m=E9todo faz o Notes abrir o di=E1logo para novos =
arquivos e projetos - que =E9 o que ocorre depois de um parser interno =
entender o que significa a string. Este mesmo parser ser=E1 usado para =
enteder todos os m=E9todos onClick. Al=E9m dos m=E9todos providos pelo =
Notes, estar=E3o dispon=EDveis os m=E9todos das extens=F5es instaladas =
pelo usu=E1rio. A extens=F5es ser=E3o sempre respons=E1veis por =
adicionar itens a menus/toolbars usando as op=E7=F5es do Notes eXtension =
Installer. Digamos que o usu=E1rio queira usar uma extens=E3o chamada =
"SuperSearch" que adiciona ao Notes um di=E1logo para fazer pesquisa de =
milh=F5es de formas diferentes. O usu=E1rio n=E3o ter=E1 muitos =
problemas para isto: basta chamar o Notes eXtension Installer e escolher =
que extens=E3o ele quer instalar. De acordo com o script xml de =
instala=E7=E3o da extens=E3o, o eXtension Installer adicionar=E1 itens =
aos menus, aos toolbars, ao ToolBox, etc.  Estes itens tamb=E9m ter=E3o =
a tag onClick, exatamente como os itens que chamam os m=E9todos do =
Notes. Mas as strings onClick  come=E7ar=E3o com "Extension." ao inv=E9s =
de "Notes." e ser=E3o seguidas de sua categoria (comandos, di=E1logos, =
etc.), de seu nome e, por =FAltimo, do m=E9todo contido na extens=E3o a =
ser chamado. (Nem todas as extens=F5es poder=E3o ser chamadas deste =
modo, pois algumas delas n=E3o adicionam novos m=E9todos ao notes, mas =
sim colora=E7=E3o de syntaxe para alguma nova linguagem, templates, =
etc.) Um exemplo seria um comando, implementado na forma de um script em =
PHP, que formata o c=F3digo Java de acordo com os estilos recomendados =
pela Sun=AE. A string para chamar esta extens=E3o seria a seguinte: =
"Extension.Command.PhpJavaFormater.Execute()".  Todas as extens=F5es que =
adicionam m=E9todos ao Notes poder=E3o ser chamadas pelo m=E9todo =
"Execute()". Em scripts este m=E9todo n=E3o existe, mas o Notes entende =
que a extens=E3o =E9 um script e o executa. No caso de plugins (DLLs, =
DSOs, BPLs), este m=E9todo dever=E1 ser implementado ou ele dever=E1 =
usar o arquivo extension.xml para pedir ao Notes que chame outro =
m=E9todo no lugar dele. As complexidades ficam sempre a cargo do Notes, =
pois os usu=E1rios e os desenvolvedores de extens=F5es podem sempre usar =
um m=E9todo 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 dif=EDcil de responder. Temos pensando em uma estrutura assim =
(de cima para baixo): menus; barra de ferramentas; tabs (para mudar =
entre os arquivos abertos)  e um bot=E3o seletor de projetos (no Notes 2 =
voc=EA poder=E1 abrir v=E1rios projetos ao mesmo tempo, clique no =
bot=E3o para mudar de um para outro); na esquerda um painel vertical =
onde ficaram v=E1rias ferramentas (gerenciador de projetos, gerenciador =
CVS, etc.) e na direita a =E1rea de edi=E7=E3o; um painel horizotal =
(abaixo do editor, mas n=E3o abaixo do painel vertical) com outras =
ferramentas (sa=EDda de compiladores, gerenciador de tarefas, etc.); e, =
por =FAltimo, a barra de status.

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

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

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

    Integra=E7=E3o
    Sendo programadores, estamos cientes de que um editor de c=F3digo =
n=E3o =E9 a =FAnica ferramenta necess=E1ria durante o desenvolvimento.  =
Por isto o Notes 2 ter=E1 uma boa integra=E7=E3o com compiladores, =
debugers, CVS, FTP, etc.  Outros IDEs fazem isto construindo novas =
ferramentas (quase sempre propriet=E1rias)  diferentes daquelas que os =
programadores est=E3o acostumados a usar. Queremos que o Notes 2 se =
integre com as ferramentas que est=E3o a=ED e que voc=EA j=E1 sabe usar. =
Nada de inventar a roda e 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 uma classe ou procedures que nos permitam ler e escrever em programas =
de modo texto - ou seja, comunicarmos atrav=E9s de pipes. =C9 isto que =
precisaremos para nos integrarmos com CVS, compiladores e debugers. =
Alguns aplicativos (como o cvs e o jdb, debuger do java) exigem que =
voc=EA al=E9m de ler sua s=E1ida (stdout) possam tamb=E9m escrever nela =
(stdin). A partir deste c=F3digo ser=E1 necess=E1rio criar o suporte =
para cada ferramenta de forma separada, j=E1 que cada um deste possui =
comandos completamente diferentes. No caso de debugers e compiladores =
este suporte poderia ser feito atrav=E9s de extens=F5es: al=E9m de =
possibilitar que suporte a novos compiladores/debugers seja facilmente =
adicionado, isto diminuiria o n=FAmero de forms linkados diretamente no =
bin=E1rio. As extens=F5es usariam APIs do Notes para que pudessem se =
comunicarem com os aplicativos por pipes de forma mais f=E1cil e =
multi-plataforma. No caso do CVS, o suporte poderia ser interno, j=E1 =
que trata-se de algo amplamente usado. O mesmo com o FTP - mas neste a =
implementa=E7=E3o n=E3o precisaria de um programa externo para rodar =
(existe uma biblioteca SL chamada Synapse para Delphi/Kylix que nos =
permitir=E1 fazer isto facilmente).

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


    CVS
    O gerenciado de CVS do Notes permitir=E1 que voc=EA use esta =
ferramenta de maneira f=E1cil e sem sair da IDE.  O gerenciador estar=E1 =
integrado ao resto do Notes, permitindo por exemplo que um novo projeto =
seja criado a partir do downlod (checkout) de fontes de um servidor =
local ou remoto.  Assim voc=EA podecom facilitade come=E7ar a participar =
de um dos muitos 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 esquecidos. Voc=EA poder=E1 publicar o projeto para um ftp ou para =
uma pasta local e ver o resultado em um dos seus browser - tudo isto sem =
sair da IDE. Da mesma forma, os desenvolvedores de script poder=E3o =
rodar seus aplciativos facilmente. No caso de linguagens de script muito =
usadas e que possuam um debuger padr=E3o, este ser=E1 suportado da mesma =
forma que os debugers para linguagens compiladas.


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

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

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

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

    Implementa=E7=E3o:  relativamente simples. O Notes l=EA primeiro o =
arquivo XML que define a gui. Cada membro da gui possui o nome de uma =
vari=E1vel anexado a ele. Conforme o usu=E1rio manipula a GUI, estes =
valores s=E3o armazenados nas vari=E1veis. Por exemplo, se a GUI possui =
um campo de texto e o usu=E1rio preenche nele "Isto =E9 o valor da =
vari=E1vel" e a vari=E1vel associada ao campo chama-se MinhaVari=E1vel, =
MinhaVari=E1vel armazena a string "Isto =E9 o valor da vari=E1vel".  =
Quando o usu=E1rio clcia OK na GUI, o Notes abre o arquivo de script e =
substitu=ED nele as vari=E1veis pelo valor que o usu=E1rio deu para =
elas. Por exemplo, achando %MinhaVari=E1vel% no script, o Notes a =
substituirpa por "Isto =E9 o valor da vari=E1vel". Depois disto, o Notes =
executa o script. O script cria ent=E3o alguns arquivos: um com a sua =
sa=EDda (normalmente =E9 o texto modificado); outro com erros, quando =
necess=E1rio; e um terceiro que definir=E1 o que o 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 linguagens e melhorar o suporte as linguagens que s=E3o =
suportadas no Notes 2 por padr=E3o. Uma extens=E3o poder=E1 conter =
templates, o arquivo de colora=E7=E3o de c=F3digo para a linguagem, =
snippets, scripts, plugins, etc.=20

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

    Mais detalhes

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

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