Shulou(Shulou.com)06/02 Report--

Editor to share with you what is the use of Flex event mechanism, I believe that most people do not know much about it, so share this article for your reference, I hope you can learn a lot after reading this article, let's go to understand it!

Flex event mechanism

I. introduction

Many newcomers are not familiar with the Flex event mechanism, and there will inevitably be a variety of problems in the process of use, which is a very common problem. In order to help you faster and better, we will introduce the various mechanisms and usage of events in Flex.

One of the quintessence of Flex is the event and binding mechanism, which can help you design programs more flexibly and help novices to get on the road.

The explanation may not be systematic or comprehensive, and many of them are not in-depth. If you have any questions after seeing it, you are welcome to correct it. Of course, you can also put forward your own views, or experience sharing, thank you.

II. Introduction to Flex event mechanism

1. What is the Flex event mechanism

An event can be seen as a trigger mechanism, which will be triggered when certain conditions are met. For example, MouseEvent refers to a series of events that are triggered when the mouse operates. Many controls have a click event, which is an instance of MouseEvent, and when the mouse is clicked, the system automatically throws a MouseEvent event named click (this method will be described later). If a method is registered on click at this time, it will be executed when the event is triggered.

Mxml code of the main application of Flex

When we write code, there are many different icons in the editor's code completion hint list.

Those with lightning are events, three small pieces are styles, hollow circles are attributes, solid dots are public methods, and one is effect.

The event that we can see in this list, I call it the event registration channel. (officials still call it an event, but it has a different meaning from an ordinary event. The event registration channel will be described below)

two。 Event registration channel

The above Flex event mechanism mentioned that these channels can only be seen in the mxml code hint, and its role is to provide the mxml component with a registration channel for the method executed when the event is triggered, and it can be seen in the code hint, which provides a great abstract benefit to the component. We can clearly tell the component consumer which events are contained in the component to call.

Why treat him differently? In addition to the code hints, he also has some implementation differences.

Button's click event is inherited from the core class InteractiveObject. Unfortunately, we can't see his source code, but it shows that the "event registration channel" can be inherited.

We will talk about how to declare the event Registration Channel in a custom event.

3. Event trigger method

If the registration channel is filled with a function, it means that this method will be executed when the event is triggered.

Click= "clickHandler (event)"

We see that this method has an event object passed in as a parameter, and the newcomer may ask, where did this event object come from? I didn't declare this variable either. He is actually passed to him by the registration channel, and the default variable name is event. If we want to pass other parameters when the event is triggered, we can do so through a custom event object.

This object is the event object distributed by this component, that is, an instance of MouseEvent whose type is "click".

This event object contains all kinds of information when the event is triggered, such as which event object is triggered, which is the listening object, where the mouse click is when triggered, and so on. Different event classes contain different properties, such as which key the keyboard clicked is included in the KeyboardEvent.

We can also communicate all kinds of information we want by customizing an event class. (this will be described later.)

4. Event distribution

The Flex event mechanism eventually inherits from EventDispatcher objects that contain the method dispatchEvent, which has a parameter, the event object.

The event registration channel mentioned earlier is just a channel, but in fact, events are distributed by this method, and the channel is just a channel.

His role is to distribute an event object, his distribution is aimless, a form of broadcast, Flex event listener thread will receive a variety of events (we call it capture events, which will be described later), then which is the event you want, identification will be distinguished by the event's type attribute.

1) event object

When an event is distributed, an event object will be distributed. No matter which event class it is, it inherits from the flash.events.Event object, which contains some important properties, type and bubbles.

Type is the type of event, and event listener uses this parameter to identify whether it is the event it is listening to.

Bubbles is a Boolean value that determines whether the object is passed up. The default is false. What do you mean? Just draw a picture.

For example, when the button component distributes the click event object and sets the bubbles to false, then its distribution looks like this

Cosmetic code

DispatchEvent (newMouseEvent ("click", false))

The event object cannot span the component itself, except, of course, the registration channel mentioned earlier (which is very vivid).

Therefore, if there is no registered channel, the events distributed by this button component cannot be captured in the Flex main application.

If we set Bubbles to true, that's what he looks like.

DispatchEvent (newMouseEvent ("click", true))

As you can see, this event can cross over the component itself to the Flex main application. Not only that, it is clearly stated in the help manual that if the event is not captured during the delivery process, the event will be uploaded layer by layer until the final stage, and if it has not been captured, the event will be destroyed.

In this way, even if we don't have an event channel for click, we can get the distributed click event as long as we add an event listener (addEventListener) to the Flex main application.

So, isn't it useless to register the channel? No, as mentioned before, the registration channel is current and visible, so if your component is to be used by others, it is very clear at a glance without knowing exactly what events are distributed in your source code. However, do not listen and register the same event, which will be repeated. (I'll talk about it later)

Event listening in 5.Flex event mechanism

In the distribution, we said that if the trigger event is not called through the registration channel, then we need a monitor to capture it. How to capture the distributed event is through the type value of the event.

For example:

Some static constants are provided in the events of Flex in the Flex event mechanism, so that we can call them to prevent us from dialing the wrong number. So this sentence can be written like this.

TestBtn.addEventListener (MouseEvent.CLICK,clickHandler)

We see that there are no parameters passed in the listening callback method. Yes, this is somewhat different from the way the channel is written. The callback method here (that is, clickHandler) is just a reference and does not represent the execution of the method. What it means is to tell eventLinstener that if the click event is caught, then go to clickHandler and execute it, and the event object parameters are passed dynamically during execution. (if you are familiar with ajax, it should be easy to understand.)

That's how he works.

If you sign up for click's event channel again, both of them will take effect, which is obviously superfluous.

6. About async and execution order

The previous statement is wrong, there is no concept of threads in as, in remote requests, the result events and error events are asynchronous. If you need to process the results, you need to use monitoring and get your remote data in the callback.

When dealing with local events, they are still synchronized.

The callback methods are executed in less order than even the methods after dispatchEvent. If the next method depends on the event callback, write the next method to the callback method.

The above is all the content of the article "what is the use of Flex event mechanism". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.