[Notes2-team] Infos e mais uma parte da viagem nos sources do Notes

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
  <meta content="text/html; charset=ISO-8859-1"
 http-equiv="content-type">
  <title>ManipulandoOsEditores</title>
</head>
<body>
<big><big><span style="font-weight: bold;">Uma viagem aos sources do
Notes - parte III</span><br style="font-weight: bold;">
<span style="font-weight: bold;">Implementando novos comandos no editor</span></big></big><br>
<br>
Na terceira parte da nossa viagem aos sources do Notes, finalmente
vamos explorar o editor! Melhor ainda, o texto inteiro estar&aacute;
"baseado em fatos reais" - enquanto escrevo isto, estamos h&aacute;
poucos dias do lan&ccedil;amento do alpha 3 do Notes 2004 e eu estarei
implementando no Notes o que estarei ensinando voc&ecirc; a fazer aqui.<br>
<br>
A feature que vamos implementar ser&aacute; uma bem conheciada dos
editores de c&oacute;digo: permitir ao usu&aacute;rio converter tabs
para espa&ccedil;os e vice-versa. Criaremos duas novas
a&ccedil;&otilde;es de formata&ccedil;&atilde;o do c&oacute;digo que
permitem ao usu&aacute;rio fazer isto. Na parte II voc&ecirc; aprendeu
a criar a&ccedil;&otilde;es e coloc&aacute;-las no menu, ent&atilde;o
n&atilde;o preciso explicar novamente como se faz isto. Eu criei duas
a&ccedil;&otilde;es ("actEditFormatSpacesToTabs" e
"actEditFormatTabsToSpaces") e coloquei elas em Editar &gt;&gt;
Formatar, junto com outras a&ccedil;&otilde;es que est&atilde;o ligadas
a formata&ccedil;&atilde;o do c&oacute;digo.<br>
<br>
Ap&oacute;s criadas as a&ccedil;&otilde;es e os items dos menus,
lembrei-me que t&iacute;nhamos que desabilitar estas
a&ccedil;&otilde;es quando nada estivesse selecionado ou quando o texto
fosse readonly. Ainda bem que o Notes, j&aacute; tem como fazer isto de
maneira bem f&aacute;cil, bastou adicionar o c&oacute;digo a seguir no
"FormCreate" do formul&aacute;rio principal e estava pronto:<br>
<br>
<table
 style="width: 100%; text-align: left; background-color: rgb(243, 243, 243);"
 border="0" cellpadding="2" cellspacing="2">
  <tbody>
    <tr>
      <td style="vertical-align: top;">
      <pre>// Habilita as a&ccedil;&otilde;es apenas quando houver sele&ccedil;&atilde;o e o texto n&atilde;o for readonly<br>ActionMan.ControlAction(actEditFormatTabToSpaces, [ecHasSelection, ecNotReadonly]);<br>ActionMan.ControlAction(actEditFormatSpacesToTabs, [ecHasSelection, ecNotReadonly]);      </pre>
      </td>
    </tr>
  </tbody>
