Buttons in AS3.0... is there an easier way?

Question

I am wondering if there is an easier way to create buttons in
3.0... I want to make an e-publication in 3.0 but am finding most
of the actions easier to do in 2.0. Should I generally use a
combination of these AS versions or am I missing something with
this endless array of 3.0 options? I am having troubles adapting to
the whole applying an action to a frame rather than button thing...
I have downloaded all the terminology from Adobe so that I can get
better adjusted, but it's always nice to read feedback from a real
person explaining a few simple things to me... links or comments
much much much appreciated!!!

Answer 1

cdbsoccer63,
vvirgill's answer is good, because it shows how easy AS3
buttons can be.
In fact, the nice thing about ActionScript 3.0 is that nearly
all event
handling is this easy, becuase nearly all of it is performed
the same way.
That is ...
someObject.addEventListener(
<an event to listen for>,
<what to do when the event occurs>
You can put that all on one like, like vvirgill showed, or
broken over
several lines, like I just showed with my own example. My
example isn't
literal code, so it wouldn't work if you typed that into the
Actions panel.
Like vvirgill did, you'd have to replace the <an event to
listen for> part
with the name of some event. For buttons, one of them is
"click", which
appears in quotes because it's a string (text). Then you'd
replace the
<what do do ...> part with the name of some function,
such as myListener(),
onClick(), or honestly, whatever name you like. I often use
clickHandler(),
but it doesn't matter, so long as the function name makes
sense to you (a
descriptive name is usually a good choice, such as
submitForm() or
orderPizza()). When you refer to your function as a parameter
inside the
addEventListener() method, you leave the parentheses off the
function,
because it's the parentheses that actually make the function
do its thing.
You don't want to trigger the function inside that
addEventListener()
method, but rather, in response to whatever event you'r
listening for.
So ... how do you know what events are valid for buttons --
or anything
else, for that matter? Look up the class entry for the object
you're
dealing with. If you're dealing with button symbols, look up
the
SimpleButton class. For movie clip symbols, look up the
MovieClip class.
For text fields, the TextField class, and so on. Each class
entry -- in
this case, in the ActionScript 3.0 Language and Components
Reference (F1
key) -- generally has three categories: Properties
(characteristics of the
object), Methods (things the object can do), and Events
(things the object
can react to). You'll find relevant events under the Events
heading, as you
can imagine. Many classes inherit frunctionality from other
classes, so
always make sure to click the hyperlink that says "Show
Inherited
Properties/Methods/Events" near each heading.
The documentation will show you things a bit differently
than vvirgill
showed. Instead of "click", for example, you'll find sample
code that shows
you MouseEvent.CLICK. Don't be thrown by that. All that means
is that the
"click" string is stored as a constant (an unchanging
variable) of the
MouseEvent class. You can reference that string by referring
to the
contstant, like this:
myButton.addEventListener(
MouseEvent.CLICK,
clickHandler
According to best practices, you should do it like that
(it's the more
"proper" way to go about it), but in the end, all that
contsant does is
point to the string "click", so they ultimately mean the same
thing.
Nearly every time, if an object has an event, you'll be able
to wire up
an event listener the same way youv'e seen now in this
thread. The only
exceptions I can think of are related to video (cue points
and status
messages, I think) -- but for everything else ...
myObject.addEventListener(someEvent, someHandler);
... and then, of course, you have to write out that what
"someHandler" is.
As vvirgill demonstrated, that's easy to. You need a function
declaration,
and then the code you want performed, and that's really all
there is to it.
You do have to write the function to accept one parameter:
function myFunction(param:Event):void {
... which I called param in that snippet (vvirgill called it
e). That
parameter gives you optional access to the event itself, and
the *type* of
parameter it is depends on the type of event that triggers
the function.
Strictly speaking, the MouseEvent.CLICK event is an instance
of the
MouseEvent class (just like button symbols are instances of
the SimpleCutton
class, movie clips are instances of the MovieClip class, and
so on). So
ideally, that parameter should be typed as MouseEvent rather
than Event:
function myFunction(param:MouseEvent):void {
... but only when the function is triggered in reponse to a
mouse click
(that is, a MouseEvent). Makes sense, right? The reason
vvirgill's example
isn't wrong is because the MouseEvent class inherits some of
its
functionality from the Event class, so mouse event objects
actually *are*
event objects -- the identification as such is true -- but if
you're
adhering to Adobe recommendations, you'll type your
parameters (and all
variables) specifically.
David Stiller
Co-author, Foundation Flash CS4 for Designers
http://tinyurl.com/5j55cv
"Luck is the residue of good design."