Why is AS1 documentation not a part of CS3 help

Question

hello;
in my flash CS3 help, there is AS2 and AS3 documentation, but
no AS1 documentation;
I have come to the understanding that AS1 would continue to
be supported in future flash authoring environments;
any thoughts?
thanks
dsdsdsdsd

Answer 1

dsdsdsdsd,
> I am still not convinced that AS3 is necessary
It isn't.
> just because an engineer can build a 800hp engine,
> powerful enough to thrust a wing-adapted minivan
> into flight
> doesn't mean it is the right approach: do soccer moms
even
> want to fly?
I do get your analogy. Really, I do. What I don't get is why
you're
the one making it -- because based on what you've described,
it sounds like
you're the engineer in this analogy, not the soccer mom.
After reading
Colin Moock's article, I would think even the soccer moms
should find
encouraged, but regardless ... of course you don't have to
use AS3. ;)
If you don't, you're stuck with a different set of
complexities, so it
all comes down to what you're comfortable with. In AS1/AS2,
you have on()
and/or onClipEvent() for handling events. You also have the
dot notation
equivalents (e.g. myClip.onRelease = handlerFunction). But
wait, there's
more! You also have addListener(). How's that for consistent?
Ah, but
then you also have addEventListener() -- just depends on
which datatype
you're handling the event for. If you're a longtime Flash
user -- and you
are -- then each new event handling model was something you
took in stride.
If you're new to the scene, it could seem like a completely
arbitrary mess.
In AS3 (outside of a drop-in-the-bucket NetStream exception),
you have
addEventListener(). Easy to learn and easy to remember,
because it's very
nearly consistent.
In AS1/AS2, if you want to instantiate a new MovieClip
instance, you
have to refer to an existing MovieClip instance and invoke
the
createEmptyMovieClip() method, give the new instance an
instance name and
assign it a depth. In AS3, you just invoke the constructor:
new
MovieClip(), then add the new instance to the display list.
It comes down to personal taste, I guess. To me, the newer
models are
easier to use ... once you learn them (of course). There are
trade-offs in
either camp, obviously.
> if someone could tell me some concrete thing
> that AS3 can do that AS1 cannot
> I would appreciate it;
I'm sure there are more, but here's a concrete thing off the
top of my
head: AS3 allows you to reparent movie clips (and other
visual display
objects) simply by removing them from the display list of one
object and
adding them to another. A practical example that comes to
mind is a jigsaw
puzzle, in which snapped-together pieces stay together,
making it easy to
move snapped-together pieces as a single group. Each
individual piece could
initially belong to the display list of the main timeline,
but could be
moved to the collective display list of a group of
snapped-together pieces.
Not that a single example should sway you. The example I
made might
just be meaningless to you, because you might not be
interested in
Flash-based jigsaws (or you might be interested, but would
rather move
snapped-together pieces by way of some algorithm that tracks
the position
and movement of each individual piece -- again, you're
trading one set of
complexities for another; on the main, I personally find the
complexities of
AS3 worth the learning curve).
> I am working on my first AS3 project - shopping cart -
but
> I will not use external packages );
And you shouldn't, unless you feel that external classes
would help you.
For me, I like the idea of utility classes (at least). In
order to create a
dynamic text field in AS1 -- let's say a non-selectable text
field, that
resizes as needed to fit the text, with a sans serif font --
you might do
something like this:
var tf = this.createTextField("myTextField", 0, 0, 0, 0, 0);
tf.selectable = false;
tf.autoSize = "left";
var fmt = new TextFormat();
fmt.font = "_sans";
tf.setNewTextFormat(fmt);
tf.text = "Lorem ipsum dolor sit amet";
(Note, this assumes Flash Player 8 or higher, because prior
to Flash Player
8, the MovieClip.createTextField() method returns Void.)
So ... to me, that's a lot to type. Again (this is my mantra
in this
post) ... one set of complexities for another. To reuse this
code, I could
certainly throw it into a function. Let's say something like
this:
function makeTextField(target, text) {
var tf = target.createTextField("myTextField" +
target.getNextHighestDepth(),
target.getNextHighestDepth(), 0, 0, 0, 0);
tf.selectable = false;
tf.autoSize = "left";
var fmt = new TextFormat();
fmt.font = "_sans";
tf.setNewTextFormat(fmt);
tf.text = text;
makeTextField(this, "Lorem ipsum dolor sit amet");
That's a tried and true procedural way to make your work
easier. I
think, so far, you would agree ... and I think, for you,
there's nothing new
so far. Notice that to keep instance names unique, I used
MovieClip.getNextHighestDepth() to append a number to the
instance name, and
also to ensure that a safe depth is met. A real
implementation would
probably include x,y positioning parameters, to make sure
text doesn't
overlap ... but you get the idea.
I could use AS2 to create a utility class called, say,
SimpleText.
Here's a stab at it. Quick and dirty AS2 external class file.
// Class file
class net.quip.utils.text.SimpleText {
public function SimpleText() {};
public static function makeTextField (target:MovieClip,
text:String):Void {
var tf:TextField = target.createTextField("myTextField" +
target.getNextHighestDepth(), target.getNextHighestDepth(),
0, 0, 0, 0);
tf.selectable = false;
tf.autoSize = "left";
var fmt:TextFormat = new TextFormat();
fmt.font = "_sans";
tf.setNewTextFormat(fmt);
tf.text = text;
More complex? In a sense, sure. Not by a whole lot, if you
really look
at it. The AS1 function version was a teensy bit bigger than
the
non-function version. The AS2 class version is a teensy bit
bigger than the
AS1 function version. But once it's done, it's done. If I
ever want this
functionality, I just import my class and use its (in this
case) static
method:
import net.quip.utils.text.SimpleText;
SimpleText.makeTextField(this, "Lorem ipsum dolor sit amet");
In my experience, that saves me time and effort. And this
same sort of
approach applies to non-static methods as well. It's just a
way to organize
your code. Many people find it more efficient. If you don't,
then you
don't. ;) It's as simple as that.
David Stiller
Adobe Community Expert
Dev blog,
http://www.quip.net/blog/
"Luck is the residue of good design."