The Widget King

WidgetFactory 5.5.1 and Question Pools

Just a quick post to let you know that I released a minor update to WidgetFactory which fixes some problems with widgets in question pools. Click here to get the update.

While I’m here I may as well talk about what I’ve learnt about question pools.

Whatfore art thou Question Pools?

From the Captivate author’s standpoint, question pools are a group that they can assign certain quiz questions to. These questions are kept separate from the rest of the lesson and left to their own devices would never appear in the movie. However, when a ‘Random Question Slide’ is added to the movie, it will pick a random question, from the pool of your choice, to display in the movie. This way the audience will get different quiz questions for each time they watch the lesson.

Here is what’s going on behind the scenes to make this happen:

When the Captivate Movie is opened all the question pool slides are created and then stored in a sort of waiting room which is separate from other slides in the movie. Random question slides however, are created and placed where the Captivate Author set them to appear in the movie. When the movie enters a random question slide, it goes searching in the waiting room for a question pool slide to display. When it finds one, the random question slide makes itself the parent of the chosen slide. So the random question slide is not replaced by the question pool slide, it becomes the parent of the question pool slide. The question pool slide is inside the random question slide. You have a slide inside a slide.

When the audience moves to the next random question slide, it will then go to the waiting room and pick its question pool slide.

So here are a few things to remember:

Random question slides are slides in their own right. Not just placeholders for the quiz slide.
The decision on which question pool slide will appear in the movie is not made until just before the audience enters it.
Question pool slides are not counted with the other slides in the movie. So they don’t have a slide number assigned to them.
Random question slides however, do have a slide number assigned to them.
If you had a widget on another slide of the movie which is trying to access slide elements on the question pool slide with getSlideObjectByName(), then it won’t work. Because getSlideObjectByName() will be searching for the slide elements in the random question slide, not the question pool slide.

So what does this topsy turvy system mean if you’re building a widget which might be used on a question pool slide?

Widgets and Question Pools

Perhaps the most significant difference is that the enterMovie() template method is not called at the start of the movie after the widget has set itself up. This is because the question pool slides are in the waiting room at the start of the movie and therefore outside the typical Captivate Movie structure. At this time WidgetFactory is unable to locate the elements it needs to set up the widget (like slides and the Captivate Main Timeline). So the widget delays its setup until the question pool slide is added as a child to the random question slide. The slide is now part of the typical Captivate Movie structure and the widget can find the elements it needs to set itself up, after doing that the enterMovie() Template Method will be called.

This delay in enterMovie() can cause some troubles if your widget is trying to join a widget room. I haven’t written an article on these yet, but when I do I will explain that it’s usually best behaviour for your widget to join rooms at the start of the movie. In other words: In the enterMovie() template method.

Now I’m afraid it’s not all good news and clean shoes. Although widgets now co-exist with question pools in Captivate 5 and Captivate 5.5, in Captivate 4 they are still at odds. Actually, they don’t work full stop. From the tests I’ve done, I can tell you that the movie doesn’t even get to the point of creating the widget before experiencing a terminal cardiac arrest. There is some error inside Captivate that prevents the widget being created and therefore the problem can’t be fixed in WidgetFactory. The good news is that the bug has already been fixed! So if you’re getting complaints from a user, tell them to upgrade to Captivate 5/5.5.

I hope that makes the pool a little clearer for your guys. Time to dive in!

Meet the Captivate Family – The Manager

In the last post we got an introduction to the everyday ordinary slide, and how it fits into the Captivate Movie. However, Captivate Movies are rarely made out of one slide. More often than not they’re made out of A-MILLION-BAJILLION SLIDZE! (Note: WidgetFactory, Infosemantics, and the Widget King do not in any way sanction or encourage the use of ‘A-MILLION-BAJILLION’ slides in a single Captivate Movie. Use imaginary numbers of slides in your movie at your own risk).

With the possibility for that many slides in a single movie, managing them gets very complex. That’s why this week we’re going to look at a little object which keeps those slides in line!

