So many widgets, so little time
TwitterFacebookGoogle

Did Someone Say ‘Example’?

Recently I’ve had a number of people asking me to put up an example of a WidgetFactory 6 widget. At least I think it was a number of people. It could have been the same person through a number of different channels. Whoever you are and in whatever quantity I wish to thank you and provide you with a gift. Here for you all now, whether you requested it or not, is a free to download widget with all its code begging to be investigated.

Click Here to Download the WidgetFactory 6 Example

I’ve included a .fla file that you can use to publish the widget. However you can use any program you wish to compile the widget. Except Word. Because Word doesn’t compile .swf files. Come to think of it you couldn’t use PowerPoint either… or Outlook, or Captivate, or Firefox, or Windows Task Manager, or Steam, or iTunes, or Intelli-J Idea- Wait no, you can use Intelli-J idea to compile it.

Okay, let’s try that again. You can use ANY Flash IDE to publish the widget example, you just have to make sure that WidgetFactory is already installed in that IDE. If you’re using Flash, then click here to read a tutorial on setting up WidgetFactory.

In other news I’m going to be easing up on the blog posts for a bit because… Wait… No I should probably write a devoted blog post about that… I’ll be right back.

PS: One of the people who originally requested an example wanted to know how to build a pause/play/fastforward button with a widget. For that person, please have a look at the TestInteractiveRuntimeMode class. In there I have coded two buttons, one to report the Interactive Widget’s success criteria and one to report its failure criteria. To change the button’s functionality to pause or play the movie for say… the success button, go to its click event handler (the onSuccess function) and delete the code in there. You can pause and play the movie the same way as you would in Advanced Actions, by changing a Captivate Variable. For example, if you wanted to pause the movie you’d write this in the onSuccess function:

1
cpVariables.rdcmndPause = 1;

For a list of other Captivate Variables you can use to control the Captivate Movie, please take a look at this post here (look under the variables named ‘rdcmnd’).

Building A Widget Step by Step – Part 2: Widget Type

In the last post we looked at how to form the foundation for a widget. In this post we will see how to set the widget’s type.

If you are using the ‘old’ method of building widgets, you’d specify your widget’s type by which class you extend. If you wanted to build a static widget you’d extend the StaticWidget class, if you wanted to build an interactive widget you’d extend the InteractiveWidget class and so on.

With the new Widget method in WidgetFactory 6 (I’ve really got to come up with a better name for that) no matter what type of widget we’re building, we always extend the Widget class, which is type independent. By default, the Widget class will be a static widget, so how do we tell WidgetFactory that we want to build an interactive or question widget?

How to do it

At the end of the last post, our widget was looking like this:

1
2
3
4
5
6
7
8
9
package {

   import widgetfactory.Widget;

   public class MyWidget extends Widget {

   }

}

This bare bones widget will import into Captivate as a static widget. To make this an interactive widget, first of all we must build a constructor function. When the MyWidget class creates a MyWidget object, its constructor function will run immediately. We identify the constructor function by giving it the exact same name as the class. So let’s add a MyWidget function to the MyWidget class.

1
2
3
4
5
6
7
8
9
10
11
12
13
package {

   import widgetfactory.Widget;

   public class MyWidget extends Widget {

      public function MyWidget():void
      {
      }

   }

}

The Widget class has its own constructor function as well, and its constructor function is set up to receive two pieces of information. The first piece of information is what type of widget this is going to be. The second piece of information is a bit complicated and outside of the scope of this post (though we’ll get to it some day). To send this information to the Widget class’ constructor function we use the ‘super()’ method. Super is short for ‘super class’ which means the class were extending, which of course in this situation is the Widget class.

A few posts ago I showed how to use the WidgetType class to detect what type of widget you’re in. The WidgetType class also has another use. If you recall the widget class has three static properties:

  • STATIC
  • INTERACTIVE
  • QUESTION

