Chapter 2. Storyboard Engine

Table of Contents

Introduction
Engine Architecture Overview
Graphical Composition Elements
Events and Actions
Maintaining State and Reacting to Changes
Execution Pipeline
Execution Environment
Data Variables
Animation
Scripting
Performance Considerations
External Communication (Storyboard IO)
Rendering
Render Extension Descriptions
Fill
Polygon
Rectangle
Image
Text
External
Scripting with Lua
Lua function parameters
Passing extra parameters to lua functions
Storyboard Lua integration
Lua execution environment
Storyboard IO
Connecting to the Engine
Sending Events to the Engine
Setting Engine Data
Receiving Events from the Engine
Optimizing Your Storyboard Based Application
Choosing the Right Image Format(s)
Frames Per Second
Scaling Images
Turn down the verbosity
Memory
Storyboard Engine environment
Engine
Plugins
Target Configuration
Application files
Engine and Plugins
System specific requirements
Events Definitions
Stock Event Definitions
Plugin Event Definitions
Actions Definitions
Stock Action Definitions
Plugin Action Definitions
Storyboard Lua API
gre.set_data ( table )
gre.get_data ( val1 [ ,val2 , ...] )
gre.send_event (  event_name, channel )
gre.send_event_target (  event_name, target, channel )
gre.send_event_data (  event_name, format_string, data, channel )
gre.touch ( x , y, channel )
gre.key_up ( scancode, channel )
gre.key_down ( scancode, channel )
gre.key_repeat ( scancode, channel )
gre.redraw (x, y, w, h, channel)
gre.layer_move(key_name, dx, dy, x, y)
gre.control_move(key_name, dx, dy, x, y)
gre.get_control_attrs(key_name, tags …)
gre.get_layer_attrs(key_name, tags …)
gre.get_table_attrs(key_name, tags …)
gre.set_control_attrs(key_name, tags …)
gre.set_layer_attrs(key_name, table)
gre.set_layer_attrs_global(key_name, table)
gre.get_string_size(font, font_size, string, length, width)
gre.quit (channel)
gre.mstime ()
Storyboard IO API
gre_io_add_mdata()    
gre_io_close()  
gre_io_free_buffer()
gre_io_open ()
gre_io_receive  ()
gre_io_send ()
gre_io_send_mdata ()
gre_io_serialize ()
gre_io_size_buffer ()
gre_io_unserialize ()

Introduction

The Storyboard Embedded Engine (Engine) is a runtime framework that allows a description of a graphical application to be interpreted and executed.  The graphical application description, known as a deployment bundle, contains all of the instructions required to render screens to a display and to process events that would cause state transitions to occur in the application, potentially leading to additional screens being displayed.

The separation of the visual display logic from the system behavior is achieved through the use of events.  Events are asynchronous notifications containing a data payload that can be delivered to the Engine from multiple sources to trigger changes.