Ladies and Gentlemen, meet Ms’ Movie Controller.

Meet the Control Freak

Previously we illustrated the Captivate Movie as being a family talent show. Well now let’s say that due to overwhelming critical success, the Captivate family have decided to take their show on the road!

However, it’s not as simple as doing the same song and dance routine on a giant stage in front of 6,000 people. No, no, they need to be organized about this! So the first thing they do is hire Ms’ Movie Controller to manage the acts and keep those slides in line. And no wonder, just look at her.

Would you dare cross her?

With her reputation slides obey her command without question. But what makes her fabulous at her job is not her dominating attitude, but her intimate knowledge of the show. She can tell you immediately the current slide, frame, frame rate, movie height/width, number of slides, Captivate Version… and almost any other peice of the information you could ever want.

She isn’t in charge of the movie, but she’s the go to person when you want something to happen.

Seriously, this is a gal you want on speed dial.

How to Access the Movie Controller

Every slide has a property called m_movie, which holds a reference to the Movie Controller. You may be needing the Movie Controller regularly, so it’s a good idea to save it to a variable. Here’s how you’d do that:

1	var movieController:Object = widgetSlide.m_movie

Here I used the widgetSlide to access the Movie Controller, but you could access it through any slide.

The Remote Control

Here are all the unique methods on the m_movie object. Many are self explanatory. Others are a bit vague. I’ve marked the ones I’ve found useful and given them a brief explanation.

addSlide()
clickHandlerLoaded()
closeFLVConnections()
Dofscommand()
exit() – Closes down the movie.
getCurrentFrame()
getCurrentSlide()
getCurrentSlideData() – This function returns a rdSlideData object that has the following properties:
- m_playOnFrame: The number frame of the movie that the slide starts.
- m_stopOnFrame: The number frame of the movie that the slide ends.
- m_rdSlide_mc: A reference to the slide object.
getFrameCount()
getFrameRate()
getMovieHeight()
getMovieSlideCount()
getMovieWidth()
GetPlayingSlideIndex()
getSlide()
getSlideCount()
getSlideIndexFromFrame() – If you pass in a number to represent a frame in the Captivate movie, it will tell you which slide is supposed to be visible for that frame.
getSlidesInProject()
getTOCContainerMC() – (Not in Captivate 4)
getVersion()
gotoFlashFrame()
gotoFrameAndResume()
gotoMovieSlide()
gotoNextSlide()
gotoPreviousSlide()
gotoSlide()
gotoSlideAndResume()
hasPlaybar() – Returned false even though I had a playbar.
isMovieReady()
isPlaying() – Returns true if the movie is playing, false if it’s paused. Quite useful in some situations.
isTOCVisible() – Returns true if the TOC is out, false if it’s not. (Not in Captivate 4)
JumpToSlide()
markSlideAsCompletedForTOC() – (Not in Captivate 4)
movieonEnterFrame()
mute()
pause()
pauseMovie()
pauseOnInfo()
printCurrentFrame()
ReArrangeSlideData() – No idea what this one does, but it sounds scary.
relayoutTOC() – (Not in Captivate 4)
RestoreMovieState()
resume()
resumeMovie()
resumeOnInfo()
rewindAndPause()
rewindAndPlay()
setMovieSize()
SetPacemeker()
setSize()
showCC()
showInfo()
slideCompleted()
slideLoaded()

If that’s not enough for you. Here are the object’s properties:

m_clickHandler_mc
m_currFrame
m_currSlideIndex
m_fps
m_isPreviewForAudioDialog
m_itemToInitialVisibilityMap – (Not in Captivate 4)
m_keyHandler
m_movie_mc
m_OrigFPS
m_paused
m_QuizInfoLastSlidePointScored – (Not in Captivate 4)
m_quizPlaybackController
m_slideData_array
m_soundHandler
m_startPlaying
m_state
m_supportsSyncPlayback

Déjà vu