</table>
<br>
Olhando o c&oacute;digo da unit frm_Princ (que &eacute; onde
est&aacute; o form principal) vemos que as a&ccedil;&otilde;es do menu
editar n&atilde;o est&atilde;o implementadas nela e sim em um objeto
chamado "tabs". Este &eacute; um objeto da classe "TNotesTabsManager",
o gerenciador de tabs do Notes. O objeto tabs permite criar novas
tabs/editores, fechar tabs, etc. H&aacute; algum tempo o tamanho da
Unit "frm_Princ.pas" era gigantesco e por isso refactorings foram
feitos distribuindo todo aquele c&oacute;digo para novas Units, como
por exemlo a "NotesTabsManager.pas". Bom, olhando est&aacute; unit
descobrimos mais uma coisinha: na verdade tamb&eacute;m n&atilde;o
&eacute; nela que os m&eacute;todos est&atilde;o implementados! Na
verdade tudo que ela faz &eacute; verificar se um editor est&aacute;
ativo e repassar para o editor ativo a a&ccedil;&atilde;o pedida
l&aacute; no form principal. <br>
<br>
<span style="font-style: italic;">- Oh God! Para que esse passa-repassa
de tarefas de uma unit para outra e para outra? Parece at&eacute; fila
do SUS! Isso vai deixar tudo mais lento!</span><br>
<br>
Em teoria, vai ficar mais lento. Na pr&aacute;tica, o usu&aacute;rio
nunca, nunca conseguir&aacute; perceber a diferen&ccedil;a. Chamadas de
m&eacute;todos com at&eacute; dois par&acirc;metros s&atilde;o chamados
sem precisar acessar a mem&oacute;ria, pois os par&acirc;metros
s&atilde;o movidos diretamente para os registradores do processador, o
que &eacute; absurdamente r&aacute;pido. Se voc&ecirc; n&atilde;o
confia em mim, pergunte para qualquer guru de Delphi. Isto tudo tem uma
vantagem, apesar de dar um poquinho mais de trabalho para n&oacute;s:
esse passa e repassa de tarefas cria layers entre um peda&ccedil;o e
outro do programa o que evita que voc&ecirc; tenha que reescrever muito
c&oacute;digo para substituir um dos componentes (por exemplo, se
f&oacute;ssemos trocar de controle de edi&ccedil;&atilde;o,
provavelmente n&atilde;o ter&iacute;amos que reescrever muita coisa).<br>
<br>
Bom, ent&atilde;o vamos para a Unit "NotesEditorTab.pas", pois &eacute;
l&aacute; que toda a divers&atilde;o acontece! Logo voc&ecirc; vai
perceber que op&ccedil;&otilde;es semelhantes a que estamos
implementando est&atilde;o na classe TNotesEditorTab... n&atilde;o
precisa ser um g&ecirc;nio pra adivinhar que &eacute; nela que
deveremos colocar nossos novos m&eacute;todos, n&atilde;o?! Colocamos o
c&oacute;digo abaixo na parte p&uacute;blica da classe:<br>
<br>
<table
 style="width: 100%; text-align: left; background-color: rgb(243, 243, 243);"
 border="0" cellpadding="2" cellspacing="2">
  <tbody>
    <tr>
      <td style="vertical-align: top;">{ Converte tabs para
espa&ccedil;os }<br>
procedure TabsToSpaces;<br>
{ Converte espa&ccedil;os para tabs }<br>
procedure SpacesToTabs;<br>
      </td>
    </tr>
  </tbody>
</table>
<br>
Pronto. Se voc&ecirc; nunca escreveu classes/componentes no Delphi,
provavelmente n&atilde;o sabe, mas o pr&oacute;ximo passo pode ser dado
pelo editor do Delphi. Use a tecla de atalho Ctrl+Shift+C para que o
delphi crie o c&oacute;digo inicial dos nossos m&eacute;todos:<br>
<br>
<table
 style="width: 100%; text-align: left; background-color: rgb(243, 243, 243);"
 border="0" cellpadding="2" cellspacing="2">
  <tbody>
    <tr>
      <td style="vertical-align: top;">procedure
TNotesEditorTab.SpacesToTabs;<br>
begin<br>
      <br>
end;<br>
      <br>
procedure TNotesEditorTab.TabsToSpaces;<br>
begin<br>
      <br>
end;<br>
      </td>
    </tr>
  </tbody>
</table>
<br>
A implementa&ccedil;&atilde;o dos m&eacute;todos &eacute; bem simples:<br>
<br>
<table
 style="width: 100%; text-align: left; background-color: rgb(243, 243, 243);"
 border="0" cellpadding="2" cellspacing="2">
  <tbody>
    <tr>
      <td style="vertical-align: top;">procedure
