notes2-team Mailing List for Notes (Page 27)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

  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

2003	Jan	Feb	Mar (11)	Apr (21)	May (57)	Jun (79)	Jul (76)	Aug (24)	Sep (58)	Oct (187)	Nov (134)	Dec (81)
2004	Jan (30)	Feb (42)	Mar (60)	Apr (23)	May (6)	Jun (32)	Jul (14)	Aug (10)	Sep (6)	Oct (6)	Nov (4)	Dec (2)
2005	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct (1)	Nov	Dec
2006	Jan	Feb (1)	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov (6)	Dec (3)
2007	Jan (2)	Feb (2)	Mar	Apr (1)	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec

notes2-team Mailing List for Notes (Page 27)

notes2-team — Notes developers mailing list.