Re: [Notes2-team] Boas vindas aos novos noteiros!!!
Brought to you by:
andersonrb
Menu
▾
▴
Re: [Notes2-team] Boas vindas aos novos noteiros!!!
|
From: Anderson R. B. <no...@ig...> - 2003-10-19 15:07:37
|
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="content-type"
content="text/html; charset=ISO-8859-1">
<title>pla-n2</title>
</head>
<body>
<font face="Helvetica, Arial, sans-serif"><big
style="font-family: helvetica,arial,sans-serif; font-weight: bold;"><big>Planejamento
do Notes 2</big></big><span
style="font-family: helvetica,arial,sans-serif; font-weight: bold;"> </span><br
style="font-family: helvetica,arial,sans-serif;">
<br style="font-family: helvetica,arial,sans-serif;">
<br style="font-family: helvetica,arial,sans-serif;">
<span style="font-family: helvetica,arial,sans-serif;"><big><span
style="font-weight: bold;">Editando texto</span></big><br>
Para poder atender a todas as sugestões feitas pelos
usuários, a Equipe do Notes decidiu construir um componente
(controle) de edição próprio (baseado no famoso
componente de edição SynEdit). Este componente de
edição funcionara no Windows e no Linux exatamente da
mesma forma. As capacidades dele são discutidas abaixo:<br>
<br>
<big><small style="font-weight: bold;">Coloração de
código</small><br>
<small>Este é o pedido mais frequente dos usuários e, com
a construção do novo componente, poderemos
atendê-lo. O componente usará definições que
ficarão <span style="font-style: italic;">todas </span>em
arquivos XML. Isto significa que a coloração de
código será altamente flexível, podendo ser
configurada em detalhes pelo usuário inclusive permitindo que a
comunidade adicione ao Notes suporte a linguagens não suportadas
pela distribuição padrão.<br>
<span style="font-weight: bold;"><br>
<small style="color: rgb(0, 0, 102);">Implementação:</small></span><small
style="color: rgb(0, 0, 102);"> a implementação da
coloração de código se dará de forma
semelhante a de um editor para Linux chamado Kate. Assim, o texto seria
dividido em blocos definidos através de arquivos XML (por
exemplo: comentário, string, inteiro, etc.) e não por
simples tokens separados por espaços em branco. Para evitar que
o parser fique lento, sugere-se que, como no Kate, existam regras
pré-prontas para detectar alguns tipos de blocos: inteiros,
hexadecimais, octais, ponto flutuante, keyword (pré-definindo
que uma keyword é uma string sem espaços, iniciada por uma
letra e que permite além de letras, número e o caracter
"_"; as keywords são fornecidas pelo arquivo xml). Regras para
diferenciar bloco de textos poderão ser facilmente criadas tanto
usando expressões regulares como tags que permitem procurar por
strings exatas, por um único caracter, </small></small></big></span><span
style="font-family: helvetica,arial,sans-serif; color: rgb(0, 0, 102);"><big><small><small>por</small></small></big><big><small><small>dois
caracteres, </small></small></big><big><small><small>por </small></small></big></span><span
style="font-family: helvetica,arial,sans-serif;"><big><small><small
style="color: rgb(0, 0, 102);">qualquer um dos caracteres listados, e
pelo intervalo entre uma string/caracter e outra. Este modelo foi
escolhido por se encaixar perfeitamente nas idéias da equipe e
por que o modelo é altamente flexível podendo ser usado
para definir a coloração de qualquer linguagem de
programação - seja de script, de marcação,
etc.</small><span style="font-weight: bold;"><br>
<br>
<br>
</span><big>Analisador e corretor de erros / auto-completar</big><span
style="font-weight: bold;"><br>
</span>O editor poderá detectar erros no código enquanto
o usuário digita dispensando o uso de compiladores e debugers
para a localização e correção de erros
simples de programação. Além de detectar os erros,
o editor poderá sugerir correções baseado nas
estruturas padrões da linguagem que o usuário estiver
usando. O corretor poderá ser usado pelo usuário para
completar certas construções. Por exemplo, um
usuário poderá digitar "if (x==y" e pedir para o editor
auto-completar o código, o que o deixaria semelhante a "if
(x==y) { }".<br>
<br>
<small style="color: rgb(0, 0, 102);"><span style="font-weight: bold;">Implementação:</span>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ódigo para ver se ele está de
acordo com os modelos que ele conhece. Se o modelo não estiver
de acordo com a estrutura que o analisador conhece ele marcará o
trecho de código como errado. O usuário poderá
corrigir o erro manaulmente ou através de sugestões dadas
pelo analisador. As sugestões serão feitas de forma a
transformar o bloco reconhecido como errado na estrutura que ele
conhece que for mais parecida com o bloco de código.</small><span
style="font-weight: bold;"><br>
<br>
Debugando<br>
</span></small></big></span><big
style="font-family: helvetica,arial,sans-serif;"><small>O editor teria
a capacidade de setar breakpoints quando informado de que a linguagem
pode ser debugada pelo Notes. Além disto, erros de
compilação seriam marcados, quando possível, de
forma semelhante aos erros marcados pelo analisador. </small></big><br>
<span style="font-family: helvetica,arial,sans-serif;"><big><small><span
style="font-weight: bold;"><br>
Folding</span><br>
Alguns dos editores mais novos permitem que o usuário esconda
certas partes do código. É semelhante a usar o Windows
Explorer (ou o Konqueror/Nautilus no linux) só que no lugar de
poder navegar certas pastas e arquivos, pode-se navegar pelas partes do
seu código. O folding poderá ser controlado pelo
usuário. Bastará selecionar algumas linhas de
código que um pequeno ícone aparecerá: clicando
nele aquela parte do código será escondida, bastando
clicar nele novamente para mostrar a parte escondida novamente.
As áreas de folding poderão ser marcadas também
manualmente: bastará adicionar "{{{" para iniciar uma
área de folding e "}}}" para fechá-la (sem as aspas).
Selecionando as linhas e clicando no ícone para esconder o trecho
o Notes adicionará estes marcadores automaticamente.<br>
<br>
<small style="color: rgb(0, 0, 102);"><span style="font-weight: bold;">Implementação:</span>
será usado como base o código para folding do editor
JediEdit, já que ele não difere muito das
especificações de folding desejado pela equipe.
Modificações serão feitas conforme
necessário para que o comportamento descrito acima seja
alcançado.</small><br>
<br>
</small></big><span style="font-weight: bold;"><br>
Intellisense/Code completion, ToolTip com argumentos e Templates</span><br>
O editor poderá completar nomes de classes, constantes, etc.
como nas IDEs da Microsoft® e da Borland®.<br>
Além disto, mostrará tooltips (dicas) mostrando os
parâmetros de métodos e funções quando o
usuário teclar "(" (ou outro caracter dependendo da linguagem).
Para completar, o editor suportará templates. Estes são
palavras especiais definidas pelo usuário que são
transformadas pelo editor (quando invocado) em uma string maior. Por
exemplo, será possível definir a palavra "class" e
então invocar a função para que o editor
substitua class pela definição de classe da linguagem que
estiver sendo editada. <br>
<br>
<small><span style="font-weight: bold; color: rgb(255, 0, 0);">Implementação:
?????????????</span></small><br>
<br>
<b>Favoritos</b><br>
O Notes 2 usará um modelo de bookmakers diferente do usado em
algumas IDEs (como o Delphi, Context, etc.). Ao invés de limitar
o usuário a nove bookmakers nomeados simplesmente com
números de 0 a 9 - que forçam o usuário a lembrar
a correspondência entre nome do bookmaker e parte do
código de cabeça - a equipe optou por usar um modelo
semelhante ao usado pelo editor jEdit. O usuário
simplesmente dirá ao Notes 2 (clicando no menu, usando atalhos,
etc.) em que linha do código ele quer que o Notes 2 crie o
bookmaker. O Notes 2 criará um bookmaker para aquela linha e
permitirá ao usuário voltar a aquela linha de
várias formas: ele poderá seleciona-lo na lista de
bookmakers - cada item da lsita terá o formato [número da
linha]: "[início da linha]"... (por exemplo: 42 : "if (x==y){ //
fechamos o prog"...) - ou usar itens como "próximo bookmaker" e
"bookmaker anterior". Os bookmakers de cada arquivo serão salvos
no arquivo que contém o projeto que está sendo editado.
Assim o usuário terá eles sempre à mão,
mesmo após fechar e abrir o arquivo.<br>
<br>
<br>
<b>TaskList</b><br>
As tarefas ficarão anotadas diretamente no código fonte,
através de comentários iniciados por certas palavras
chaves (como "TODO:" por exemplo). Estes comentários
serão coletados e mostrados no gerenciador de tarefas. Como as
tarefas ficarão no próprio código, as tarefas
poderão ser facilmente compartilhadas pela equipe mesmo que
alguém da equipe resolva não usar o Notes 2. <br>
<br>
<b>Clipboard History</b><br>
O Notes guardar os últimos trechos de código copiados
para a área de transferência, permitindo ao usuário
colar estes trechos ou reenviá-los para a área de
transferência.<br>
<br>
</span><big style="font-family: helvetica,arial,sans-serif;"><small
style="font-weight: bold;">Split</small><br>
</big><span style="font-family: helvetica,arial,sans-serif;">O velho
edit do DOS e outros editores atuais permitem que o componente de
edição seja dividido em 2. <br>
No Notes 2 está capacidade estará presente, podendo
dividir o editor tanto horizontalmente quanto verticalmente, quantas
vezes o usuário quiser.<br
style="font-family: helvetica,arial,sans-serif;">
</span><br>
<span style="font-weight: bold; color: rgb(255, 0, 0);">Implementação:
????????????</span><br>
<br>
<span style="font-family: helvetica,arial,sans-serif;"><big><span
style="font-weight: bold;">Navegando no Código</span></big></span><br>
<br>
<b>ClassView</b><br>
Permitirá ao usuário visualizar a estrutura do
código e navegar por ela. O ClassView mostrará todas as
classes do arquivo que estiver sendo editado, com todos os
métodos, propriedades, campos, etc.<br>
<br>
<b>Barra com combos para navegação</b><br>
O usuário poderá navegar pelo código usando uma
barra de navegação. Esta barra terá dois bombos -
um listando todas as classes do código e outro mostrando os
métos/propriedades da classe selecionada no primeiro combo.
Selecionando os itens de cada combo o usuário poderá
pular rapidamente para os trechos do código que quiser editar.<br>
<br>
<b> Incremental search</b><br>
O Incremental Search será um localizar diferente:
permitirá ao usuário ver os resultados da
localização enquanto digita o que quer localizar. Por
exemplo, se o usuário quiser localizar "int", quando digitar "i"
o Notes 2 mostrará visualemnte todas as ocorrências de "i"
no texto; quando o usuário digitar o próximo carater
("n") o Notes 2 mostrará todos os "in" existentes no texto; e
assim por diante.<br>
<br>
<b>Indo e vindo nos locais editados</b><br>
Com o Notes 2 o usuário poderá voltar para as partes do
código que recém editou. Toda vez que o usuário
começar a editar uma parte de código muito distante
daquela que ele estava editando anteriormente, o Notes guardará
a localização da região que ele estava editando.
Se o usuário precisar voltar para ela, bastará clicar
numa opção do menu - ele não precisará
lembrar em que linha que ele estava. O Notes guardará a
localização de todas as últimas partes editadas
permitindo ao usuário trabalhar em partes diferentes do
código sem se perder.<br>
<br>
<br style="font-family: helvetica,arial,sans-serif;">
<span style="font-family: helvetica,arial,sans-serif;"><big><span
style="font-weight: bold;">A Interface</span></big><br>
A interface do Notes 2 será altamente configurável. Isso
ocorrerá por que menus e toolbars serão criados a partir
de arquivos XML, ao invés de estarem definidos dentro do
binário. Além disto, o Notes 2 suportará skins
(temas) que poderão alterar os controles (botões, campos
de edição, combos, etc.) e os ícones
padrões. Apesar de altamente configurável,
continuará simples de usar, pois sua organização
seguirá a forma a qual os programadores já estão
acostumados. <br>
<br>
<small style="color: rgb(0, 0, 153);"><span
style="font-weight: bold; color: rgb(0, 0, 102);">Implementação:</span><span
style="color: rgb(0, 0, 102);"> existirão dois arquivos xml, um
que define os menus e outro que define as toolbars. As
ações dos itens dos menus/toolbars serão definidas
pela tag "onClick" de cada um dos itens. Dito de outra forma, a string
definida em onClick é que dirá ao notes o que ele deve
fazer quando o usuário clicar no item. O Notes trará
muitos métodos pré-definidos. Estes métodos
poderão ser chamados usando uma string contendo "Notes." seguido
do nome do método. Por exemplo, ao detectar um click no primeiro
item do primeiro menu, o Notes lê a string contida na tag onClick
do item (seria bom guardar esta string no próprio intem).
Digamos que a string é esta: "Notes.New()". Este método
faz o Notes abrir o diálogo para novos arquivos e projetos - que
é o que ocorre depois de um parser interno entender o que
significa a string. Este mesmo parser será usado para enteder
todos os métodos onClick. Além dos métodos
providos pelo Notes, estarão disponíveis os
métodos das extensões instaladas pelo usuário. A
extensões serão sempre responsáveis por adicionar
itens a menus/toolbars usando as opções do Notes
eXtension Installer. Digamos que o usuário queira usar uma
extensão chamada "SuperSearch" que adiciona ao Notes um
diálogo para fazer pesquisa de milhões de formas
diferentes. O usuário não terá muitos problemas
para isto: basta chamar o Notes eXtension Installer e escolher que
extensão ele quer instalar. De acordo com o script xml de
instalação da extensão, o eXtension Installer
adicionará itens aos menus, aos toolbars, ao ToolBox, etc.
Estes itens também terão a tag onClick, exatamente como
os itens que chamam os métodos do Notes. Mas as strings
onClick começarão com "Extension." ao invés
de "Notes." e serão seguidas de sua categoria (comandos,
diálogos, etc.), de seu nome e, por último, do
método contido na extensão a ser chamado. (Nem todas as
extensões poderão ser chamadas deste modo, pois algumas
delas não adicionam novos métodos ao notes, mas sim
coloração 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ódigo Java de acordo com os
estilos recomendados pela Sun®. A string para chamar esta
extensão seria a seguinte:
"Extension.Command.PhpJavaFormater.Execute()". Todas as
extensões que adicionam métodos ao Notes poderão
ser chamadas pelo método "Execute()". Em scripts este
método não existe, mas o Notes entende que a
extensão é um script e o executa. No caso de plugins
(DLLs, DSOs, BPLs), este método deverá ser implementado
ou ele deverá usar o arquivo extension.xml para pedir ao Notes
que chame outro método no lugar dele. As complexidades ficam
sempre a cargo do Notes, pois os usuários e os desenvolvedores
de extensões podem sempre usar um método padrão
para chamar as extensões.</span><br>
</small><br>
<br>
<big>Como será a interface?<br>
<small>Num programa tão configurável quanto o Notes 2,
esta é uma pergunta difícil 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ão seletor de projetos (no Notes 2 você poderá
abrir vários projetos ao mesmo tempo, clique no botão
para mudar de um para outro); na esquerda um painel vertical onde
ficaram várias ferramentas (gerenciador de projetos, gerenciador
CVS, etc.) e na direita a área de edição; um
painel horizotal (abaixo do editor, mas não abaixo do painel
vertical) com outras ferramentas (saída de compiladores,
gerenciador de tarefas, etc.); e, por último, a barra de status.<br>
<br>
<small style="color: rgb(255, 0, 0);"><span style="font-weight: bold;">Implementação: </span>???
aguardando sugestões sobre como os temas poderão ser
implementados ???</small><br>
</small> </big></span><br>
<span style="font-family: helvetica,arial,sans-serif;"><big>Dando poder
ao teclado<br>
<small>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ão prometemos desde já dar uma
atenção especial a ele. No caso do editor, AutoIndent,
SmartIndent, SmartHome, SmartEnd, SmartPaste ajudarão a diminuir
o tempo que um programador gasta escrevendo e formatando o
código. Além disto, o editor poderá usar
features normalmente só encontradadas em editores da
Borland®, como as setas que podem se movimentar livremente no
texto. Além disto tudo, as teclas de atalho poderão ser
totalmente configuradas. Pensamos até em permitir que algumas
delas mudem conforme a linguagem que se está editando!!!<br>
<br>
<small style="color: rgb(0, 0, 102);"><span style="font-weight: bold;">Implementação:</span>
algumas destas características já vem implementadas no
SynEdit, componente que modificaremos para construir o controle de
edição. No caso do SmatIndent deveremos permitir
que seja configurado, como todo o resto, através de um arquivo
XML para cada linguagem. O arquivo poderá conter
até diferentes estilos de indentação que
poderão ser escolhidos pelo usuário como aquele que ele
quer usar. No caso das teclas de atalho, bastará reusarmos o
parser das tags onClick referido na descrição da
implementação da interface para que façamos elas
altamente configuráveis. </small><br>
</small></big></span><br>
<big style="font-family: helvetica,arial,sans-serif;"><span
style="font-weight: bold;">Integração<br>
</span><small>Sendo programadores, estamos cientes de que um editor de
código não é a única ferramenta
necessária durante o desenvolvimento. Por isto o Notes 2
terá uma boa integração com compiladores,
debugers, CVS, FTP, etc. Outros IDEs fazem isto construindo novas
ferramentas (quase sempre proprietárias) diferentes
daquelas que os programadores estão acostumados a usar. Queremos
que o Notes 2 se integre com as ferramentas que estão aí
e que você já sabe usar. Nada de inventar a roda e
obrigá-lo a aprender algo que você não quer.<br>
<br>
<small><span style="font-weight: bold; color: rgb(0, 0, 102);">Implementação:</span><span
style="color: rgb(0, 0, 102);"> a implementação 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és de pipes. É 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ê além de
ler sua sáida (stdout) possam também escrever nela
(stdin). A partir deste código será necessário
criar o suporte para cada ferramenta de forma separada, já que
cada um deste possui comandos completamente diferentes. No caso de
debugers e compiladores este suporte poderia ser feito através
de extensões: além de possibilitar que suporte a novos
compiladores/debugers seja facilmente adicionado, isto diminuiria o
número de forms linkados diretamente no binário. As
extensões usariam APIs do Notes para que pudessem se comunicarem
com os aplicativos por pipes de forma mais fácil e
multi-plataforma. No caso do CVS, o suporte poderia ser interno,
já que trata-se de algo amplamente usado. O mesmo com o FTP -
mas neste a implementação não precisaria de um
programa externo para rodar (existe uma biblioteca SL chamada Synapse
para Delphi/Kylix que nos permitirá fazer isto facilmente).</span></small><br>
</small></big><br style="font-family: helvetica,arial,sans-serif;">
<big style="font-family: helvetica,arial,sans-serif;"><small
style="font-weight: bold;">Compiladores e debugers<br>
</small><small>O Notes suportaria por padrão os compiladores
mais usados no windows (vc++, delphi, free pascal, gcc, java,
etc.) e no linux (gcc e suas variações, java,
kylix, etc.). Para cada compilador (o compilador do projeto será
escolhido pelo usuário nas propriedades do projeto) o Notes
exibirá um diálgo diferente, permitindo que o
usuário configure todas as opções do compilador
como se estivesse usando uma IDE específica para a sua
linguagem. Quanto aos debugers, </small></big><big
style="font-family: helvetica,arial,sans-serif;"><small>seriam
suportados aqueles mais usados, como o GNU Debuger, o jdb, etc. </small><small
style="font-weight: bold;"><br>
</small></big><big style="font-family: helvetica,arial,sans-serif;"><small
style="font-weight: bold;"><br>
</small><small style="font-weight: bold;"><br>
CVS<br>
</small><small>O gerenciado de CVS do Notes permitirá que
você use esta ferramenta de maneira fácil e sem sair da
IDE. O gerenciador estará 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ê podecom facilitade começar a participar de um
dos muitos projetos de software livre existentes!</small><small
style="font-weight: bold;"><br>
<br>
<br>
Sites dinâmicos e Linguagens de Script<br>
</small><small>Os desenvolvedores de sites dinâmicos (php, jsp,
asp, etc.) não foram esquecidos. Você poderá
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ão rodar seus
aplciativos facilmente. No caso de linguagens de script muito usadas e
que possuam um debuger padrão, este será suportado da
mesma forma que os debugers para linguagens compiladas.</small><small
style="font-weight: bold;"><br>
<br>
<br>
</small><span style="font-weight: bold;">Extensibilidade<br>
</span><small>Por mais que nos esforcemos, nunca poderemos oferecer
tudo o que um usuário precisa. Há ferramentas que
são muito específicas, isto é, úteis apenas
para uma linguagem ou para alguns poucos usuários. Há
linguagens que não existem ainda ou outras, mais antigas, que
poderão não ser suportadas por padrão quando o
Notes 2 for lançado. E além disto, todos os membros da
equipe são humanos! Para resolver o problema, o Notes 2
será altamente extensível: você poderá
adicionar suporte a novas linguagens, criar novos comandos na sua
linguagem de script preferida para fazer pequenas
modificações no código ou, até mesmo,
escrever novos diálogos e ferramentas - plugins - em C/C++,
Object Pascal, etc. Além de tudo isto, as extensões
poderão ser instaladas através do Notes e farão
todas as modificações necessárias para que
você possa sair usando elas sem precisar ler manuais complicados.<br>
<br>
<big>Plugins<br>
<small>Os plugins serão as extensões mais poderosas no
Notes 2. Isto por que os plugins terão acesso a uma API do
Notes, feita especialmente para eles. Com isto poderão conseguir
todo tipo de informações que precisarem, poderão
alterar certos comportamentos, capturar eventos, usar bibliotecas do
Notes (como a de expressões regulares ou a de
configurações), etc. Um plugin poderá implementar
"serviços" (um novo comportamento, como inserir uma quebra de
linha toda vez que você digitar "{"), diálogos, novas
ferramentas que podem ser dockadas aos painéis do Notes 2, etc.<br>
<br>
<small style="color: rgb(0, 0, 102);"><span style="font-weight: bold;">Implementação:</span>
o código para a implementação dos plugins já
existe, então não há tanto trabalho pela frente.
Talvez a maior dificuldade seja o que incluiremos na API - pois
precisamos saber extamente de que métodos temos para poder
permitir que plugins usem eles. </small><br>
</small> <br>
Scripts<br>
<small>No Notes 2 você poderá usar a sua linguagem de
scripts preferida para adicionar novas ferramentas ao Notes (claro que
você precisará ter o interpretador já instalado,
não dá para querer que o Notes aprenda a interpretar
todas as linguagens de scripts existentes). Outra novidade
é que você poderá ter interfaces simples para o seus
scripts - usando apenas a sua linguagem de script e um pouco de XML
(que é fácil). Com isto você poderá
adicionar, por exemplo, um botão na barra de ferramentas que,
quando acionado, mostre ao usuário um diálogo com
várias opções permitindo a ele criar uma tabela
HTML em poucos segundos. <br>
<br>
</small></big></small></big><big
style="font-family: helvetica,arial,sans-serif;"><small><big><small><small
style="color: rgb(0, 0, 102);"><span style="font-weight: bold;">Implementação:</span>
relativamente simples. O Notes lê primeiro o arquivo XML que
define a gui. Cada membro da gui possui o nome de uma variável
anexado a ele. Conforme o usuário manipula a GUI, estes valores
são armazenados nas variáveis. Por exemplo, se a GUI
possui um campo de texto e o usuário preenche nele "Isto
é o valor da variável" e a variável associada ao
campo chama-se MinhaVariável, MinhaVariável armazena a
string </small></small></big></small></big><small
style="color: rgb(0, 0, 102); font-family: helvetica,arial,sans-serif;"><big><small>"Isto
é o valor da variável". Quando o usuário
clcia OK na GUI, o Notes abre o arquivo de script e substituí
nele as variáveis pelo valor que o usuário deu para elas.
Por exemplo, achando %MinhaVariável% no script, o Notes a
substituirpa por </small></big></small><small
style="color: rgb(0, 0, 102); font-family: helvetica,arial,sans-serif;"><big><small>"Isto
é o valor da variável". Depois disto, o Notes executa o
script. O script cria então alguns arquivos: um com a sua
saída (normalmente é o texto modificado); outro com
erros, quando necessário; e um terceiro que definirá o
que o Notes fará com a suas saída.</small></big></small><br>
<big style="font-family: helvetica,arial,sans-serif;"><small><big><br>
Suporte a novas linguagens<br>
</big>Através das extensões será possível
também adicionar suporte a outras linguagens e melhorar o
suporte as linguagens que são suportadas no Notes 2 por
padrão. Uma extensão poderá conter templates, o
arquivo de coloração de código para a linguagem,
snippets, scripts, plugins, etc. </small><span
style="font-weight: bold;"><br>
<br>
</span><b>A ajuda do Notes 2</b><br>
<small>A ajuda do Notes 2 trará todas as
informações sobre como operar o Notes 2, tutoriais para
os novos usuários e ferramentas que facilitarão a
resolução de dúvidas ligadas as linguagens
suportadas pelo Notes. A ajuda estará totalmente integrada a
IDE, não tendo nenhuma dependência de sistemas exteriores
e/ou proprietários. Em um painel - organizado de forma
semelhante ao toolbox - o usuário terá acesso a
três ferramentas: "NotesStart"; "Ajuda do Notes 2"; e "Ajuda das
linguagens". O NotesStart será um painel que trará links
para aquilo que quem está iniciando a usar o Notes precisa -
permitindo abrir os trechos mais importantes da
documentação e realizar as tarefas mais comuns. A
"Ajuda do Notes" possuirá um índice de toda a
documentação do Notes 2 e dará ao usuário a
possibilidade de procurar na documentação. A "Ajuda das
linguagens" permitirá ao usuário procurar por
informações nos sites mais importantes sobre a linguagem
que está usando e trará links para fórums, listas
de discussão, etc. Em resumo: a Ajuda do Notes trará
várias ferramentas permitindo ao usuário ir muito
além do acesso a documentação, procurando
guiá-lo as melhores soluções para as suas
dúvidas de forma rápida e intuitiva.</small><br>
</big><big style="font-family: helvetica,arial,sans-serif;"><span
style="font-weight: bold;"><br>
</span><span style="font-weight: bold;">Mais detalhes</span><br>
<br>
ToolBox<small><br>
O Notes SE incluia o menu inserir. Apesar de ser altamente funcional,
ele tinha um problema: você tinha que navegar pelos submenus
até achar o que queria inserir. Para solucionar este problema, a
equipe do Notes incluirá um ToolBox no painel vertical, que
facilitará o acesso aos códigos do menu inserir.<br>
<br>
<big>Ferramentas para SQL e XML<small><br>
O Notes 2 incluirá também ferramentas para que você
possa manipular banco de dados, construir querys SQL com facilidade e
editar visualmente arquivos XML.</small></big></small></big></font>
</body>
</html>
|