TNotesEditorTab.SpacesToTabs;<br>
var<br>
&nbsp; S: string;<br>
begin<br>
&nbsp; if fEditor.SelAvail then<br>
&nbsp; begin<br>
&nbsp;&nbsp;&nbsp; S:= StringOfChar(#32, fEditor.TabWidth);<br>
&nbsp;&nbsp;&nbsp; fEditor.SelText:= StringReplace(fEditor.SelText, S,
#9, [rfReplaceAll]);<br>
&nbsp; end;<br>
end;<br>
      <br>
procedure TNotesEditorTab.TabsToSpaces;<br>
var<br>
&nbsp; S: string;<br>
begin<br>
&nbsp; if fEditor.SelAvail then<br>
&nbsp; begin<br>
&nbsp;&nbsp;&nbsp; S:= StringOfChar(#32, fEditor.TabWidth);<br>
&nbsp;&nbsp;&nbsp; fEditor.SelText:= StringReplace(fEditor.SelText, #9,
S, [rfReplaceAll]);<br>
&nbsp; end;<br>
end;<br>
      </td>
    </tr>
  </tbody>
</table>
<br>
Para acessar o editor mesmo, usamos o campo fEditor (vari&aacute;vel).
O Notes usa o SynEdit como componente de edi&ccedil;&atilde;o. O
TNotesEditor serve apenas como uma classe que agrupa uma Tab e um
SynEditor (Editor + Tab = NotesEditorTab). Para aprender a usar o
SynEdit n&atilde;o h&aacute; outro modo sen&atilde;o dar uma olhada no
c&oacute;digo dele - infelizmente ele n&atilde;o vem com
documenta&ccedil;&atilde;o alguma. (Por&eacute;m alguns m&eacute;todos
e propriedades s&atilde;o bem semelhantes ao do TMemo e do TRichEdit.)
A propriedade SelText que voc&ecirc; v&ecirc; acima permite manipular o
texto selecionado. O que fazemos &eacute; criar uma string com
espa&ccedil;os do tamanho de um caracter tab e trocar esta string pelo
caracter tab ou vice-versa.<br>
<br>
Implementado isto, temos que implementar m&eacute;todos na classe
TNotesTabsManager que chamem nossos novos m&eacute;todos. Eles ficariam
assim:<br>
<br>
<table
 style="width: 100%; text-align: left; background-color: rgb(243, 243, 243);"
 border="0" cellpadding="2" cellspacing="2">
  <tbody>
    <tr>
      <td style="vertical-align: top;">{ Converte tabs para
espa&ccedil;os }<br>
procedure EditorTabsToSpaces(Sender: TObject);<br>
{ Converte espa&ccedil;os para tabs }<br>
procedure EditorSpacesToTabs(Sender: TObject);<br>
      </td>
    </tr>
  </tbody>
</table>
<br>
Note que temos uma novidade - o par&acirc;metro Sender. Ele &eacute;
necess&aacute;rio por que assinalaremos nossos m&eacute;todos ao evento
OnExecute das a&ccedil;&otilde;es que criamos (lembra delas?). Use o
truque do Ctrl+Shift+C e vejamos a implementa&ccedil;&atilde;o:<br>
<br>
<table
 style="width: 100%; text-align: left; background-color: rgb(243, 243, 243);"
 border="0" cellpadding="2" cellspacing="2">
  <tbody>
    <tr>
      <td style="vertical-align: top;">procedure
TNotesTabsManager.EditorSpacesToTabs(Sender: TObject);<br>
begin<br>
&nbsp; if ActiveEditorTab &lt;&gt; nil then<br>
&nbsp;&nbsp;&nbsp; ActiveEditorTab.SpacesToTabs;<br>
end;<br>
      <br>
procedure TNotesTabsManager.EditorTabsToSpaces(Sender: TObject);<br>
begin<br>
&nbsp; if ActiveEditorTab &lt;&gt; nil then<br>
&nbsp;&nbsp;&nbsp; ActiveEditorTab.TabsToSpaces;<br>
end;<br>
      </td>
    </tr>
  </tbody>
</table>
<br>
N&oacute;s chamamos a fun&ccedil;&atilde;o "ActiveEditorTab" para
descobrirmos se h&aacute; um editor ativo (se n&atilde;o houver, ela
retornar&aacute; nil). Depois usamos ela para acessar o TNotesEditorTab
que est&aacute; ativo e assim chamar os m&eacute;todos
rec&eacute;m-criados nesta classe. Esta fun&ccedil;&atilde;o
ActiveEditorTab pode ser acessada em qualquer unit do Notes que tenha
no uses a unit "NotesGlobals".<br>
<br>
Estamos quase l&aacute;! Agora s&oacute; precisamos associar estes
novos m&eacute;otodos ao evento OnExecute dentro do m&eacute;todo
Initialize (que &eacute; chamado quando o Notes est&aacute; carregando
mas j&aacute; est&aacute; vis&iacute;vel ao usu&aacute;rio) do form
principal:<br>
<br>
<table
 style="width: 100%; text-align: left; background-color: rgb(243, 243, 243);"
 border="0" cellpadding="2" cellspacing="2">
  <tbody>
    <tr>
      <td style="vertical-align: top;">&nbsp;
actEditFormatTabToSpaces.OnExecute:= tabs.EditorTabsToSpaces;<br>
&nbsp; actEditFormatSpacesToTabs.OnExecute:= tabs.EditorSpacesToTabs;<br>
      </td>
    </tr>
  </tbody>
</table>
<br>
E por hoje era s&oacute; pessoal! Para complementar o que voc&ecirc;
aprendeu hoje, d&ecirc; uma olhada em todas estas units por quais
passamos, principalmente nas partes comentadas :)<br>
Anderson<br>
&nbsp;&nbsp;&nbsp; <br>
</body>
</html>