Seções iMasters
CMS + Flash

Diga “adeus” ao EventDispatcher e “olá” ao NResponder – Parte 01

E aí, galera! Sejam bem vindos!

Hoje eu quero mostrar para vocês algo chamado Nineveh Responder Engine, ou apenas NResponder. Para ser o mais claro possível, vou falar apenas sobre 4 tópicos, nada mais:

  • Nineveh o quê? Que negócio é esse? Para que serve?
  • Características do NResponder: E o que ele tem de especial?
  • Usos do NResponder: E como é que usa isso?
  • Exemplo REAL: NResponder na prática! (veremos isso na segunda parte do artigo)

OK, vamos começar, então!

Nineveh o quê?

Nineveh é a forma em inglês para o nome Nínive. Ele  é um novo Framework para AS3 que está em desenvolvimento. Ele é muito prático e direto, inspirado na lógica de programação C e Objective-C.

O Nineveh Framework é cheio de engines e APIs que funcionam de forma independente, assim eles podem funcionar perfeitamente mesmo fora do contexto do framework. E o Nineveh Responder é um desses engines.

OK, então que tipo de engine é o NResponder afinal? Uma Engine de Eventos!

Por muitos anos, eu usei a API nativa de Eventos do Flash framework, o famigerado EventDispatcher. Mais de 80% do framework nativo do Flash é herdado dessa “classezinha”. Eu a acho muito chata e ruim, já que:

  • Você tem que criar uma instância direta ou herdada do EventDispatcher.
  • Adicionar suas listas de retorno nessa instância.
  • Criar um muito limitado e restrito tipo de classe-evento, que na maioria dos casos ainda vem herdado da classe Event. E, para completar, é obrigado a usar somente este parâmetro para disparar seus eventos.
  • Criar uma nova instância dessa classe-evento.
  • Disparar seu evento usando a instância criada do EventDispatcher (isto é, se você ainda tiver acesso àquela instância na hora de disparar).
  • Esperar pelas fases de Capture, Target e Bubbling.

Bom, se você também não gosta do EventDispatcher, então NResponder é para você! Se você é completamente novo em Eventos no Flash e veio aqui para saber sobre Eventos, então NResponder é para você também!

NResponder é muito mais rápido que a API Nativa de Eventos do Flash. E uma das melhores coisas é que ele não precisa de instância nenhuma, se você não quiser. Ele consegue controlar e distribuir todos os eventos dentro de uma aplicação inteira.

Imagine que, em uma aplicação, você tem 3 botões no palco principal e carrega logo de início um outro SWF rodando um vídeo. Quando você pressionar um dos 3 botões, o vídeo que está tocando no outro SWF deve parar, porque um novo SWF será carregado por cima de tudo para apresentar um conteúdo.

Isso é bem similar ao comportamento de muitos sites.

Agora pense que, usando o EventDispatcher, você certamente teria que percorrer um longo caminho desde o clique no botão até finalmente para o vídeo e carregar o novo SWF.

Mas é aí que entra o NResponder. Tudo que você precisará com o NResponder são apenas duas linhas de código: uma no botão, outra no player do vídeo! Nada mais!

Veja, isso é apenas um comportamento natural do NResponder, porque ele não precisa utilizar instâncias. Você pode usá-lo para tudo relacionado a eventos, ações do mouse, eventos do teclado, eventos de multi-touch, tudo!

E assim como o título do artigo, você pode dizer definitivamente “adeus” ao EventDispatcher.

OK, agora você já sabe o que é NResponder. Você pode obter mais informações sobre ele na página do projeto no Google: http://code.google.com/p/nineveh-responder/ ou no meu blog, http://db-in.com/blog/nineveh-framework/nresponder/. Clique aqui para fazer o download dos fontes do NResponder: http://nineveh-responder.googlecode.com/files/Nineveh-Responder.zip

Obviamente você pode seguir a Wiki da página do projeto no Google ou ver a documentação completa do NResponder, mas aqui neste tutorial vou mostrar passo a passo como utilizar o grande poder do NResponder na sua aplicação.

