Skip to content

Creating interactive e-learning with Adobe Captivate Advanced Actions

Why Captivate has Advanced Actions

Wanting to open up more creative possibilities for e-learning developers, the software architects behind Captivate kindly provided a mechanism allowing non-programmers to customize interactivity of their e-learning content. This all comes under an umbrella term of “Advanced Actions”. It’s really just a simplified method of scripting to customize how Cp e-learning output works at run-time.

For me personally, advanced actions are THE killer feature of Captivate that make it my go-to tool for creating custom interactivity in e-learning courses.  Of course Captivate is by no means the first or only rapid e-learning authoring tool to have this capability. In fact most (if not all) other tools now offer some form of support for basic scripting of interactivity. As a professional e-learning developer, I have also used several other rapid e-learning authoring applications to create interactive e-learning.  But, for my money, Captivate just seems to take things that little bit further than the others.

Captivate offers four different ways to execute actions and uses the broad term Advanced Actions to encompass them as a whole. Here’s a quick summary of what they are and how they differ:

Single actions

Adobe just calls these Actions in the help files, but I prefer to use the term Single Actions because it better describes how they differ from the other types we discuss below. These are the actions you can assign directly to any run-time event via the Properties tab > Actions drop-down list.  These same actions are also available when creating interactivity with Standard and Conditional Actions. The main limitation found with Single Actions is that they only allow you to execute one action per run-time event (hence the reason for the word ‘single’ in my preferred name for them). If you need to execute multiple actions from a single event, then you need one of the next action types. Another limitation of Single Actions is that you have to set them up each and every time. You cannot save and reuse them as you can with the ones we discuss next.

Standard actions

These are re-usable actions you create via the Project > Advanced Actions dialog (or SHIFT + F9). They allow you to execute one or more actions in a sequence. After creating a Standard Action you need to give it a unique name and then trigger (execute) it using any one of Captivate’s dozen or more run-time events.  I don’t personally use many Standard Actions because I find the next type much more useful.  They give you the best of both worlds.

Conditional actions

I have to confess that I love Conditional Actions! They are the unsung misunderstood work-horses of interactive e-learning. But they have a well-deserved reputation for causing Captivate developers headaches. Like their simpler brethren, the Standard Actions, they also allow you to execute any number of single actions from a single run-time event, but with the bonus of being able to specify multiple IF>THEN>ELSE conditions that determine whether or not groups of actions get executed at all. This then allows your content to respond to user interaction and make decisions on-the-fly. And this is where Captivate gets really exciting!

In earlier versions of Captivate you could not mix-and-match Standard and Conditional Actions together. But the Advanced Actions dialog now allows you to build both Standard and Conditional Actions at the same time and execute all of them from a single event. The only real difference is that Conditional Actions have decision blocks that specify the conditions that will determine if the actions under that section will be executed, whereas a section that is set up as a Standard Action has no condition and will therefore be executed each and every time the run-time event fires.

Shared actions

Captivate version 7 introduced a new type of action called Shared Actions. In theory they allow Standard or Conditional Actions to be saved in a stripped-down ‘parameterized’ format that can then be shared with other projects by exporting from one project file and importing into the other. In practice Shared Actions can sometimes be more trouble than they are worth because once you create them you cannot (as of Captivate 2019) edit them to make changes after that. Other than making actions portable across projects, shared actions don’t really allow you to do anything more than the other action types. They have some slight advantages in terms of run-time performance if you have a situation where you are going to need to reuse the same Standard or Conditional Action many many times in a single project or across many projects.  That’s about the only time that I believe it is necessary to use them.

Can Advanced Actions really be called ‘programming’?

Strictly speaking, Captivate’s advanced actions would not qualify as ‘programming’ if compared to languages such as JavaScript, Java or C++, etc.  Many of the established concepts that are regarded as essential to modern object-oriented programming are missing completely from Advanced Actions and professional programmers often struggle to see why they deserve the adjective ‘advanced’ at all.  So it’s probably more accurate to refer to what we’re doing here as simple ‘scripting’ of interativity.

