Anyone familiar with Flash Presentations?

Question

Hi.
I continue to have problems playing movieclips on certain
slides of a Flash Presentation.
If anyone has *reasonable* experience with Flash
presentations please let me know. You might be familiar with the
problem, or have suggestions.
Thanks in advance,
K

Answer 1

chez Lou,
> 1. Would I be better off just placing everything on the
main
> timeline, and saving the use of mc for animations that
can play
> continously (for instance animations that "accent" the
content
> of the slide, vs those used to put the content
together)?
Well, that would certainly be one approach, but then you
lose out on the
benefit of nested movie clips, not the least of which is
avoidance of
timeline sprawl. I played a bit more with the Slide API this
morning. I
can see what's going on. Under the hood, each slide is a
movie clip, and
they all exist at once, so if you have nested animation on
any slide ...
they all start playing even on slide 1, and might in fact
have played
through by the time you hit slide 5.
> 2. Do you know of a way to have an animation stop on the
last
> frame, yet replay on slide re-entry?
Here's what I came up with. Let's assume you have two
buttons on the
root presentation slide. By default, Flash gives you a root
slide named
"presentation" and a child slide named "slide1". In my
experiment, I added
a Next and Previous button to "presentation" and wired them
up like this:
btnNext.onRelease = function():Void {
this._parent.currentSlide.gotoNextSlide();
btnPrev.onRelease = function():Void {
this._parent.currentSlide.gotoPreviousSlide();
This uses the button event handling approach I prefer,
personally, over
on() and onClipEvent() -- I'm not sure which approach you're
using. In this
approach, the code codes into a keyframe, typically a
dedicated scripts
layer, rather than attached to the object itself. The buttons
have the
instance names btnNext and btnPrev. A function is assigned to
the
Button.onRelease event of each button instance, and the
functions call
either Slide.gotoNextSlide() or Slide.gotoPreviousSlide() as
appropriate.
In order to target the relevant Slide instance, I use the
Slide.currentSlide
property, which I reference via the expression this._parent.
Let me explain that, real quick. In the above code, the word
"this"
refers to the corresponding button instance itself -- in
btnNext's onRelease
handler, "this" refers to btnNext. btnNext -- the button
symbol -- is, by
nature, an instance of the Button class. Consulting the
Button class in the
ActionScript 2.0 Language Reference, I see that all button
instances have a
Button._parent property, which points to the object that
contains the
button. Cool. Therefore, from a button's point of view,
this._parent
refers to the timeline that contains the button. Normally,
such a reference
points to a MovieClip instance (which is what timelines are;
they're movie
clips). That's the case here, too, but thanks to the way
object-oriented
programming works, and because we're inside a Slide
presentation, the parent
movie clip of this button is also an instance of the Slide
class.
Look up "Slide class" in the Components Language Reference,
and you'll
see the full pedigree. Any instance of Slide has the
following family tree:
MovieClip > UIObject > UIComponent > View >
Loader > Screen > Slide. Slides
*are* movie clips, but they're more than that. They're also
UIObjects,
which are objects that contain all the functionality of movie
clips, and
then some. They're also UIComponents, which addes even more
functionality,
and so on ... all the way through Slide. One of the
properties of the Slide
class is Slide.currentSlide. Bingo!
So ... this._parent (in this context) refers to a Slide
instance, which
means this._parent.currentSlide refers to the currently
showing slide, which
is obviously also a Slide instance. For that reason, we can
still invoke
Slide class methods on the reference, which is why something
like
this._parent.currentSlide.gotoNextSlide() works.
Forgive me, by the way, if you already understand all of
this. Forum
replies are searchable, and who knows ... in the future, the
explanation has
the potential to help someone else, too. :)
Okay, so now the issue is, we want each current slide to run
through any
nested movie clips it may have, regardless of their instance
names, and tell
each movie clip to start again from frame 1 of its own
timeline. Amend the
above code to look like this:
import mx.screens.Slide;
btnNext.onRelease = function():Void {
this._parent.currentSlide.gotoNextSlide();
var slide:Slide = this._parent.currentSlide;
for (var prop:String in slide) {
if (typeof(slide[prop] == "movieclip")) {
slide[prop].gotoAndPlay(1);
btnPrev.onRelease = function():Void {
this._parent.currentSlide.gotoPreviousSlide();
var slide:Slide = this._parent.currentSlide;
for (var prop:String in slide) {
if (typeof(slide[prop] == "movieclip")) {
slide[prop].gotoAndPlay(1);
The import statement allows us to reference Slide as a
datatype, which
happens just below the line in each event handler that was
already there.
To save a few keystrokes (basically, to make the code easier
to read), we're
creating a temporary variable, slide, and setting it to the
same
this._parent.currentSlide expression we already used. Once
gotoNextSlide()
or gotoPreviousSlide() is called, the value of
this._parent.currentSlide
changes, because now a *new* slide is the current slide. It's
the new slide
we're interested in. Using the variable slide as a kind of
shorthand, we
use a for..in loop to run through all the properties of the
current slide.
If the datatype of a given propery is a movie clip, we tell
it to go to
frame 1 of its own timeline and start playing.
What I've spelled out may or may not fit, exactly, with your
current
circumstance, but that's why I spent a bit of time explaining
the mechanics
of it. I hope that steers you in a useful direction. :)
David Stiller
Co-author, Foundation Flash CS3 for Designers
http://tinyurl.com/2k29mj
"Luck is the residue of good design."