Agora vamos em frente.

Características do NResponder

Antes de falar das características do NResponder, quero fazer uma comparação. Na tabela a seguir, você pode ver a API Nativa de Eventos do Flash (EventDispatcher e companhia) comparada com o NResponder.

Feature Event API
(Adobe® Flash®)
NResponder
(Diney Bomfim)
Used without instance não sim
Used with instance sim sim
Specify number of dispatch arguments não sim
Dynamic dispatch arguments não sim
Change dispatch arguments in Run-Time não sim
Remove all não sim
Specify a delay time não sim
Set the number of replies não sim
Ordenate sim sim
Can associate with a target sim sim
Can pause without remove não sim
Can stop propagation sim sim
Change attributes in Run-Time não sim
Garbage Collect only weak references sim

Neste artigo, vou focar nas características mais usadas.

  • Modo instanciado e estático

Com o NResponder, você pode escolher o melhor jeito de trabalhar. Use-o como uma classe estática, sem criar instâncias ou variáveis, ou, se preferir, use-o como uma instância, assumindo uma programação mais orientada a objeto.

O importante é saber que não há diferença entre os dois modos, ambos coexistem sem problemas, o que muda para você é que com o modo instanciado, você tem mais controle sobre o NResponder após criá-lo. Mas, em contrapartida, também se torna responsável por deletar aquela instância quando não precisar mais dela.

  • Múltiplos parâmetros e mudanças no disparo

Este é um dos meus favoritos. Como você sabe, utilizando a API Nativa de Eventos do Flash, você PRECISA e DEVE informar apenas UMA instância de evento como parâmetro na hora de disparar. E suas funções de retorno precisam esperar aquele tipo de evento.

Por exemplo, quando deve ter:

eventDispatcherInstance.addEventListener("aCustomEvent", callBackFunction);
eventDispatcherInstance.dispatchEvent(new MyCustomEvent("aCustomEvent"));
...
private function callBackFunction(event:MyCustomEvent):void
{
...
}

Isso é muito chato! Porque se você quiser passar algum parâmetro para a função callBackFunc-tion(), neste caso, você precisa criar uma variavel dentro da sua classe de evento e ler essa variável dentro dessa função! Muito trabalho, né?

Com o NResponder, você pode se esquecer disso, já que é possível passar quantos parâmetros quiser diretamente para a sua função de retorno, e ela pode ficar deste jeito:

private function callBackFunction(aNumber:Number, aString:String, customOb-ject:ACustomObject):void
{
...
}

Isso já dá a você muito mais flexibilidade para trabalhar! Imagine que agora você pode reutilizar essa função várias vezes, sem ter que passar um parâmetro null ou algo do tipo para um função que só aceita MyCustomEvent!

  • Número de respostas

Este é também um dos meus favoritos, se não for o mais. Com essa simples característica, você pode, de forma muito simples, especificar um número de respostas no qual o seu evento (ou Ação) irá acontecer, independentemente de quantas vezes.

Veja, um exemplo muito comum é usado em classes de View (seguindo um modelo de MVC). Como você sabe, quando você inicia uma classe de View, ela pode não estar presente no palco, então sua propriedade de “stage” será nula. Para resolver isso, costuma-se usar a seguinte técnica:

public function Main()
{
if (this.stage)
{
init(null);
}
else
{
this.addEventListener(Event.ADDED_TO_STAGE, init);
}
}

public function init()
{
if (this.hasEventListener(Event.ADDED_TO_STAGE))
{
this.removeEventListener(Event.ADDED_TO_STAGE, init);
}
}

Você precisa adicionar e remover, fazer checkagem com hasEventListener() para evitar erros, tudo para usar essa rotina uma única vez!

Já com NResponder, só o que você precisa fazer é especificar o número de respostas, nesse caso, para 1, nada mais. E ele também será o responsável, depois da última resposta que você definiu, por limpar toda a sujeira, remover o evento, deletar o que for preciso e ainda livrar memória da aplicação.

  • Intervalo entre disparos