These represent the static, interactive, and question widgets. When we call the ‘super()’ function we can pass in one of these properties and that will specify what type of widget we’re building.

  • For a static widget: super(WidgetType.STATIC);
  • For an Interactive widget: super(WidgetType.INTERACTIVE);
  • For a Question widget: super(WidgetType.QUESTION);

Of course, you must import the WidgetType class before you can access it. The WidgetType class is located under the widgetfactory package, so just add…

1
import widgetfactory.WidgetType;

…to your class and you’re set.

So in the end, an Interactive widget would look like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package {

   import widgetfactory.Widget;
   import widgetfactory.WidgetType;

   public class MyWidget extends Widget {

      public function MyWidget():void
      {
         super(WidgetType.INTERACTIVE);
      }

   }

}

And a question widget would look like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package {

   import widgetfactory.Widget;
   import widgetfactory.WidgetType;

   public class MyWidget extends Widget {

      public function MyWidget():void
      {
         super(WidgetType.QUESTION);
      }

   }

}

There is another way to define your widget type that does not involve this ‘super()’ call, but I’ll explain that in another post. For our next post, we’ll learn about widget modes!

How to Detect Widget Type

Here’s a quick tip.

As many of you know, the Drag and Drop widgets come in two flavors, a Question Widget and an Interactive Widget. These two widgets mostly use the same code, but of course there are differences in between Question Widgets and Interactive Widgets, so at certain points different code is executed for the Question Widget than is for the Interactive Widget.

If you’ve got a similar situation and need to detect what type of widget is executing the code you’re writing, here’s how you go about it.

New to WidgetFactory 6 is the WidgetType class. It is found under the ‘widgetfactory’ package, so to import it you’d write the following:

1
import widgetfactory.WidgetType;

The WidgetType class has a single static property…

  • WidgetType.type

…and three static constants.

  • WidgetType.STATIC
  • WidgetType.INTERACTIVE
  • WidgetType.QUESTION

So if you want to check the widget type, just compare the relevant constant to the ‘type’ property like so:

1
2
3
4
5
6
7
if (WidgetType.type == WidgetType.QUESTION) {
   // This is a question widget.
} else if (WidgetType.type == WidgetType.INTERACTIVE) {
   // This is an interactive widget.
} else {
   // This is a static widget.
}

A Word on Partial Scoring

So Rod had been on to me for a long time to look into partial scoring. Which is basically a way of conveying ”You sorta got it right, but not entirely” as a quiz score. Currently all Captivate Quiz Questions and Interactive Objects can only report two scores: Zero and whatever number you gave it other than zero.

This static score is a bit limiting, and many people out there, who are extending the bounds of what Captivate can do, have been trying to find ways around it. Until recently the only viable method was employing Javascript. Which, for the non-programmatically minded, is – uh – Javascript.

So we wanted to find a way to open up the world of partial scoring to the grand populous. After a little more Captivate spelunking we found a way to BEND CAPTIVATE TO OUR WILL! MUAHAHA! The rest, as they say, is the Infosemantics Interactive Master Widget Version 1.1!

Don’t believe me? Take a look at this video here:

Pretty cool right?

And before you ask, yes this will be in the next version of WidgetFactory. Definitely for Interactive Widgets, most likely for Question Widgets too. WidgetFactory 5.6 shouldn’t be too far away and you can harness the awesome power of partial scoring for your very own widgets!

Bonn appetite!

(And yes I know I haven’t blogged about the features in WidgetFactory 5.5 yet. STILL GETTING AROUND TO IT!)

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.

QuestionPoolStructure

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:

  1. Random question slides are slides in their own right. Not just placeholders for the quiz slide.
  2. The decision on which question pool slide will appear in the movie is not made until just before the audience enters it.
  3. Question pool slides are not counted with the other slides in the movie. So they don’t have a slide number assigned to them.
  4. Random question slides however, do have a slide number assigned to them.
  5. 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!