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

[Robson C. d. S. <rcs...@ma...>]

  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 =

  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