Esta característica pode ser muito útil em alguns casos. Esse intervalo refere-se ao tempo, em segundos, que será o mínimo necessário entre dois disparos consecutivos.

Por exemplo, você tem um botão no seu jogo que o usuário precisa clicar continuamente. Mas você não quer que ele clique como um louco no botão, você quer que, no mínimo, haja meio segundo entre dois cliques consecutivos. Com o NResponder, tudo que você precisa fazer é especificar esse número e pronto! O NResponder vai cuidar de todo o funcionamento dessa dinâmica para você.

  • Remover com combinações

Com a API Nativa de Eventos, se você tiver um monte de listas adicionadas e depois quiser removê-las, precisa fazer isso uma por uma.

Com o NResponder, você pode remover tudo de uma só vez, ou fazer remoções combinadas, como remover todos os registros relacionados a uma função de retorno, ou todos os registros relacionados a um alvo, ou mesmo remover todos os registros de um tipo de evento (ação na linguagem do NResponder), como Mouse.CLICK ou Keyboard.KEY_DOWN.

Não se preocupe se essa última parte não fez muito sentido agora, você vai entender mais claramente nos exemplos mais adiante.

OK, essas são as características mais importantes do NResponder. Eu não vou falar aqui sobre as características que possuem uma equivalente na API Nativa de Eventos, como ordenar e parar propagação, suponho que você já conheça essas características do velho EventDispatcher.

Mais uma coisa

Algo que alguns podem pensar até aqui é: “oK, você falou sobre MouseEvent, KeyboardEvent, TouchEvent, e disse que eu poderia dizer Adeus ao EventDispatcher, mas esses tipos de evento não são relacionados diretamente a API Nativa de Eventos, como é isso então?”.

Yeah, você está certo!

Com o NResponder, você pode dizer Adeus ao EventDispatcher.

Mas, se você quiser, o NResponder fornece uma maneira de você trabalhar com os eventos nativos (apenas os eventos como o MouseEvent, KeyboardEvent, e todos os outros).

Obviamente que para trabalhar com esse tipo de evento, o NResponder precisa usar uma pequena parte da API Nativa de Eventos, porque no Flash é a única forma de se conseguir capturar esses eventos. Mas, novamente, NResponder pode fazer isso muito mais rápido e melhor que a API Nativa de Eventos.

Usos do NResponder

Mãos à obra!

Agora é bom que você tenha em mãos os arquivos fonte do NResponder, você pode baixá-los aqui.

Por enquanto, vamos apenas criar um projeto vazio onde teremos apenas alguns “prints” (trace) na tela. Você vai precisar de uma IDE para compilar e depurar o código, como Flash Professional, Flash Builder, Flash Develop, FDT etc.

OK, vamos codificar!

  • Modo instanciado e estático

Bom, a primeira coisa é importar a classe de acesso do NResponder para as suas classes. Algumas IDEs podem fazer isso automaticamente à medida que você vai codificando (Flash Builder, FDT, Flash Develop, entre outras).

NResponder fica no caminho que começa no pacote “appkit” (um SubFramework do Nineveh Framework) e dentro deste, no pacote “responders”. Esse caminho é apenas uma convenção de organização do Nineveh Framework. 

package
{
import flash.display.MovieClip;

import appkit.responders.NResponder;

public class Main
{
public function Main():void
{
}
}
}

Agora, sobre o modo instanciado e estático. Toda vez que você criar um novo NResponder (registrar um evento, adicionar uma função de retorno, tanto faz, é tudo a mesma coisa para o NResponder), ele vai criar uma pequena e uma leve instância de “Responder”; essa instância vai para dentro do núcleo de processamento do NResponder e será ela a responsável por executar os comando dentro do motor do núcleo. Esse é o funcionamento do NResponder, ele sempre fará isso independentemente do modo que você estiver utilizando.

O legal aqui é que você pode ficar com uma copia dessa pequena instância quando você criar um novo NResponder. E você tem varias formas para pegar essa instância.