However, when you publish your project, Captivate converts your Variables and Advanced Actions into much more complex programming code that is executed at runtime.  When the output is HTML5, the final code will be HTMLJavaScript and CSS.  It’s likely to be far more complex code than you could have written by yourself (unless you’re already a talented programmer).  Captivate’s simplified (and somewhat clunky) interface shields you from the dizzying complexity that hides just ‘under the hood’ of the project CPTX file. And, although there are lots of limitations in what you can do, some very sophisticated results are still achievable within those limits.

What you CAN do with Advanced Actions

So what level of sophistication are we talking about here?  Well consider the following examples:

  • Create your own custom User Variables and display them in your content at runtime;
  • Use dozens of System Variables that Captivate exposes for you;
  • Use run-time events to execute Simple Actions chosen from a menu;
  • Define a series of actions to be performed in sequence, and save this as a Standard Action that can be reused and executed by events on any number of slides;
  • Create IF – THEN – ELSE conditional actions that determine whether or not certain actions (or sets of actions) are executed;
  • Create dynamic content that responds to user input;
  • Manipulate numeric variable values to calculate results or scores;
  • Hide or show objects at run-time;
  • Change the appearance of objects to indicate state;
  • Concatenate strings to assemble sentences or create your own custom date formats from component system variables;
  • Create dynamic navigation menus that indicate which sections a user has completed;
  • Simulate navigation components such as tabs, drop-down or fly-out menus;
  • Store user details in custom variables and then use these later in the content;
  • Create custom quiz interactions;
  • Share actions between projects.
  • Execute a WHILE loop.

The list of what you can do is long and growing as clever Captivate developers come up with new ways to bend the tool to their will.

What you CANNOT do with Advanced Actions

So what are some of the limitations mentioned above?  Here are just a few examples:


Each Captivate variable can only store one value.  This means you cannot create a variable as an indexed array containing multiple values.  Additionally, you cannot assign an object as the value of a variable.


As mentioned above, you can define a series of actions to be performed in sequence, and save this as a Standard Action or Conditional Action to be triggered by screen events or user interaction. But this is not really the same as being able to program with reusable functions.  For example, you cannot call one Advanced Action from another Advanced Action unless you happen to have the Infosemantics CpExtra HTML5 widget in your toolkit.

Complex Loops

A loop is a logic structure where the program asks a question, and if the answer requires an action, then it is performed and the original question is asked again and again until the assigned action is no longer required. Though Captivate does now allow you to create a simple WHILE loop as part of a Conditional Action, it has many limitations. So, if you need to do something more complex, you’d usually need to resort to JavaScript

Nesting of Advanced Actions

You cannot build an Advanced Action inside another Advanced Action.  If you need to have the same code in more than one action, you have to manually recreate the code in other clauses of the action, or copy and paste lines one at a time.  Trust me. It gets tedious fast.


This is an important programming concept that allows you to save code when creating new types of objects by appending or extending existing objects. This concept just doesn’t exist in Captivate’s Advanced Actions. So for example, you cannot use Advanced Actions to define a new type of text caption or highlight box. You cannot extend an existing Advanced Actions. Each is a standalone object.

What if I want to go beyond the limitations?

With such a long list of limitations it’s easy to see why hard-core programmers are unimpressed with advanced actions. They’re more accustomed to unlimited creative vistas. But on balance, most Captivate users are NOT programmers.  They’ve usually been thrust into the world of e-learning authoring because they just needed to create or deliver training materials. The truth is, Advanced Actions are really designed for non-programmers.

But, that doesn’t mean serious programmers are left out in the cold.


Once derided by programmers as “just a basic scripting language”, JavaScript has now grown up and is regarded as a cornerstone of web-based technology. It is based on the same international ECMAScript standard as many other languages.  It’s a loosely typed object-oriented language that is now the most popular programming language in the world, thanks in part due to the recent rise in popularity of HTML5.  If by some chance you’ve decided to create widgets for Captivate that will work in HTML5, then you will need to become adept at JavaScript.  This is beyond the scope of this discussion, however, there are many books and online resources available to learn the language.