Some of you may find these properties and methods familiar. Yes, many of these operations or peices of information are accessible to Advanced Actions through Captivate Variables. What I believe is happening (and I can’t say for sure because I’m not a Captivate Developer) is that when you access or change one of these Captivate Variables, it diverts your request to the Movie Controller. For example, if you wanted to show the Closed Captions then usually you’d change the cpCmndCC variable like this:

1	cpVariables.cpCmndCC = 1

But what’s actually happening behind the scenes is the Captivate Main Timeline is calling the Movie Controller’s showCC() function.

As you can see, the Movie Controller has a lot of extra gems that have not been exposed via Captivate Variables. So I suggest you pull out your nearest test widget and have a good play Smile

Meet the Captivate Family – Slides

In the last post we learned about the Captivate Movie’s head honcho: The Captivate Main Timeline. Now it’s time to climb a little further down the family tree and meet the old man’s kids.

Ladies and Gentlemen, I give you: Slides.

What are Slides?

As users of Captivate, we think of slides as chapters in a book, each dealing with a specific topic. While that is true from a metaphorical point of view, from a technical point of view, a slide is a Display Object (Display Objects were explained in the previous post). The slide Display Object is a child to the Captivate Main Timeline.

When the Captivate Main Timeline realizes the movie needs to move to another slide, it sets that slide appear, then tells the previous slide to disappear. So the Captivate Main Timeline controls which slide will be shown next. Whereas, slides control when their objects (Such as Captions, Highlight Boxes, Images…) will appear.

I find it helpful if you can think of the Captivate Movie like this:

A Show to End All Shows!

Slides are the Captivate Main Timeline’s sons and they’re in the film business.

All of them.

And yes, in case you were wondering, they are all identical… er… Quadruplets.

What’s more, each of them are Dads too, and their kids are a real handful. Yep, they’ve got little Captions and Highlight Boxes running about at home.

The story goes that the Captivate Family are having a big reunion hosted at Grampa Timeline’s house. As part of the festivities, the grand-kids are to take part in one big talent show! However, each slide is assigned one act for all his kids to take part in. So it’s up to Daddy slide to coordinate the family act. Yes he’s the one that has to make sure little Clarance the Caption can sing her song, while Herbie the Highlight Box can dance to it.

So although the slides never appear in the act (even the slide background is a separate Display Object that the slide has hired out) they are the managing force behind it.

When one act finishes, it’s up to Old Man Timeline to decide who’s on next.

And that’s basically what the whole Captivate Movie is.

Getting a Hold of a Slide

So slides have an important place in the Captivate family. So how might we, when coding a widget, get a hold of a particular slide?

WidgetFactory has many tools for accessing slides.

The slide you’ll most commonly want to access is the slide the widget has been placed on. This can be accessed directly through the widgetSlide property.

However, if your widget is doing some behind the scenes calculations while its slide is not active, you can access the slide that is active through the currentSlide property.

But what if you just want to access the first slide, or a slide with a particular label, or you need to loop through the slides until you find a specific one, like the Quiz Results slide? In that case, you can use the getSlide() method. Just pass in the number, or label (though this will only work if the movie has Accessibility turned on), of the slide into the function, and it will return a reference to it. For Example: The next line of code will return you a reference to the first slide of the movie.

1	getSlide(1);

To store that slide reference in a variable, you’d write it like this:

1
2
3

import flash.display.MovieClip;

var firstSlide:MovieClip = getSlide(1);

So now that we know how to get a hold of our desired slide, what can we do with it?

Slide Features

Slides have a number of objects and methods that widget developers will find useful. There are a few properties…

m_paused (Boolean): Indicates whether the slide is paused or not.
m_projectSlideIndex (int): Holds the slide’s number (this value is zero based, so the first slide would be 0, the second would be 1, and so on)
m_movie: A very interesting object that is essentially a remote control for the whole movie. I’ll be writing more about this in a future post.

…But methods are really where it’s at for slides. Here are some of the handy ones:

getSlideProperties() : Returns an object that has the following properties.
- startFrame (int): The frame of the movie that this slide starts on.
- endFrame (int): The frame of the movie that this slide ends on.
- slideTyle (String): A string that describes what sort of slide this is.
- slideHandle: A proxy object of the slide.
getSlideDatabaseId() : Returns a number which… is some sort of database ID.
hasSlideAudio() : Returns a Boolean which indicates whether this slide has audio.
isSlideActive() : Returns a Boolean which indicates whether this slide is currently being viewed or not.
isSlidelet() : Returns a Boolean which indicates whether this slide is actually a slidelet.
nextSlide() : Jumps the movie to the next slide.
previousSlide() : Jumps the movie to the previous slide.
resumeSlide() : If the slide has been paused, this starts it playing again.

It’s a Slippery World Out There

Today we’ve learnt a lot about the common slide. However there are many varieties of slides, like: Quiz slides, Animation Slides, Image Slides, PowerPoint Slides, Recording Slides, and Master Slides. In the future, we may take a more in depth look at what makes these slides unique, and how you can use them to your advantage.

Meet the Captivate Family–Old Man Timeline

Have you ever had one of those ‘Let’s Meet the In-Laws’ dinners? Kinda awkward aren’t they? Often we fail to realize how stunningly varied the human race is until we share a meal with those soon to be related to us.

Think of the Captivate movie as a family. Not necessarily one you’re about to be forcibly related to, but one you have to deal with on a day to day basis.

The Captivate Movie family is made up of many members, each with their own role and peculiar quirks. Over the next couple of weeks, I’ll be introducing you to each member in turn. But first, let’s take a look at how this illustration works on a technical level.

Display Objects and their Relatives

In the world of Flash (and by extension Captivate), anything in the swf we can see is called a Display Object. However, just because you have a Display Object doesn’t mean that you can see it. For a Display Object to be seen, it must be added to the Display List (think of it like marrying into the family).

Don’t let the word ‘list’ fool you into thinking it’s just a scrap of paper with a few Display Objects scribbled over it. Oh no, the Display List is structured man! Right at the top of the Display List is a root Display Object (known as the Main Timeline). All other Display Objects must descend as ‘children’ from the Main Timeline.

These Display Objects can have children of their own. In that case, the top Display Object becomes the ‘parent’ of the ‘child’ Display Object.

So by that logic, the Main Timeline is parent to all Display Object.

Now if we did something to a parent, such as change its location, then this would affect the child too. If the parent were to be rendered pink, then the child would be also. If we added a blur filter to the parent, then the child would also be blurred.

Note though, that if the parent is not in some way a child of the Main Timeline, then the child isn’t considered as being part of the Display List either; and remember, if it’s not on the Display List, then it isn’t seen.

Thus we end up with the great family tree which is Captivate.

Now let’s get to know the man at the top a bit better.

Old Man Timeline

Old Man Captivate Timeline has been around for donkeys years, but he hasn’t gone soft. No, he’s the main organizing force behind the entire Captivate Movie. If Captivate could be likened to the mob, he’d be the Godfather.

This is the guy who decides (from his mouldy brown corduroy recliner) when and which slides are shown. He also keeps a tight hold on the Captivate Variables (system or user). If you want to access them, you’re going to have to go through him first.

The Captivate TOC and Playbar are direct children of Old Man Timeline. That is unless the movie is inside an aggregated project, which is a WHOLE other type of family.

Also held closely to his chest is the movieXML. This is data that is written by Captivate (the software program) and incorporated into the published movie. It contains information about general settings for the movie and each of its slides. It also contains data for each object on every slide. If you want to have some fun, I suggest you pick up your nearest copy of De Monster Debugger and trace out the movieXML.

1	MonsterDebugger.trace(this, cpVariables.movieXML);

Oh, which reminds me. The Captivate Main Timeline is accessible in WidgetFactory through the cpVariables property. The property is called this (instead of captivateMainTimeline) because you’re most likely to access it to get hold of a Captivate Variable.

Now that we’ve met the head honcho, in the next post we’ll get acquainted with some of his kids: Slides.