Importante: O código a seguir não é funcional, ele é apenas para ilustrar como usar os modos estáticos e instanciados. Na próxima seção (Criando um NResponder), você verá códigos mais funcionais.

package
{
import flash.display.MovieClip;

import appkit.responders.NResponder;

public class Main
{
public function Main():void
{
// This is the static mode
NResponder.add();

// This is the instantiated mode.
var responder:NResponder;

responder = new NResponder();
// Or even
responder = NResponder.add();
}
}
}

Você pode estar se perguntando: “espera, ok, só um minuto, que o construtor “new” crie uma instância tudo bem, mas por que uma chamada estática faria o mesmo?”

Bem, você entenderá isso logo, o construtor “new” é algo genérico, com ele você pode criar todo tipo de NResponder. Já os métodos “adds” (no plural porque tem mais de um add) têm alguns atalhos para que você não fique criando linhas muito longas de código. Como mencionei antes, o NResponder pode trabalhar com os eventos nativos do Flash, para isso ele tem um método “add” específico. Embora o construtor padrão “new” possa criar qualquer tipo de NResponder, você precisa passar mais parâmetros para ele.

Os modos instanciados e estáticos não impactam absolutamente em nada na performance e na memória da sua aplicação. A única razão para usar o modo instanciado é se você precisar alterar os parâmetros ou as características de uma instância de NResponder. Como, por exemplo, se você quiser pausá-lo sem removê-lo.

Mas se você não precisar alterar nada após criar um NResponder, não há motivos para ficar utilizando o modo instanciado.

Criando um NResponder

Agora vamos ver como definir uma função de retorno para um evento no Flash, ou de forma mais direta, vamos criar um NResponder!

É aqui que, além de apenas definir uma função de retorno, nós vamos especificar uma Ação (Ação para o NResponder é a mesma coisa que um Tipo para o EventDispatcher) e todos os outros tipos de atributos para o NResponder.

Importante: É aqui, nesta seção, que você já começa a dizer “adeus” ao EventDispatcher!

OK, a primeira coisa que eu quero mostrar é como você normalmente faz com EventDispatcher. Quando você precisa criar um evento personalizado (websites, por exemplo, tem dezenas desses), você faz algo como:

var myDispatcher:EventDispatcher;
myDispatcher.addEventListener('myCustomEventType', callBackFunction, false, 0, true);
...
myDispatcher.dispatchEvent(new CustomEvent('myCustomEventType'));
[/as]

Isso é horrível! Porque o único jeito de você disparar seu CustomEvent é usando a instância do myDispatcher! E olhe como essa linha de myDispatcher.addEventListener é grande, completa-mente desnecessária.

Agora vamos transcrever isso para o NResponder, examente assim:

[as]
NResponder.add('myCustomEventType', callBackFunction);
...
NResponder.dispatch('myCustomEventType');

Vamos falar sobre os disparos mais para frente; por agora, como você pode ver, não há necessidade de instância nenhuma e você nem precisa se preocupar com parâmetros adicionais como capture ou weak references, porque o NResponder não precisa desse tipo de coisa para trabalhar.

Aqui é importante lembrar o que é uma Ação para o NResponder. Como você viu, o ‘myCusto-mEventType’ é o Type para o EventDispatcher. Esse mesmo parâmetro é chamado de “Action” para o NResponder. Isso é apenas um detalhe, mas daqui em diante toda vez que me referir a Ação do NResponder, você saberá que estou falando do Tipo do Evento.

E, como vimos acima, você pode ficar com uma cópia da instância do NResponder:

var myReponder:NResponder = NResponder.add('myCustomEventType', callBackFunction);

Lembre-se de que essa instância não interfere no funcionamento, ela apenas serve para você ter mais controle sobre o NResponder criado.

OK, agora vamos dar uma olhada em como é o NResponder trabalhando com a API Nativa de Eventos do Flash. O método para criar é muito similar ao “add” acima. Se você quiser criar um CLICK num botão com a API Nativa, por exemplo, você fará algo como:

var myButton:CustomButton;// probably inherited from MovieClip or Sprite.

myButton.addEventListener(MouseEvent.CLICK, clickFunction, false, 0, true);

Com NResponder, fará:

var myButton:CustomButton;// probably inherited from MovieClip or Sprite.

NResponder.addNative(myButton, MouseEvent.CLICK, clickFunction);

Simples assim!

Usar o método “addNative” é similar a usar o “add”, apenas com uma única diferença: o primeiro parâmetro é o Alvo (Target) do evento nativo.

Algumas pessoas ficam confusas nessa parte. Mas tudo que você precisa lembrar é perguntar: “Quem é o responsável por disparar esse evento nativo? Quem é uma extensão da classe E-ventDispatcher?”, então o objeto resultante dessa pergunta deverá ser passado no primeiro parâmetro do “addNative”.

Desta forma:

Você pode usar o NResponder com qualquer tipo de evento nativo. Os benefícios são que o NResponder irá trabalhar mais rápido, mais limpo e você ainda pode usar todas as características do NResponder. Os tópicos a seguir tratam a fundo dessas características.

Bom, como você pode já ter percebido, como uma boa prática em programação, para evitar erros de digitação no seu código, é aconselhável que você crie constantes públicas para armazenar as Ações que for usar com o NResponder, assim:

public static const CUSTOM_ACTION:String = 'myCustomAction';
...
NResponder.add(CUSTOM_ACTION, callBackFunction);

Bem, essa é apenas uma dica, embora neste artigo apenas para ser mais direto eu vou usar Strings literais em vez de constantes.

  • Disparo e argumentos

Depois de criar um NResponder com os métodos “adds” (add() e addNative()), você estará pronto para disparar esses Responders de qualquer lugar na sua aplicação, mesmo disparando contra arquivos SWF diferentes (arquivos carregados na mesma aplicação).

Tudo que você precisa é informar a Ação que você quer disparar e os parâmetros que você quiser, isto é, se precisar de parâmetros.

Assim:

// This will dispatch "myAction" with no arguments. So the callBack function don't need to ex-pect any parameter.
NResponder.dispatch('myAction');

// This will dispatch "anotherAction" with the arguments 35 (Number) and "aString" (String)
// So the callBack function should expect these parameter (Number and String in this order).
NResponder.dispatch('anotherAction', [35.5, 'aString']);

O método dispatch() é simples, ele vai disparar a Ação informada para toda a aplicação, assim qualquer funcão que esteja preparado para receber essa Ação irá fazê-lo.

OK, então talvez você possa se perguntar “se o NResponder irá disparar a Ação para qualquer um na aplicação, o que acontecerá então com os botões, por exemplo? O clique será disparado para TODOS? Como é que o NResponder vai saber para quem disparar?”

Ótimo ponto!

A resposta é: usando o parâmetro Alvo (Target)!

Você lembra, no método addNative(), que você especificou um Alvo (Target)? É aqui que ele faz toda a diferença. Se você especificar um Alvo ao criar um NResponder, esse Alvo irá funcionar como uma “trava” e esse NResponder só vai responder quando essa “trava” for especificada.

Bem, isso pode parecer um pouco confuso falando assim por cima, mas apenas pense que o NResponderCore irá cuidar disso para você. Se você estiver usando eventos nativos como MouseEvent, KeyboardEvent ou qualquer outro, isso irá acontecer automaticamente durante os disparos. Apenas informe o Alvo correto e não se preocupe mais com isso.

Você pode utilizar o Alvo mesmo sem ser um evento nativo. Assim você pode tirar proveito dessa “trava” que ele te proporciona. Mas este é um tópico avançado do NResponder e eu não vou falar disso aqui para não te confundir. Se você quiser saber mais sobre isso, veja a Wiki do projeto.

Vamos em frente.

  • Número de respostas.

Como eu te disse, este é um dos meus favoritos! Ele é muito útil.

Com o número de respostas, você pode especificar quantas vezes um NResponder vai responder antes de ser automaticamente removido e limpo. E só o que você precisa fazer é especificar o número que desejar logo após o parâmetro “listener” dentro dos métodos “adds”. Assim:

NResponder.add('myCustomEventType', callBackFunction, 5);
NResponder.addNative(myButton, MouseEvent.CLICK, clickButton, 2);
NResponder.addNative(this, Event.ADDED_TO_STAGE, init, 1);

No código acima:

  • “myCustomEventType” vai responder apenas 5 vezes.
  • O CLICK no “myButton” vai acontecer apenas 2.
  • O método “init” vai acontecer apenas uma vez quando o Alvo “this” for colocado no palco.

Você pode especificar qualquer número inteiro e não negativo. E, apenas por convenção, o valor 0 (padrão) significa que o NResponder vai acontecer infinitamente, obviamente porque um NResponder não pode ser criado para responder 0 vezes.

  • Tempo de espera

O tempo de espera é o mínimo necessário entre dois disparos consecutivos daquele NResponder.

Imagine que você tem um botão em seu jogo e não quer que o usuário clique no botão igual um louco. Você pode querer que o usuário só possa clicar no botão a cada 2.5 segundos. Bem, tudo que você precisa fazer então é especificar o próximo parâmetro depois do número de respostas no métodos “adds”.

NResponder.addNative(myButton, MouseEvent.CLICK, clickButton, 0, 2.5);

Isso significa que a funcão “clickButton” só poderá acontecer novamente depois de 2.5 segundos. Se o usuário fizer um clique e depois clicar novamente antes de 2.5 segundos, esse segundo clique será ignorado.

O valor pardão é 0 e significa nenhum intervalo de tempo.

  • Has e remove

Assim como o EventDispatcher, NResponder oferece uma forma para fazer verificações dos itens registrados e também uma forma de removê-los. A vantagem aqui é que você pode fazer combinações múltiplas, realizando várias tarefas de uma só vez.

Vamos começar com um caso simples, você quer saber se existe na sua aplicação algum registro para a Ação “myAction”, então:

NResponder.has('myAction');

Simples assim!

O exemplo acima trará um retorno no valor Boolean “true” se houver ao menos um único registro com a Ação “myAction”.

Agora imagine que você quer saber se há algum registro da Ação “myAction” ligada a uma função de retorno específica.

NResponder.has('myAction', myFunction);

Isso irá retornar “true” se houver na aplicação ao menos um registro com a Ação “myAction” e a função de retorno “myFunction”.

E, por último, vamos checar se há o exemplo acima possui um Alvo (Target) atrelado a ele.

NResponder.has('myAction', myFunction, myTarget);

Este irá retornar “true” se houver na aplicação ao menos um registro de NResponder com a Ação “myAction”, ligada a uma função “myFunction” e um Alvo “myTarget”.

A parte boa aqui é que você pode combinar esses 3 parâmetros, desta maneira:

NResponder.has('myAction', null, myTarget);
NResponder.has(null, myFunction, myTarget);
NResponder.has(null, myFunction, null);
NResponder.has(null, null, myTarget);

As quatro linhas acima significam:

  1. Há ao menos um NResponder registrado com “myAction” como Ação e “myTarget” como Alvo?
  2. Há ao menos um NResponder registrado com “myTarget” como Alvo e respondendo para “myFunction”?
  3. Há ao menos um NResponder registrado para a função “myFunction”, independentemente da Ação ou do Alvo?
  4. Há ao menos um NResponder registrado com “myTarget” como Alvo, independentemente da função de retorno ou da Ação?

O null nas funções do NResponder significa que você deseja ignorar o parâmetro e se focar nos outros. Essas combinações são especialmente úteis quando você não tem mais acesso a um ou dois parametros relacionados.

Mas o mais útil das combinações é quando você as utiliza para remover. Você pode remover vários NResponders de uma só vez com uma única linha de código.

O método remove() trabalha exatamente como o método has():

NResponder.remove(null, null, myTarget);

A linha acima significa que você vai remover todos os NResponders que esteja relacionados ao Alvo “myTarget”.

Agora pense em um botão com Dragging. Você pode registrar vários NResponders nele, um para o MOUSE_OVER, um para o MOUSE_OUT, MOUSE_DOWN, MOUSE_UP e MOUSE_MOVE.

Bem, são 5 NResponder. E se você precisar remover todos, pode fazer isso em uma única linha. Assim:

NResponder.addNative(myButton, MouseEvent.MOUSE_OVER, overFunction);
NResponder.addNative(myButton, MouseEvent.MOUSE_OUT, outFunction);
NResponder.addNative(myButton, MouseEvent.MOUSE_DOWN, startDragFunction);
NResponder.addNative(myButton, MouseEvent.MOUSE_UP, stopDragFunction);
NResponder.addNative(myButton, MouseEvent.MOUSE_MOVE, draggingFunction);
...
NResponder.remove(null, null, myButton);

Lembre-se de que o núcleo do NResponder é responsável por limpar tudo, e ele vai saber exatamente como e onde fazer isso com apenas esta única linha de código com a função remove().

  • Benefícios do modo instanciado

Com o modo instanciado, você pode alterar a orderm dos disparos de um Ação, você pode executar a funcão de retorno associada diretamente, você pode checar e alterar algumas propriedade como o número de respostas, o intervalo de disparos consecutivos, etc.

Não vou falar aqui sobre todos esses benefícios, como eles são de utilização mais avançada, você pode ler sobre eles na Wiki do Projeto no Google e na documentação oficial.

Bom, vou falar então sobre um benefício específico chamado “pausado” (paused). Essa propriedade possui um valor booleano, no qual “true” indica que o NResponder está pausado.

Claro, como o nome sugere, você pode parar temporariamente o funcionamento de um NResponder sem precisar removê-lo. Isso é muito útil quando você precisa interromper um NResponder por um curto tempo.

Por exemplo, imagine que na sua aplicação há uma interface 3D que reage à posição do mouse na tela. Mas se o usuário pressionar a barra de espaço aparecerá sobre a tela uma espécie de “pop-up” e durante o tempo que o usuário permanecer neste “pop-up” você quer que a inter-face 3D pare de reagir com à posição do mouse.

Bem, tudo que você precisa é usar a propriedade “pausado”. Desta maneira:

var myResponder:NResponder = NResponder.addNative(my3DInterface, MouseE-vent.MOUSE_MOVE, interactFunction);
...
// When start the pop-up, use this to pause this NResponder.
myResponder.paused = true;

...

// When close the pop-up, use this to reactivate this NResponder again.
myResponder.paused = false;

Obviamente você também poderia remover e adicionar o NResponder novamente usando o modo estático, mas utilizando essa propriedade “pausado”, você economiza muito processamento do CPU e salva muita memória da sua aplicação. Além de ser mais rápido também.

Muito bem, aqui eu apresentei algumas características do NResponder, as mais úteis e importantes. Lembre-se de conferir a página do projeto para ver tudo que não foi dito aqui sobre o NResponder.

Por hora, isso é tudo que precisamos saber para dizer “Adeus EventDispatcher”. Com o que vimos até aqui, é possível utilizar quase tudo do NResponder.

Na próxima parte destes artigos, veremos uma utilização real do NResponder para solucionar problemas complexos de forma simples no nosso dia-a-dia de programação.

Comente também

5 Comentários

Parece interessante. Pena que não podemos desativar a classe EventDispatcher né? Ela é herdada em todos os componentes Flash…

http://www.actionscriptblog.com

muito bom mesmo….

Não consegui encontrar o outro artigo… vc já escreveu?

Tiago Braga

Muito bom o artigo!!! Curti demais. #ficaadica para a galera.

pedro paulo almeida

Interessante. Prefiro o Signals, de Robert Penner.

Caso alguém se interesse:
https://github.com/robertpenner/as3-signals

Não deixe de ler:
http://robertpenner.com/flashblog/2009/08/my-critique-of-as3-events-part-1.html
http://robertpenner.com/flashblog/2009/09/my-critique-of-as3-events-part-2.html

Abraços e parabéns pelo artigo.

Qual a sua opinião?