Added additional tests and increased test framework version

Fixes #39

.gitignore

@@ -8,3 +8,4 @@ build
 .cproject
 builtins
 .internal
+luacov.report.out

.luacov

@@ -0,0 +1,74 @@
+local reporter = require "luacov.reporter.defold"
+
+--- Default values for configuration options.
+-- For project specific configuration create '.luacov' file in your project
+-- folder. It should be a Lua script setting various options as globals
+-- or returning table of options.
+-- @class module
+-- @name deftest.coverage.configuration
+return {
+
+  --- Reporter class to use when creating a report. Default: DefaultReporter from reporter.lua
+  reporter = reporter,
+
+  --- Filename to store collected stats. Default: "luacov.stats.out".
+  statsfile = "luacov.stats.out",
+
+  --- Filename to store report. Default: "luacov.report.out".
+  reportfile = "luacov.report.out",
+
+  --- Enable saving coverage data after every `savestepsize` lines?
+  -- Setting this flag to `true` in config is equivalent to running LuaCov
+  -- using `luacov.tick` module. Default: false.
+  tick = false,
+
+  --- Stats file updating frequency for `luacov.tick`.
+  -- The lower this value - the more frequently results will be written out to the stats file.
+  -- You may want to reduce this value (to, for example, 2) to avoid losing coverage data in
+  -- case your program may terminate without triggering luacov exit hooks that are supposed
+  -- to save the data. Default: 100.
+  savestepsize = 100,
+
+  --- Run reporter on completion? Default: true.
+  runreport = true,
+
+  --- Delete stats file after reporting? Default: false.
+  deletestats = true,
+
+  --- Process Lua code loaded from raw strings?
+  -- That is, when the 'source' field in the debug info
+  -- does not start with '@'. Default: true.
+  codefromstrings = true,
+
+  --- Lua patterns for files to include when reporting.
+  -- All will be included if nothing is listed.
+  -- Do not include the '.lua' extension. Path separator is always '/'.
+  -- Overruled by `exclude`.
+  -- @usage
+  -- include = {
+  --    "mymodule$",      -- the main module
+  --    "mymodule%/.+$",  -- and everything namespaced underneath it
+  -- }
+  include = {},
+
+  --- Lua patterns for files to exclude when reporting.
+  -- Nothing will be excluded if nothing is listed.
+  -- Do not include the '.lua' extension. Path separator is always '/'.
+  -- Overrules `include`.
+  exclude = { "^test%/.+$", "^deftest%/.+$" },
+
+  --- Table mapping names of modules to be included to their filenames.
+  -- Has no effect if empty.
+  -- Real filenames mentioned here will be used for reporting
+  -- even if the modules have been installed elsewhere.
+  -- Module name can contain '*' wildcard to match groups of modules,
+  -- in this case corresponding path will be used as a prefix directory
+  -- where modules from the group are located.
+  -- @usage
+  -- modules = {
+  --    ["some_rock"] = "src/some_rock.lua",
+  --    ["some_rock.*"] = "src"
+  -- }
+  modules = {},
+
+}

.travis.yml

@@ -26,3 +26,6 @@ env:
 
 script:
   - "./.travis/run.sh"
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash)

CHANGELOG.md

@@ -0,0 +1,60 @@
+## Monarch 2.8.0 [britzl released 2018-06-10]
+NEW: Prevent show/hide operations while busy showing/hiding another screen  
+FIX: Make sure to properly finish active transitions when layout changes
+
+## Monarch 2.7.0 [britzl released 2018-06-04]
+NEW: Added monarch.top([offset]) and monarch.bottom([offset]) to get screen id of top and bottom screens (w. optional offset)  
+NEW: Transition messages now contain `next_screen` or `previous_screen`
+
+## Monarch 2.6.1 [britzl released 2018-06-04]
+FIX: Check if screen has already been preloaded before trying to preload it again (the callback will still be invoked).
+
+## Monarch 2.6.0 [britzl released 2018-06-03]
+NEW: monarch.preload() to load but not show a screen. Useful for content heavy screens that you wish to show without delay.
+
+## Monarch 2.5.0 [britzl released 2018-06-01]
+NEW: Transitions will send a `transition_done` message to the creator of the transition to notify that the transition has finished. The `message` will contain which transition that was finished.
+
+## Monarch 2.4.0 [britzl released 2018-05-26]
+NEW: Screen transitions are remembered so that they can be replayed when the screen layout changes.
+
+## Monarch 2.3.0 [britzl released 2018-03-24]
+CHANGE: The functions in monarch.lua that previously only accepted a hash as screen id now also accepts strings (and does the conversion internally)
+
+## Monarch 2.2.0 [britzl released 2018-03-19]
+NEW: Transitions now handle layout changes (via `layout_changed` message)  
+NEW: Transitions can now be notified of changes in window size using transition.window_resize(width, height)
+
+## Monarch 2.1 [britzl released 2017-12-27]
+NEW: Added Popup on Popup flag that allows a popup to be shown on top of another popup
+
+## Monarch 2.0 [britzl released 2017-12-08]
+BREAKING CHANGE: If you are using custom screen transitions (ie your own transition functions) you need to make a change to the function. The previous function signature was ```(node, to, easing, duration, delay, url)``` where ```url``` was the URL  to where the ```transition_done``` message was supposed to be posted. The new function signature for a transition function is: ```(node, to, easing, duration, delay, cb)``` where ```cb``` is a function that should be invoked when the transition is completed.  
+  
+FIX: Fixed issues related to screen transitions.  
+FIX: Code cleanup to reduce code duplication.  
+FIX: Improved documentation regarding transitions.
+
+## Monarch 1.4 [britzl released 2017-12-06]
+FIX: Several bugfixes for specific corner cases.
+
+## Monarch 1.3 [britzl released 2017-12-01]
+FIX: monarch.back(data, cb) set the data on the previous screen not the new current screen.  
+NEW: monarch.is_top(id)  
+NEW: monarch.get_stack()  
+NEW: monarch.in_stack(id)
+
+## Monarch 1.2 [britzl released 2017-11-28]
+NEW: Message id constants exposed from the Monarch module  
+NEW: Focus lost/gained contains id of next/previous screen
+
+## Monarch 1.1 [britzl released 2017-11-22]
+FIX: Bugfixes for transitions and state under certain circumstances  
+NEW: Added 'reload' option to show() command.
+
+## Monarch 1.0 [britzl released 2017-09-28]
+First public stable release
+
+## Monarch 0.9 [britzl released 2017-09-17]
+
+

README.md

@@ -1,11 +1,13 @@
 ![](docs/logo.jpg)
 
 [![Build Status](https://travis-ci.org/britzl/monarch.svg?branch=master)](https://travis-ci.org/britzl/monarch)
+[![Code Coverage](https://codecov.io/gh/britzl/monarch/branch/master/graph/badge.svg)](https://codecov.io/gh/britzl/monarch)
 [![Latest Release](https://img.shields.io/github/release/britzl/monarch.svg)](https://github.com/britzl/monarch/releases)
 
 # Monarch
 Monarch is a screen manager for the [Defold](https://www.defold.com) game engine.
 
+
 # Installation
 You can use Monarch in your own project by adding this project as a [Defold library dependency](http://www.defold.com/manuals/libraries/). Open your game.project file and in the dependencies field under project add:
 
@@ -13,20 +15,45 @@ https://github.com/britzl/monarch/archive/master.zip
 
 Or point to the ZIP file of a [specific release](https://github.com/britzl/monarch/releases).
 
+
 # Usage
 Using Monarch requires that screens are created in a certain way. Once you have one or more screens created you can start navigating between the screens.
 
+
 ## Creating screens
-Monarch screens are created in individual collections and loaded through collection proxies. The recommended setup is to create one game object per screen and per game object attach a collection proxy component and an instance of the ```screen.script``` provided by Monarch. The ```screen.script``` will take care of the setup of the screen. All you need to do is to make sure that the script properties on the ```screen.script``` are correct:
+Monarch screens are created in individual collections and either loaded through collection proxies or created through collection factories.
+
+### Collection proxies
+For proxies the recommended setup is to create one game object per screen and per game object attach a collection proxy component and an instance of the ```screen_proxy.script``` provided by Monarch. The ```screen_proxy.script``` will take care of the setup of the screen. All you need to do is to make sure that the script properties on the script are correct:
 
 * **Screen Proxy (url)** - The URL to the collection proxy component containing the actual screen. Defaults to ```#collectionproxy```.
 * **Screen Id (hash)** - A unique id that can be used to reference the screen when navigating your app.
 * **Popup (boolean)** - Check this if the screen should be treated as a [popup](#popups).
 * **Popup on Popup (boolean)** - Check this if the screen is a [popup](#popups) and it can be shown on top of other popups.
+* **Timestep below Popup (number)** - Timestep to set on screen proxy when it is below a popup. This is useful when pausing animations and gameplay while a popup is open.
 * **Transition Url (url)** - Optional URL to call when the screen is about to be shown/hidden. Use this to trigger a transition (see the section on [transitions](#transitions)).
 * **Focus Url (url)** - Optional URL to call when the screen gains or loses focus (see the section on [screen focus](#screen-focus-gainloss)).
+* **Preload (boolean)** - Check this if the screen should be preloaded and kept loaded at all times. For a collection proxy it means that it will be async loaded but not enabled at all times while not visible. This can also temporarily be achieved through the `monarch.preload()` function.
 
-![](docs/setup.png)
+![](docs/setup_proxy.png)
+
+### Collection factories
+For factories the recommended setup is to create one game object per screen and per game object attach a collection factory component and an instance of the ```screen_factory.script``` provided by Monarch. The ```screen_factory.script``` will take care of the setup of the screen. All you need to do is to make sure that the script properties on the script are correct:
+
+* **Screen Factory (url)** - The URL to the collection factory component containing the actual screen. Defaults to ```#collectionfactory```.
+* **Screen Id (hash)** - A unique id that can be used to reference the screen when navigating your app.
+* **Popup (boolean)** - Check this if the screen should be treated as a [popup](#popups).
+* **Popup on Popup (boolean)** - Check this if the screen is a [popup](#popups) and it can be shown on top of other popups.
+* **Transition Id (url)** - Optional id of the game object to send a message to when the screen is about to be shown/hidden. Use this to trigger a transition (see the section on [transitions](#transitions)).
+* **Focus Id (url)** - Optional id of the game object to send a message to when the screen gains or loses focus (see the section on [screen focus](#screen-focus-gainloss)).
+* **Preload (boolean)** - Check this if the screen should be preloaded and kept loaded at all times. For a collection factory this means that its resources will be dynamically loaded at all times. This can also temporarily be achieved through the `monarch.preload()` function.
+
+![](docs/setup_factory.png)
+
+Note: Monarch supports dynamic collection factories (ie where the "Load Dynamically" checkbox is checked).
+
+## Nesting screens
+Sometimes it might be desirable to have a screen that contains one or more sub-screens or children, for instance popups that are used only by that screen. Monarch supports nested screens only when the parent screen is created via a collection factory. If the parent screen is loaded via a collection proxy the sub/child-screens won't be able to receive any input.
 
 ## Navigating between screens
 The navigation in Monarch is based around a stack of screens. When a screen is shown it is pushed to the top of the stack. When going back to a previous screen the topmost screen on the stack is removed. Example:
@@ -69,6 +96,15 @@ As opposed to if the ```clear``` flag was not set:
 * A call to ```monarch.show(B, { clear = false })``` is made
 * Stack is ```[A, B, C, D, B]``` - (B is on top)
 
+#### Showing a screen without adding it to the stack
+Monarch can also show a screen without adding it to the stack. This can be used to for instance load a collection containing a background that you want to have visible at all times. You show and hide such a screen like this:
+
+	-- show the background without adding it to the stack
+	monarch.show(hash("background"), { no_stack = true })
+
+	-- hide the background
+	monarch.hide(hash("background"))
+
 ### Going back to a previous screen
 You navigate back in the screen hierarchy in one of two ways:
 
@@ -118,11 +154,14 @@ You can add optional transitions when navigating between screens. The default be
 * ```transition_back_in``` (constant defined as ```monarch.TRANSITION.BACK_IN```)
 * ```transition_back_out``` (constant defined as ```monarch.TRANSITION.BACK_OUT```)
 
-When a transition is completed it is up to the developer to send a ```transition_done``` (constant ```monarch.TRANSITION.DONE```) message back to the sender to indicate that the transition is completed and that Monarch can continue the navigation sequence. Monarch comes with a system for setting up transitions easily in a gui_script. Example:
+When a transition is completed it is up to the developer to send a ```transition_done``` (constant ```monarch.TRANSITION.DONE```) message back to the sender to indicate that the transition is completed and that Monarch can continue the navigation sequence.
 
+
+### Predefined transitions
 Monarch comes with a system for setting up transitions easily in a gui_script using the ```monarch.transitions.gui``` module. Example:
 
 	local transitions = require "monarch.transitions.gui"
+	local monarch = require "monarch.monarch"
 
 	function init(self)
 		-- create transitions for the node 'root'
@@ -137,9 +176,12 @@ Monarch comes with a system for setting up transitions easily in a gui_script us
 
 	function on_message(self, message_id, message, sender)
 		self.transition.handle(message_id, message, sender)
+		-- you can also check when a transition has completed:
+		if message_id == monarch.TRANSITION.DONE and message.transition == monarch.TRANSITION.SHOW_IN then
+			print("Show in done!")
+		end
 	end
 
-### Predefined transitions
 The predefined transitions provided by ```monarch.transitions.gui``` are:
 
 * ```slide_in_right```
@@ -152,6 +194,26 @@ The predefined transitions provided by ```monarch.transitions.gui``` are:
 * ```slide_out_bottom```
 * ```scale_in```
 * ```scale_out```
+* ```fade_in``` - Set node alpha to fully transparent (i.e. 0.0) and fade to fully opaque (i.e. 1.0)
+* ```fade_out``` - Set node alpha to fully opaque (i.e. 1.0) and fade to fully transparent (i.e. 0.0)
+
+Additionally there's functionality to create a full set of transitions for common transition styles:
+
+* ```transitions.in_right_out_left(node, duration, [delay], [easing])```
+* ```transitions.in_left_out_right(node, duration, [delay], [easing])```
+* ```transitions.in_left_out_left(node, duration, [delay], [easing])```
+* ```transitions.in_right_out_right(node, duration, [delay], [easing])```
+* ```transitions.fade_in_out(node, duration, [delay], [easing])```
+
+**PARAMETERS**
+* ```node``` (node) - Gui node to animate.
+* ```duration``` (number) - Transition duration in seconds.
+* ```delay``` (number) - Transition delay in seconds.
+* ```easing``` (table) - Easing table, created from a function provided by ```monarch.transitions.easings```
+
+**RETURN**
+* ```instance``` - The created transition instance
+
 
 ### Custom transitions
 You can create and use your own transition as long as the provided transition function has the following function signature:
@@ -166,6 +228,7 @@ You can create and use your own transition as long as the provided transition fu
 * ```delay``` (number) - Transition delay in seconds.
 * ```cb``` (function) - This function must be called when the transition is completed.
 
+
 ### Dynamic orientation and resized windows
 When using dynamic screen orientation together with gui layouts or using transitions on a platform where the window can be resized it's important to make sure that the created transitions adapt to the change in orientation or window size. The transition system takes care of layout changes automatically, but when it comes to changes in window size you need to notify the transition manually:
 
@@ -182,6 +245,26 @@ When using dynamic screen orientation together with gui layouts or using transit
 	end
 
 
+### Screen stack info and transitions
+The transition message sent to the Transition Url specified in the screen configuration contains additional information about the transition. For the ```transition_show_in``` and ```transition_back_out``` messages the message contains the previous screen id:
+
+	function on_message(self, message_id, message, sender)
+		if message_id == hash("transition_show_in") or message_id == hash("transition_back_out") then
+			print(message.previous_screen)
+		end
+	end
+
+For the ```transition_show_out``` and ```transition_back_in``` messages the message contains the next screen id:
+
+	function on_message(self, message_id, message, sender)
+		if message_id == hash("transition_show_out") or message_id == hash("transition_back_in") then
+			print(message.next_screen)
+		end
+	end
+
+This information can be used to create dynamic transitions where the direction of the transition depends on the previous/next screen
+
+
 ## Screen focus gain/loss
 Monarch will send focus gain and focus loss messages if a Focus Url was provided when the screen was created. The focus gained message will contain the id of the previous screen and the focus loss message will contain the id of the next screen. Example:
 
@@ -195,9 +278,11 @@ Monarch will send focus gain and focus loss messages if a Focus Url was provided
 		end
 	end
 
+
 ## Callbacks
 Both the ```monarch.show()``` and ```monarch.back()``` functions take an optional callback function that will be invoked when the ```transition_show_in``` (or the ```transition_back_in``` in the case of a ```monarch.back()``` call) transition is completed. The transition is considered completed when a ```transition_done``` message has been received (see section on [transitions](#transitions) above).
 
+
 ## Monarch API
 
 ### monarch.show(screen_id, [options], [data], [callback])
@@ -211,8 +296,24 @@ Show a Monarch screen. Note that the screen must be registered before it can be
 
 The options table can contain the following fields:
 
-* ```clear``` (boolean) - If the clear flag is set Monarch will search the stack for the screen that is to be shown. If the screen already exists in the stack and the clear flag is set Monarch will remove all screens between the current top and the screen in question.
-* ```reload``` (boolean) - If the reload flag is set Monarch will reload the collection proxy if it's already loaded (this can happen if the previous screen was a popup).
+* ```clear``` (boolean) - If the `clear` flag is set Monarch will search the stack for the screen that is to be shown. If the screen already exists in the stack and the clear flag is set Monarch will remove all screens between the current top and the screen in question.
+* ```reload``` (boolean) - If the `reload` flag is set Monarch will reload the collection proxy if it's already loaded (this can happen if the previous screen was a popup).
+* ```no_stack``` (boolean) - If the `no_stack` flag is set Monarch will load the screen without adding it to the screen stack.
+
+**RETURN**
+* ```success``` (boolean) - True if the process of showing the screen was started successfully. False if already busy showing/hiding a screen.
+
+
+### monarch.hide(screen_id, [callback])
+Hide a screen that has been shown using the `no_stack` option. If used on a screen that was shown without the `no_stack` option it will only hide it if the screen is on top of the stack and the behavior will be exactly like if `monarch.back()` had been called.
+
+**PARAMETERS**
+* ```screen_id``` (hash) - Id of the screen to hide.
+* ```callback``` (function) - Optional function to call when the screen has been hidden.
+
+**RETURN**
+* ```success``` (boolean) - True if the process of hiding the screen was started successfully.
+
 
 ### monarch.back([data], [callback])
 Go back to a previous Monarch screen
@@ -221,6 +322,63 @@ Go back to a previous Monarch screen
 * ```data``` (table) - Optional data to associate with the screen you are going back to.  Retrieve using ```monarch.data()```.
 * ```callback``` (function) - Optional function to call when the previous screen is visible.
 
+**RETURN**
+* ```success``` (boolean) - True if the process of going back to a previous screen was started successfully. False if already busy showing/hiding a screen.
+
+
+### monarch.preload(screen_id, [callback])
+Preload a Monarch screen. This will load but not enable the screen. This is useful for content heavy screens that you wish to be able to show without having to wait for it load.
+
+**PARAMETERS**
+* ```screen_id``` (hash) - Id of the screen to preload.
+* ```callback``` (function) - Optional function to call when the screen is preloaded.
+
+
+### monarch.is_preloading(screen_id)
+Check if a Monarch screen is preloading (via monarch.preload() or the Preload screen setting).
+
+**PARAMETERS**
+* ```screen_id``` (hash) - Id of the screen to check
+
+**RETURN**
+* ```preloading``` (boolean) - True if the screen is preloading.
+
+
+### monarch.when_preloaded(screen_id, callback)
+Invoke a callback when a screen has been preloaded.
+
+**PARAMETERS**
+* ```screen_id``` (hash) - Id of the screen to check
+* ```callback``` (function) - Function to call when the screen has been preloaded.
+
+
+### monarch.unload(screen_id, [callback])
+Unload a preloaded Monarch screen. A preloaded screen will automatically get unloaded when hidden, but this function can be useful if a screen has been preloaded and it needs to be unloaded again without actually hiding it.
+
+**PARAMETERS**
+* ```screen_id``` (hash) - Id of the screen to unload.
+* ```callback``` (function) - Optional function to call when the screen is unloaded.
+
+
+### monarch.top([offset])
+Get the id of the screen at the top of the stack.
+
+**PARAMETERS**
+* ```offset``` (number) - Optional offset from the top of the stack, ie -1 to get the previous screen
+
+**RETURN**
+* ```screen_id``` (hash) - Id of the requested screen
+
+
+### monarch.bottom([offset])
+Get the id of the screen at the bottom of the stack.
+
+**PARAMETERS**
+* ```offset``` (number) - Optional offset from the bottom of the stack
+
+**RETURN**
+* ```screen_id``` (hash) - Id of the requested screen
+
 
 ### monarch.data(screen_id)
 Get the data associated with a screen (from a call to ```monarch.show()``` or ```monarch.back()```).
@@ -240,3 +398,80 @@ Check if a Monarch screen exists.
 
 **RETURN**
 * ```exists``` (boolean) - True if the screen exists.
+
+
+### monarch.is_busy()
+Check if Monarch is busy showing and/or hiding a screen.
+
+**RETURN**
+* ```busy``` (boolean) - True if busy hiding and/or showing a screen.
+
+
+### monarch.is_top(id)
+Check if a Monarch screen is at the top of the view stack.
+
+**PARAMETERS**
+* ```screen_id``` (hash) - Id of the screen to check
+
+**RETURN**
+* ```exists``` (boolean) - True if the screen is at the top of the stack.
+
+
+### monarch.is_visible(id)
+Check if a Monarch screen is visible.
+
+**PARAMETERS**
+* ```screen_id``` (hash) - Id of the screen to check
+
+**RETURN**
+* ```exists``` (boolean) - True if the screen is visible.
+
+
+### monarch.add_listener([url])
+Add a URL that will be notified of navigation events.
+
+**PARAMETERS**
+* ```url``` (url) - URL to send navigation events to. Will use current URL if omitted.
+
+
+### monarch.remove_listener([url])
+Remove a previously added listener.
+
+**PARAMETERS**
+* ```url``` (url) - URL to remove. Will use current URL if omitted.
+
+
+### monarch.debug()
+Enable verbose logging of the internals of Monarch.
+
+
+### monarch.SCREEN_TRANSITION_IN_STARTED
+Message sent to listeners when a screen has started to transition in.
+
+**PARAMETERS**
+* ```screen``` (hash) - Id of the screen
+* ```previous_screen``` (hash) - Id of the previous screen (if any)
+
+
+### monarch.SCREEN_TRANSITION_IN_FINISHED
+Message sent to listeners when a screen has finished to transition in.
+
+**PARAMETERS**
+* ```screen``` (hash) - Id of the screen
+* ```previous_screen``` (hash) - Id of the previous screen (if any)
+
+
+### monarch.SCREEN_TRANSITION_OUT_STARTED
+Message sent to listeners when a screen has started to transition out.
+
+**PARAMETERS**
+* ```screen``` (hash) - Id of the screen
+* ```next_screen``` (hash) - Id of the next screen (if any)
+
+
+### monarch.SCREEN_TRANSITION_OUT_FINISHED
+Message sent to listeners when a screen has finished to transition out.
+
+**PARAMETERS**
+* ```screen``` (hash) - Id of the screen
+* ```next_screen``` (hash) - Id of the next screen (if any)

assets/logo.atlas

@@ -0,0 +1,6 @@
+images {
+  image: "/assets/images/logo.png"
+}
+margin: 0
+extrude_borders: 0
+inner_padding: 0

example/about.gui

@@ -48,7 +48,7 @@ nodes {
   yanchor: YANCHOR_NONE
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -103,7 +103,7 @@ nodes {
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
   parent: "root"
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -172,7 +172,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "ok_reload_button"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -235,7 +235,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: true
   parent: "root"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -284,7 +284,7 @@ nodes {
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
   parent: "root"
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -353,7 +353,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "ok_clear_button"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -402,7 +402,7 @@ nodes {
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
   parent: "root"
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -471,7 +471,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: true
   parent: "ok_clearreload_button"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -520,7 +520,7 @@ nodes {
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
   parent: "root"
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -589,7 +589,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "ok_button"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -598,6 +598,12 @@ nodes {
   text_leading: 1.0
   text_tracking: 0.0
 }
+layers {
+  name: "below"
+}
+layers {
+  name: "text"
+}
 material: "/builtins/materials/gui.material"
 adjust_reference: ADJUST_REFERENCE_PARENT
 max_nodes: 512

example/background.collection

@@ -0,0 +1,42 @@
+name: "background"
+scale_along_z: 0
+embedded_instances {
+  id: "go"
+  data: "embedded_components {\n"
+  "  id: \"sprite\"\n"
+  "  type: \"sprite\"\n"
+  "  data: \"tile_set: \\\"/assets/logo.atlas\\\"\\n"
+  "default_animation: \\\"logo\\\"\\n"
+  "material: \\\"/builtins/materials/sprite.material\\\"\\n"
+  "blend_mode: BLEND_MODE_ALPHA\\n"
+  "\"\n"
+  "  position {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "  }\n"
+  "  rotation {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "    w: 1.0\n"
+  "  }\n"
+  "}\n"
+  ""
+  position {
+    x: 320.0
+    y: 568.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale3 {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+  }
+}

example/confirm.gui

@@ -48,7 +48,7 @@ nodes {
   yanchor: YANCHOR_NONE
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -103,7 +103,7 @@ nodes {
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
   parent: "root"
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -172,7 +172,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "yes_button"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -221,7 +221,7 @@ nodes {
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
   parent: "root"
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -290,7 +290,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "no_button"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -362,6 +362,12 @@ nodes {
   text_leading: 1.0
   text_tracking: 0.0
 }
+layers {
+  name: "below"
+}
+layers {
+  name: "text"
+}
 material: "/builtins/materials/gui.material"
 adjust_reference: ADJUST_REFERENCE_PARENT
 max_nodes: 512

example/example.collection

@@ -3,8 +3,8 @@ scale_along_z: 0
 embedded_instances {
   id: "menu"
   data: "components {\n"
-  "  id: \"screen\"\n"
-  "  component: \"/monarch/screen.script\"\n"
+  "  id: \"screen_factory\"\n"
+  "  component: \"/monarch/screen_factory.script\"\n"
   "  position {\n"
   "    x: 0.0\n"
   "    y: 0.0\n"
@@ -22,21 +22,21 @@ embedded_instances {
   "    type: PROPERTY_TYPE_HASH\n"
   "  }\n"
   "  properties {\n"
-  "    id: \"transition_url\"\n"
-  "    value: \"menu:/go#menu\"\n"
-  "    type: PROPERTY_TYPE_URL\n"
+  "    id: \"transition_id\"\n"
+  "    value: \"/go\"\n"
+  "    type: PROPERTY_TYPE_HASH\n"
   "  }\n"
   "  properties {\n"
-  "    id: \"focus_url\"\n"
-  "    value: \"menu:/go#menu\"\n"
-  "    type: PROPERTY_TYPE_URL\n"
+  "    id: \"focus_id\"\n"
+  "    value: \"/go\"\n"
+  "    type: PROPERTY_TYPE_HASH\n"
   "  }\n"
   "}\n"
   "embedded_components {\n"
-  "  id: \"collectionproxy\"\n"
-  "  type: \"collectionproxy\"\n"
-  "  data: \"collection: \\\"/example/menu.collection\\\"\\n"
-  "exclude: false\\n"
+  "  id: \"collectionfactory\"\n"
+  "  type: \"collectionfactory\"\n"
+  "  data: \"prototype: \\\"/example/menu.collection\\\"\\n"
+  "load_dynamically: true\\n"
   "\"\n"
   "  position {\n"
   "    x: 0.0\n"
@@ -122,7 +122,7 @@ embedded_instances {
   id: "pregame"
   data: "components {\n"
   "  id: \"screen\"\n"
-  "  component: \"/monarch/screen.script\"\n"
+  "  component: \"/monarch/screen_proxy.script\"\n"
   "  position {\n"
   "    x: 0.0\n"
   "    y: 0.0\n"
@@ -185,7 +185,7 @@ embedded_instances {
   id: "game"
   data: "components {\n"
   "  id: \"screen\"\n"
-  "  component: \"/monarch/screen.script\"\n"
+  "  component: \"/monarch/screen_proxy.script\"\n"
   "  position {\n"
   "    x: 0.0\n"
   "    y: 0.0\n"
@@ -244,79 +244,11 @@ embedded_instances {
     z: 1.0
   }
 }
-embedded_instances {
-  id: "popup"
-  data: "components {\n"
-  "  id: \"screen\"\n"
-  "  component: \"/monarch/screen.script\"\n"
-  "  position {\n"
-  "    x: 0.0\n"
-  "    y: 0.0\n"
-  "    z: 0.0\n"
-  "  }\n"
-  "  rotation {\n"
-  "    x: 0.0\n"
-  "    y: 0.0\n"
-  "    z: 0.0\n"
-  "    w: 1.0\n"
-  "  }\n"
-  "  properties {\n"
-  "    id: \"screen_id\"\n"
-  "    value: \"popup\"\n"
-  "    type: PROPERTY_TYPE_HASH\n"
-  "  }\n"
-  "  properties {\n"
-  "    id: \"popup\"\n"
-  "    value: \"true\"\n"
-  "    type: PROPERTY_TYPE_BOOLEAN\n"
-  "  }\n"
-  "  properties {\n"
-  "    id: \"transition_url\"\n"
-  "    value: \"popup:/go#popup\"\n"
-  "    type: PROPERTY_TYPE_URL\n"
-  "  }\n"
-  "}\n"
-  "embedded_components {\n"
-  "  id: \"collectionproxy\"\n"
-  "  type: \"collectionproxy\"\n"
-  "  data: \"collection: \\\"/example/popup.collection\\\"\\n"
-  "exclude: false\\n"
-  "\"\n"
-  "  position {\n"
-  "    x: 0.0\n"
-  "    y: 0.0\n"
-  "    z: 0.0\n"
-  "  }\n"
-  "  rotation {\n"
-  "    x: 0.0\n"
-  "    y: 0.0\n"
-  "    z: 0.0\n"
-  "    w: 1.0\n"
-  "  }\n"
-  "}\n"
-  ""
-  position {
-    x: 0.0
-    y: 0.0
-    z: 0.0
-  }
-  rotation {
-    x: 0.0
-    y: 0.0
-    z: 0.0
-    w: 1.0
-  }
-  scale3 {
-    x: 1.0
-    y: 1.0
-    z: 1.0
-  }
-}
 embedded_instances {
   id: "about"
   data: "components {\n"
   "  id: \"screen\"\n"
-  "  component: \"/monarch/screen.script\"\n"
+  "  component: \"/monarch/screen_proxy.script\"\n"
   "  position {\n"
   "    x: 0.0\n"
   "    y: 0.0\n"
@@ -339,10 +271,20 @@ embedded_instances {
   "    type: PROPERTY_TYPE_BOOLEAN\n"
   "  }\n"
   "  properties {\n"
+  "    id: \"popup_on_popup\"\n"
+  "    value: \"true\"\n"
+  "    type: PROPERTY_TYPE_BOOLEAN\n"
+  "  }\n"
+  "  properties {\n"
   "    id: \"transition_url\"\n"
   "    value: \"about:/go#about\"\n"
   "    type: PROPERTY_TYPE_URL\n"
   "  }\n"
+  "  properties {\n"
+  "    id: \"preload\"\n"
+  "    value: \"true\"\n"
+  "    type: PROPERTY_TYPE_BOOLEAN\n"
+  "  }\n"
   "}\n"
   "embedded_components {\n"
   "  id: \"collectionproxy\"\n"
@@ -384,7 +326,7 @@ embedded_instances {
   id: "confirm"
   data: "components {\n"
   "  id: \"screen\"\n"
-  "  component: \"/monarch/screen.script\"\n"
+  "  component: \"/monarch/screen_proxy.script\"\n"
   "  position {\n"
   "    x: 0.0\n"
   "    y: 0.0\n"
@@ -453,3 +395,61 @@ embedded_instances {
     z: 1.0
   }
 }
+embedded_instances {
+  id: "background"
+  data: "components {\n"
+  "  id: \"screen_factory\"\n"
+  "  component: \"/monarch/screen_factory.script\"\n"
+  "  position {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "  }\n"
+  "  rotation {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "    w: 1.0\n"
+  "  }\n"
+  "  properties {\n"
+  "    id: \"screen_id\"\n"
+  "    value: \"background\"\n"
+  "    type: PROPERTY_TYPE_HASH\n"
+  "  }\n"
+  "}\n"
+  "embedded_components {\n"
+  "  id: \"collectionfactory\"\n"
+  "  type: \"collectionfactory\"\n"
+  "  data: \"prototype: \\\"/example/background.collection\\\"\\n"
+  "load_dynamically: false\\n"
+  "\"\n"
+  "  position {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "  }\n"
+  "  rotation {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "    w: 1.0\n"
+  "  }\n"
+  "}\n"
+  ""
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale3 {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+  }
+}

example/game.gui

@@ -48,7 +48,7 @@ nodes {
   yanchor: YANCHOR_NONE
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -103,7 +103,7 @@ nodes {
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
   parent: "root"
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -172,7 +172,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "win_button"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -235,7 +235,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "root"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -244,6 +244,12 @@ nodes {
   text_leading: 1.0
   text_tracking: 0.0
 }
+layers {
+  name: "below"
+}
+layers {
+  name: "text"
+}
 material: "/builtins/materials/gui.material"
 adjust_reference: ADJUST_REFERENCE_PARENT
 max_nodes: 512

example/game.gui_script

@@ -7,11 +7,7 @@ function init(self)
 	local data = monarch.data(hash("game"))
 	gui.set_text(gui.get_node("level"), tostring(data.level))
 
-	self.transition = transitions.create(gui.get_node("root"))
-		.show_in(transitions.slide_in_right, gui.EASING_OUTQUAD, 0.6, 0)
-		.show_out(transitions.slide_out_left, gui.EASING_INQUAD, 0.6, 0)
-		.back_in(transitions.slide_in_left, gui.EASING_OUTQUAD, 0.6, 0)
-		.back_out(transitions.slide_out_right, gui.EASING_INQUAD, 0.6, 0)
+	self.transition = transitions.in_right_out_left(gui.get_node("root"), 0.6, 0)
 end
 
 function on_input(self, action_id, action)

example/main.script

@@ -8,6 +8,8 @@ end
 
 function on_message(self, message_id, message, sender)
 	if message_id == hash("init_monarch") then
+		monarch.show(hash("background"), { no_stack = true }, nil, function()
 			monarch.show(hash("menu"))
+		end)
 	end
 end

example/menu.collection

@@ -35,3 +35,81 @@ embedded_instances {
     z: 1.0
   }
 }
+embedded_instances {
+  id: "popup"
+  data: "components {\n"
+  "  id: \"screen\"\n"
+  "  component: \"/monarch/screen_factory.script\"\n"
+  "  position {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "  }\n"
+  "  rotation {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "    w: 1.0\n"
+  "  }\n"
+  "  properties {\n"
+  "    id: \"screen_id\"\n"
+  "    value: \"popup\"\n"
+  "    type: PROPERTY_TYPE_HASH\n"
+  "  }\n"
+  "  properties {\n"
+  "    id: \"popup\"\n"
+  "    value: \"true\"\n"
+  "    type: PROPERTY_TYPE_BOOLEAN\n"
+  "  }\n"
+  "  properties {\n"
+  "    id: \"popup_on_popup\"\n"
+  "    value: \"true\"\n"
+  "    type: PROPERTY_TYPE_BOOLEAN\n"
+  "  }\n"
+  "  properties {\n"
+  "    id: \"transition_id\"\n"
+  "    value: \"/go\"\n"
+  "    type: PROPERTY_TYPE_HASH\n"
+  "  }\n"
+  "  properties {\n"
+  "    id: \"focus_id\"\n"
+  "    value: \"/go\"\n"
+  "    type: PROPERTY_TYPE_HASH\n"
+  "  }\n"
+  "}\n"
+  "embedded_components {\n"
+  "  id: \"collectionfactory\"\n"
+  "  type: \"collectionfactory\"\n"
+  "  data: \"prototype: \\\"/example/popup.collection\\\"\\n"
+  "load_dynamically: false\\n"
+  "\"\n"
+  "  position {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "  }\n"
+  "  rotation {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "    w: 1.0\n"
+  "  }\n"
+  "}\n"
+  ""
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale3 {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+  }
+}

example/menu.gui

@@ -48,7 +48,7 @@ nodes {
   yanchor: YANCHOR_NONE
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -103,7 +103,7 @@ nodes {
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
   parent: "root"
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -172,7 +172,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "startgame_button"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -221,7 +221,7 @@ nodes {
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
   parent: "root"
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -290,7 +290,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "about_button"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -339,7 +339,7 @@ nodes {
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
   parent: "root"
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -408,7 +408,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "back_button"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -471,7 +471,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "root"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -480,6 +480,67 @@ nodes {
   text_leading: 1.0
   text_tracking: 0.0
 }
+nodes {
+  position {
+    x: 320.0
+    y: 272.0
+    z: 0.0
+    w: 1.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+    w: 1.0
+  }
+  size {
+    x: 40.0
+    y: 40.0
+    z: 0.0
+    w: 1.0
+  }
+  color {
+    x: 0.6
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  type: TYPE_BOX
+  blend_mode: BLEND_MODE_ALPHA
+  texture: ""
+  id: "spinner"
+  xanchor: XANCHOR_NONE
+  yanchor: YANCHOR_NONE
+  pivot: PIVOT_CENTER
+  adjust_mode: ADJUST_MODE_FIT
+  parent: "root"
+  layer: "below"
+  inherit_alpha: true
+  slice9 {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 0.0
+  }
+  clipping_mode: CLIPPING_MODE_NONE
+  clipping_visible: true
+  clipping_inverted: false
+  alpha: 1.0
+  template_node_child: false
+  size_mode: SIZE_MODE_MANUAL
+}
+layers {
+  name: "below"
+}
+layers {
+  name: "text"
+}
 material: "/builtins/materials/gui.material"
 layouts {
   name: "Landscape"
@@ -523,7 +584,7 @@ layouts {
     pivot: PIVOT_CENTER
     adjust_mode: ADJUST_MODE_FIT
     parent: "root"
-    layer: ""
+    layer: "below"
     inherit_alpha: true
     slice9 {
       x: 0.0
@@ -579,7 +640,7 @@ layouts {
     pivot: PIVOT_CENTER
     adjust_mode: ADJUST_MODE_FIT
     parent: "root"
-    layer: ""
+    layer: "below"
     inherit_alpha: true
     slice9 {
       x: 0.0
@@ -635,7 +696,7 @@ layouts {
     pivot: PIVOT_CENTER
     adjust_mode: ADJUST_MODE_FIT
     parent: "root"
-    layer: ""
+    layer: "below"
     inherit_alpha: true
     slice9 {
       x: 0.0
@@ -705,7 +766,7 @@ layouts {
     adjust_mode: ADJUST_MODE_FIT
     line_break: false
     parent: "root"
-    layer: ""
+    layer: "text"
     inherit_alpha: true
     alpha: 1.0
     outline_alpha: 1.0

example/menu.gui_script

@@ -6,11 +6,9 @@ function init(self)
 
 	gui.set_text(gui.get_node("timestamp"), os.date())
 
-	self.transition = transitions.create(gui.get_node("root"))
-		.show_in(transitions.slide_in_right, gui.EASING_OUTQUAD, 0.6, 0)
-		.show_out(transitions.slide_out_left, gui.EASING_INQUAD, 0.6, 0)
-		.back_in(transitions.slide_in_left, gui.EASING_OUTQUAD, 0.6, 0)
-		.back_out(transitions.slide_out_right, gui.EASING_INQUAD, 0.6, 0)
+	gui.animate(gui.get_node("spinner"), gui.PROP_ROTATION, vmath.vector3(0, 0, -360), gui.EASING_INOUTQUAD, 2, 0, nil, gui.PLAYBACK_LOOP_FORWARD)
+
+	self.transition = transitions.fade_in_out(gui.get_node("root"), 0.6, 0)
 end
 
 function on_input(self, action_id, action)

example/popup.gui

@@ -48,7 +48,7 @@ nodes {
   yanchor: YANCHOR_NONE
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -103,7 +103,7 @@ nodes {
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
   parent: "root"
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -172,7 +172,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "ok_button"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -221,7 +221,7 @@ nodes {
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
   parent: "root"
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -290,7 +290,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "cancel_button"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -339,7 +339,7 @@ nodes {
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
   parent: "root"
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -408,7 +408,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "about_button"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -417,6 +417,67 @@ nodes {
   text_leading: 1.0
   text_tracking: 0.0
 }
+nodes {
+  position {
+    x: 184.0
+    y: 136.0
+    z: 0.0
+    w: 1.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+    w: 1.0
+  }
+  size {
+    x: 10.0
+    y: 10.0
+    z: 0.0
+    w: 1.0
+  }
+  color {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+    w: 1.0
+  }
+  type: TYPE_BOX
+  blend_mode: BLEND_MODE_ALPHA
+  texture: ""
+  id: "spinner"
+  xanchor: XANCHOR_NONE
+  yanchor: YANCHOR_NONE
+  pivot: PIVOT_CENTER
+  adjust_mode: ADJUST_MODE_FIT
+  parent: "root"
+  layer: "below"
+  inherit_alpha: true
+  slice9 {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 0.0
+  }
+  clipping_mode: CLIPPING_MODE_NONE
+  clipping_visible: true
+  clipping_inverted: false
+  alpha: 1.0
+  template_node_child: false
+  size_mode: SIZE_MODE_MANUAL
+}
+layers {
+  name: "below"
+}
+layers {
+  name: "text"
+}
 material: "/builtins/materials/gui.material"
 adjust_reference: ADJUST_REFERENCE_PARENT
 max_nodes: 512

example/popup.gui_script

@@ -8,6 +8,8 @@ function init(self)
 	self.about = gui.get_node("about_button")
 	gui.set_render_order(14)
 
+	gui.animate(gui.get_node("spinner"), gui.PROP_ROTATION, vmath.vector3(0, 0, -360), gui.EASING_INOUTQUAD, 2, 0, nil, gui.PLAYBACK_LOOP_FORWARD)
+	
 	self.transition = transitions.create(gui.get_node("root"))
 		.show_in(transitions.scale_in, gui.EASING_OUTBACK, 0.3, 0)
 		.show_out(transitions.scale_out, gui.EASING_INBACK, 0.3, 0)

example/pregame.gui

@@ -48,7 +48,7 @@ nodes {
   yanchor: YANCHOR_NONE
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -103,7 +103,7 @@ nodes {
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
   parent: "root"
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -172,7 +172,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "play_button"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -221,7 +221,7 @@ nodes {
   pivot: PIVOT_CENTER
   adjust_mode: ADJUST_MODE_FIT
   parent: "root"
-  layer: ""
+  layer: "below"
   inherit_alpha: true
   slice9 {
     x: 0.0
@@ -290,7 +290,7 @@ nodes {
   adjust_mode: ADJUST_MODE_FIT
   line_break: false
   parent: "back_button"
-  layer: ""
+  layer: "text"
   inherit_alpha: true
   alpha: 1.0
   outline_alpha: 1.0
@@ -299,6 +299,12 @@ nodes {
   text_leading: 1.0
   text_tracking: 0.0
 }
+layers {
+  name: "below"
+}
+layers {
+  name: "text"
+}
 material: "/builtins/materials/gui.material"
 adjust_reference: ADJUST_REFERENCE_PARENT
 max_nodes: 512

example/pregame.gui_script

@@ -6,11 +6,7 @@ function init(self)
 	self.play = gui.get_node("play_button")
 	self.back = gui.get_node("back_button")
 	
-	self.transition = transitions.create(gui.get_node("root"))
-		.show_in(transitions.slide_in_right, gui.EASING_OUTQUAD, 0.6, 0)
-		.show_out(transitions.slide_out_left, gui.EASING_INQUAD, 0.6, 0)
-		.back_in(transitions.slide_in_left, gui.EASING_OUTQUAD, 0.6, 0)
-		.back_out(transitions.slide_out_right, gui.EASING_INQUAD, 0.6, 0)
+	self.transition = transitions.in_right_out_left(gui.get_node("root"), 0.6, 0)
 end
 
 function on_input(self, action_id, action)

game.project

@@ -1,10 +1,10 @@
 [project]
 title = Monarch
 version = 0.9
-dependencies = https://github.com/britzl/deftest/archive/1.2.1.zip
+dependencies = https://github.com/britzl/deftest/archive/2.7.0.zip
 
 [bootstrap]
-main_collection = /example/example.collectionc
+main_collection = /test/test.collectionc
 
 [input]
 game_binding = /input/game.input_bindingc

monarch/monarch.lua

@@ -1,9 +1,7 @@
+local callback_tracker = require "monarch.utils.callback_tracker"
+
 local M = {}
 
-local screens = {}
-
-local stack = {}
-
 local CONTEXT = hash("monarch_context")
 local PROXY_LOADED = hash("proxy_loaded")
 local PROXY_UNLOADED = hash("proxy_unloaded")
@@ -13,7 +11,9 @@ local ACQUIRE_INPUT_FOCUS = hash("acquire_input_focus")
 local ASYNC_LOAD = hash("async_load")
 local UNLOAD = hash("unload")
 local ENABLE = hash("enable")
+local DISABLE = hash("disable")
 
+-- transition messages
 M.TRANSITION = {}
 M.TRANSITION.DONE = hash("transition_done")
 M.TRANSITION.SHOW_IN = hash("transition_show_in")
@@ -21,10 +21,31 @@ M.TRANSITION.SHOW_OUT = hash("transition_show_out")
 M.TRANSITION.BACK_IN = hash("transition_back_in")
 M.TRANSITION.BACK_OUT = hash("transition_back_out")
 
+-- focus messages
 M.FOCUS = {}
 M.FOCUS.GAINED = hash("monarch_focus_gained")
 M.FOCUS.LOST = hash("monarch_focus_lost")
 
+-- listener messages
+M.SCREEN_TRANSITION_IN_STARTED = hash("monarch_screen_transition_in_started")
+M.SCREEN_TRANSITION_IN_FINISHED = hash("monarch_screen_transition_in_finished")
+M.SCREEN_TRANSITION_OUT_STARTED = hash("monarch_screen_transition_out_started")
+M.SCREEN_TRANSITION_OUT_FINISHED = hash("monarch_screen_transition_out_finished")
+
+
+-- all registered screens
+local screens = {}
+
+-- the current stack of screens
+local stack = {}
+
+-- transition listeners
+local transition_listeners = {}
+
+-- the number of active transitions
+-- monarch is considered busy while there are active transitions
+local active_transition_count = 0
+
 
 local function log(...) end
 
@@ -32,6 +53,27 @@ function M.debug()
 	log = print
 end
 
+-- use a lookup table for so we don't have to do "return (type(s) == "string" and hash(s) or s)"
+-- every time
+local hash_lookup = {}
+local function tohash(s)
+	hash_lookup[s] = hash_lookup[s] or (type(s) == "string" and hash(s) or s)
+	return hash_lookup[s]
+end
+
+local function pcallfn(fn, ...)
+	if fn then
+		local ok, err = pcall(fn, ...)
+		if not ok then print(err) end
+	end
+end
+local function notify_transition_listeners(message_id, message)
+	log("notify_transition_listeners()", message_id)
+	for _,url in pairs(transition_listeners) do
+		msg.post(url, message_id, message or {})
+	end
+end
+
 local function screen_from_proxy(proxy)
 	for _,screen in pairs(screens) do
 		if screen.proxy == proxy then
@@ -51,9 +93,11 @@ end
 
 
 --- Check if a screen exists in the current screen stack
--- @param id
+-- @param id (string|hash)
 -- @return true of the screen is in the stack
 function M.in_stack(id)
+	assert(id, "You must provide a screen id")
+	id = tohash(id)
 	for i = 1, #stack do
 		if stack[i].id == id then
 			return true
@@ -65,17 +109,45 @@ end
 
 --- Check if a screen is at the top of the stack
 -- (primarily used for unit tests, but could have a usecase outside tests)
--- @param id
+-- @param id (string|hash)
 -- @return true if the screen is at the top of the stack
 function M.is_top(id)
+	assert(id, "You must provide a screen id")
+	id = tohash(id)
 	local top = stack[#stack]
 	return top and top.id == id or false
 end
 
 
---- Register a new screen
--- This is done automatically by the screen.script. It is expected that the
--- caller of this function is a script component attached to the same game
+--- Check if a screen is visible
+-- @param id (string|hash)
+-- @return true if the screen is visible
+function M.is_visible(id)
+	assert(id, "You must provide a screen id")
+	id = tohash(id)
+	assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
+	return screens[id].loaded
+end
+
+
+local function register(id, settings)
+	assert(id, "You must provide a screen id")
+	id = tohash(id)
+	assert(not screens[id], ("There is already a screen registered with id %s"):format(tostring(id)))
+	screens[id] = {
+		id = id,
+		script = msg.url(),
+		popup = settings and settings.popup,
+		popup_on_popup = settings and settings.popup_on_popup,
+		timestep_below_popup = settings and settings.timestep_below_popup or 1,
+		preload_listeners = {},
+	}
+	return screens[id]
+end
+
+--- Register a new screen contained in a collection proxy
+-- This is done automatically by the screen_proxy.script. It is expected that
+-- the caller of this function is a script component attached to the same game
 -- object as the proxy. This is required since monarch will acquire and
 -- release input focus of the game object where the proxy is attached.
 -- @param id Unique id of the screen
@@ -88,25 +160,56 @@ end
 --		  screen transitions
 -- 		* focus_url - URL to a script that is to be notified of focus
 --		  lost/gained events
-function M.register(id, proxy, settings)
-	assert(not screens[id], ("There is already a screen registered with id %s"):format(tostring(id)))
+--		* timestep_below_popup - Timestep to set on proxy when below a popup
+--		* auto_preload - true if the screen should be automatically preloaded
+function M.register_proxy(id, proxy, settings)
 	assert(proxy, "You must provide a collection proxy URL")
-	local url = msg.url(proxy)
-	screens[id] = {
-		id = id,
-		proxy = proxy,
-		script = msg.url(),
-		popup = settings and settings.popup,
-		popup_on_popup = settings and settings.popup_on_popup,
-		transition_url = settings and settings.transition_url,
-		focus_url = settings and settings.focus_url,
-	}
+	local screen = register(id, settings)
+	screen.proxy = proxy
+	screen.transition_url = settings and settings.transition_url
+	screen.focus_url = settings and settings.focus_url
+	screen.auto_preload = settings and settings.auto_preload
+	if screen.auto_preload then
+		M.preload(id)
+	end
+end
+M.register = M.register_proxy
+
+
+--- Register a new screen contained in a collection factory
+-- This is done automatically by the screen_factory.script. It is expected that
+-- the caller of this function is a script component attached to the same game
+-- object as the factory. This is required since monarch will acquire and
+-- release input focus of the game object where the factory is attached.
+-- @param id Unique id of the screen
+-- @param factory URL to the collection factory containing the screen
+-- @param settings Settings table for screen. Accepted values:
+-- 		* popup - true the screen is a popup
+--		* popup_on_popup - true if this popup can be shown on top of
+--		  another popup or false if an underlying popup should be closed
+-- 		* transition_id - Id of the game object in the collection that is responsible
+--		  for the screen transitions
+-- 		* focus_id - Id of the game object in the collection that is to be notified
+--		  of focus lost/gained events
+--		* auto_preload - true if the screen should be automatically preloaded
+function M.register_factory(id, factory, settings)
+	assert(factory, "You must provide a collection factory URL")
+	local screen = register(id, settings)
+	screen.factory = factory
+	screen.transition_id = settings and settings.transition_id
+	screen.focus_id = settings and settings.focus_id
+	screen.auto_preload = settings and settings.auto_preload
+	if screen.auto_preload then
+		M.preload(id)
+	end
 end
 
 --- Unregister a screen
 -- This is done automatically by the screen.script
 -- @param id Id of the screen to unregister
 function M.unregister(id)
+	assert(id, "You must provide a screen id")
+	id = tohash(id)
 	assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
 	screens[id] = nil
 end
@@ -114,7 +217,13 @@ end
 local function acquire_input(screen)
 	log("change_context()", screen.id)
 	if not screen.input then
+		if screen.proxy then
 			msg.post(screen.script, ACQUIRE_INPUT_FOCUS)
+		elseif screen.factory then
+			for id,instance in pairs(screen.factory_ids) do
+				msg.post(instance, ACQUIRE_INPUT_FOCUS)
+			end
+		end
 		screen.input = true
 	end
 end
@@ -122,7 +231,13 @@ end
 local function release_input(screen)
 	log("change_context()", screen.id)
 	if screen.input then
+		if screen.proxy then
 			msg.post(screen.script, RELEASE_INPUT_FOCUS)
+		elseif screen.factory then
+			for id,instance in pairs(screen.factory_ids) do
+				msg.post(instance, RELEASE_INPUT_FOCUS)
+			end
+		end
 		screen.input = false
 	end
 end
@@ -135,37 +250,113 @@ local function change_context(screen)
 	screen.wait_for = nil
 end
 
-local function unload(screen)
+local function unload(screen, force)
 	log("unload()", screen.id)
+
+	if screen.proxy then
+		if screen.auto_preload and not force then
+			msg.post(screen.proxy, DISABLE)
+			screen.loaded = false
+			screen.preloaded = true
+		else
 			screen.wait_for = PROXY_UNLOADED
 			msg.post(screen.proxy, UNLOAD)
 			coroutine.yield()
 			screen.loaded = false
+			screen.preloaded = false
 			screen.wait_for = nil
 		end
+	elseif screen.factory then
+		for id, instance in pairs(screen.factory_ids) do
+			go.delete(instance)
+		end
+		screen.factory_ids = nil
+		if screen.auto_preload and not force then
+			screen.loaded = false
+			screen.preloaded = true
+		else
+			collectionfactory.unload(screen.factory)
+			screen.loaded = false
+			screen.preloaded = false
+		end
+	end
+end
 
-local function async_load(screen)
-	log("async_load()", screen.id)
+
+local function preload(screen)
+	log("preload() preloading screen", screen.id)
+	assert(screen.co, "You must assign a coroutine to the screen")
+
+	if screen.preloaded then
+		log("preload() screen already preloaded", screen.id)
+		return
+	end
+
+	if screen.proxy then
 		screen.wait_for = PROXY_LOADED
 		msg.post(screen.proxy, ASYNC_LOAD)
 		coroutine.yield()
-	msg.post(screen.proxy, ENABLE)
-	screen.loaded = true
-	screen.wait_for = nil
+	elseif screen.factory then
+		if collectionfactory.get_status(screen.factory) == collectionfactory.STATUS_UNLOADED then
+			collectionfactory.load(screen.factory, function(self, url, result)
+				assert(coroutine.resume(screen.co))
+			end)
+			coroutine.yield()
 		end
 
-local function transition(screen, message_id)
+		if collectionfactory.get_status(screen.factory) ~= collectionfactory.STATUS_LOADED then
+			log("preload() error loading factory resources")
+			return
+		end
+	end
+	screen.preloaded = true
+end
+
+local function load(screen)
+	log("load()", screen.id)
+	assert(screen.co, "You must assign a coroutine to the screen")
+
+	if screen.loaded then
+		log("load() screen already loaded", screen.id)
+		return
+	end
+
+	preload(screen)
+
+	if not screen.preloaded then
+		log("load() screen wasn't preloaded", screen.id)
+		return
+	end
+
+	if screen.proxy then
+		msg.post(screen.proxy, ENABLE)
+	elseif screen.factory then
+		screen.factory_ids = collectionfactory.create(screen.factory)
+		screen.transition_url = screen.factory_ids[screen.transition_id]
+		screen.focus_url = screen.factory_ids[screen.focus_id]
+	end
+	screen.loaded = true
+	screen.preloaded = false
+end
+
+local function transition(screen, message_id, message)
 	log("transition()", screen.id)
+	if screen.transition_url then
 		screen.wait_for = M.TRANSITION.DONE
-	msg.post(screen.transition_url, message_id)
+		msg.post(screen.transition_url, message_id, message)
 		coroutine.yield()
 		screen.wait_for = nil
+	else
+		log("transition() no transition url - ignoring")
+	end
 end
 
 local function focus_gained(screen, previous_screen)
 	log("focus_gained()", screen.id)
 	if screen.focus_url then
 		msg.post(screen.focus_url, M.FOCUS.GAINED, { id = previous_screen and previous_screen.id })
+	else
+		log("focus_gained() no focus url - ignoring")
 	end
 end
 
@@ -173,148 +364,191 @@ local function focus_lost(screen, next_screen)
 	log("focus_lost()", screen.id)
 	if screen.focus_url then
 		msg.post(screen.focus_url, M.FOCUS.LOST, { id = next_screen and next_screen.id })
+	else
+		log("focus_lost() no focus url - ignoring")
 	end
 end
 
+local function change_timestep(screen)
+	if screen.proxy then
+		screen.changed_timestep = true
+		msg.post(screen.proxy, "set_time_step", { mode = 0, factor = screen.timestep_below_popup })
+	end
+end
+
+local function reset_timestep(screen)
+	if screen.proxy and screen.changed_timestep then
+		msg.post(screen.proxy, "set_time_step", { mode = 0, factor = 1 })
+		screen.changed_timestep = false
+	end
+end
+
+local function run_coroutine(screen, cb, fn)
+	local co
+	co = coroutine.create(function()
+		screen.co = co
+		fn()
+		screen.co = nil
+		pcallfn(cb)
+	end)
+	assert(coroutine.resume(co))
+end
+
 local function disable(screen, next_screen)
 	log("disable()", screen.id)
-	local co
-	co = coroutine.create(function()
-		screen.co = co
+	run_coroutine(screen, nil, function()
 		change_context(screen)
 		release_input(screen)
 		focus_lost(screen, next_screen)
-		screen.co = nil
-		if cb then cb() end
+		if next_screen and next_screen.popup then
+			change_timestep(screen)
+		else
+			reset_timestep(screen)
+		end
 	end)
-	coroutine.resume(co)
 end
 
 local function enable(screen, previous_screen)
 	log("enable()", screen.id)
-	local co
-	co = coroutine.create(function()
-		screen.co = co
+	run_coroutine(screen, nil, function()
 		change_context(screen)
 		acquire_input(screen)
 		focus_gained(screen, previous_screen)
-		screen.co = nil
-		if cb then cb() end
+		reset_timestep(screen)
 	end)
-	coroutine.resume(co)
 end
 
 local function show_out(screen, next_screen, cb)
 	log("show_out()", screen.id)
-	local co
-	co = coroutine.create(function()
-		screen.co = co
+	run_coroutine(screen, cb, function()
+		active_transition_count = active_transition_count + 1
+		notify_transition_listeners(M.SCREEN_TRANSITION_OUT_STARTED, { screen = screen.id, next_screen = next_screen.id })
 		change_context(screen)
 		release_input(screen)
 		focus_lost(screen, next_screen)
+		reset_timestep(screen)
 		-- if the next screen is a popup we want the current screen to stay visible below the popup
 		-- if the next screen isn't a popup the current one should be unloaded and transitioned out
-		local next_is_popup = next_screen and not next_screen.popup
+		local next_is_popup = next_screen and next_screen.popup
 		local current_is_popup = screen.popup
-		if (next_is_popup and not current_is_popup) or (current_is_popup) then
-			transition(screen, M.TRANSITION.SHOW_OUT)
+		if (not next_is_popup and not current_is_popup) or (current_is_popup) then
+			transition(screen, M.TRANSITION.SHOW_OUT, { next_screen = next_screen.id })
 			unload(screen)
+		elseif next_is_popup then
+			change_timestep(screen)
 		end
-		screen.co = nil
-		if cb then cb() end
+		active_transition_count = active_transition_count - 1
+		notify_transition_listeners(M.SCREEN_TRANSITION_OUT_FINISHED, { screen = screen.id, next_screen = next_screen.id })
 	end)
-	coroutine.resume(co)
 end
 
-local function show_in(screen, previous_screen, reload, cb)
+local function show_in(screen, previous_screen, reload, add_to_stack, cb)
 	log("show_in()", screen.id)
-	local co
-	co = coroutine.create(function()
-		screen.co = co
+	run_coroutine(screen, cb, function()
+		active_transition_count = active_transition_count + 1
+		notify_transition_listeners(M.SCREEN_TRANSITION_IN_STARTED, { screen = screen.id, previous_screen = previous_screen and previous_screen.id })
 		change_context(screen)
 		if reload and screen.loaded then
 			log("show_in() reloading", screen.id)
-			unload(screen)
-		end
-		-- the screen could be loaded if the previous screen was a popup
-		-- and the popup asked to show this screen again
-		-- in that case we shouldn't attempt to load it again
-		if not screen.loaded then
-			async_load(screen)
+			unload(screen, reload)
 		end
+		load(screen)
+		if add_to_stack then
 			stack[#stack + 1] = screen
-		transition(screen, M.TRANSITION.SHOW_IN)
+		end
+		reset_timestep(screen)
+		transition(screen, M.TRANSITION.SHOW_IN, { previous_screen = previous_screen and previous_screen.id })
 		acquire_input(screen)
 		focus_gained(screen, previous_screen)
-		screen.co = nil
-		if cb then cb() end
+		active_transition_count = active_transition_count - 1
+		notify_transition_listeners(M.SCREEN_TRANSITION_IN_FINISHED, { screen = screen.id, previous_screen = previous_screen and previous_screen.id })
 	end)
-	coroutine.resume(co)
 end
 
 local function back_in(screen, previous_screen, cb)
 	log("back_in()", screen.id)
-	local co
-	co = coroutine.create(function()
-		screen.co = co
+	run_coroutine(screen, cb, function()
+		active_transition_count = active_transition_count + 1
+		notify_transition_listeners(M.SCREEN_TRANSITION_IN_STARTED, { screen = screen.id, previous_screen = previous_screen and previous_screen.id })
 		change_context(screen)
-		if not screen.loaded then
-			async_load(screen)
-		end
+		load(screen)
+		reset_timestep(screen)
 		if previous_screen and not previous_screen.popup then
-			transition(screen, M.TRANSITION.BACK_IN)
+			transition(screen, M.TRANSITION.BACK_IN, { previous_screen = previous_screen.id })
 		end
 		acquire_input(screen)
 		focus_gained(screen, previous_screen)
-		screen.co = nil
-		if cb then cb() end
+		active_transition_count = active_transition_count - 1
+		notify_transition_listeners(M.SCREEN_TRANSITION_IN_FINISHED, { screen = screen.id, previous_screen = previous_screen and previous_screen.id })
 	end)
-	coroutine.resume(co)
 end
 
 local function back_out(screen, next_screen, cb)
 	log("back_out()", screen.id)
-	local co
-	co = coroutine.create(function()
-		screen.co = co
+	run_coroutine(screen, cb, function()
+		notify_transition_listeners(M.SCREEN_TRANSITION_OUT_STARTED, { screen = screen.id, next_screen = next_screen and next_screen.id })
+		active_transition_count = active_transition_count + 1
 		change_context(screen)
 		release_input(screen)
 		focus_lost(screen, next_screen)
-		transition(screen, M.TRANSITION.BACK_OUT)
+		if next_screen and screen.popup then
+			reset_timestep(next_screen)
+		end
+		transition(screen, M.TRANSITION.BACK_OUT, { next_screen = next_screen and next_screen.id })
 		unload(screen)
-		screen.co = nil
-		if cb then cb() end
+		active_transition_count = active_transition_count - 1
+		notify_transition_listeners(M.SCREEN_TRANSITION_OUT_FINISHED, { screen = screen.id, next_screen = next_screen and next_screen.id })
 	end)
-	coroutine.resume(co)
 end
 
 
 --- Get data associated with a screen
--- @param id Id of the screen to get data for
+-- @param id (string|hash) Id of the screen to get data for
 -- @return Data associated with the screen
 function M.data(id)
 	assert(id, "You must provide a screen id")
+	id = tohash(id)
 	assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
 	return screens[id].data
 end
 
+
 --- Checks to see if a screen id is registered
--- @param id Id of the screen to check if is registered
+-- @param id (string|hash) Id of the screen to check if is registered
 -- @return True or False if the screen id is registered or not
 function M.screen_exists(id)
+	assert(id, "You must provide a screen id")
+	id = tohash(id)
 	return screens[id] ~= nil
 end
 
+
+--- Check if Monarch is busy hiding and or showing a screen
+-- @return true if busy
+function M.is_busy()
+	return active_transition_count > 0
+end
+
+
 --- Show a new screen
--- @param id Id of the screen to show
--- @param options Table with options when showing the screen (can be nil). Valid values:
+-- @param id (string|hash) - Id of the screen to show
+-- @param options (table) - Table with options when showing the screen (can be nil). Valid values:
 -- 		* clear - Set to true if the stack should be cleared down to an existing instance of the screen
 -- 		* reload - Set to true if screen should be reloaded if it already exists in the stack and is loaded.
 --				   This would be the case if doing a show() from a popup on the screen just below the popup.
--- @param data Optional data to set on the screen. Can be retrieved by the data() function
--- @param cb Optional callback to invoke when screen is shown
+-- @param data (*) - Optional data to set on the screen. Can be retrieved by the data() function
+-- @param cb (function) - Optional callback to invoke when screen is shown
+-- @return success True if screen is successfully shown, false if busy performing another operation
 function M.show(id, options, data, cb)
 	assert(id, "You must provide a screen id")
+	if M.is_busy() then
+		log("show() monarch is busy, ignoring request")
+		return false
+	end
+
+	local callbacks = callback_tracker()
+
+	id = tohash(id)
 	assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
 
 	local screen = screens[id]
@@ -322,8 +556,13 @@ function M.show(id, options, data, cb)
 
 	log("show()", screen.id)
 
+	local co
+	co = coroutine.create(function()
+		-- a screen can ignore the stack by setting the no_stack to true
+		local add_to_stack = not options or not options.no_stack
+		if add_to_stack then
 			-- manipulate the current top
-	-- close popup if needed
+			-- close popup(s) if needed
 			-- transition out
 			local top = stack[#stack]
 			if top then
@@ -331,16 +570,20 @@ function M.show(id, options, data, cb)
 				if top.popup and screen.popup_on_popup then
 					disable(top, screen)
 				else
-			-- close all popups
+					-- close all popups, one by one
 					while top.popup do
 						stack[#stack] = nil
-				show_out(top, screen)
+						show_out(top, screen, function()
+							coroutine.resume(co)
+						end)
+						coroutine.yield()
 						top = stack[#stack]
 					end
 					-- unload and transition out from top
 					-- unless we're showing the same screen as is already visible
 					if top and top.id ~= screen.id then
-				show_out(top, screen)
+						show_out(top, screen, callbacks.track())
+					end
 				end
 			end
 		end
@@ -356,15 +599,70 @@ function M.show(id, options, data, cb)
 			end
 		end
 
-	-- show screen
-	show_in(screen, top, options and options.reload, cb)
+		-- show screen, wait until preloaded if it is already preloading
+		-- this can typpically happen if you do a show() on app start for a
+		-- screen that has Preload set to true
+		if M.is_preloading(id) then
+			M.when_preloaded(id, function()
+				coroutine.resume(co)
+			end)
+			coroutine.yield()
+		end
+		show_in(screen, top, options and options.reload, add_to_stack, callbacks.track())
+
+		if cb then callbacks.when_done(cb) end
+	end)
+	coroutine.resume(co)
+
+	return true
+end
+
+
+-- Hide a screen. The screen must either be at the top of the stack or
+-- visible but not added to the stack (through the no_stack option)
+-- @param id (string|hash) - Id of the screen to show
+-- @param cb (function) - Optional callback to invoke when the screen is hidden
+-- @return true if successfully hiding, false if busy performing another operation
+function M.hide(id, cb)
+	if M.is_busy() then
+		log("hide() monarch is busy, ignoring request")
+		return false
+	end
+	
+	id = tohash(id)
+	assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
+
+	local screen = screens[id]
+	log("hide()", screen.id)
+	if M.in_stack(id) then
+		if not M.is_top(id) then
+			log("hide() you can only hide the screen at the top of the stack", id)
+			return false
+		end
+		return M.back(id, cb)
+	else
+		if M.is_visible(id) then
+			back_out(screen, nil, cb)
+		else
+			pcallfn(cb)
+		end
+	end
+	return true
 end
 
 
 -- Go back to the previous screen in the stack
--- @param data Optional data to set for the previous screen
--- @param cb Optional callback to invoke when the previous screen is visible again
+-- @param data (*) - Optional data to set for the previous screen
+-- @param cb (function) - Optional callback to invoke when the previous screen is visible again
+-- @return true if successfully going back, false if busy performing another operation
 function M.back(data, cb)
+	if M.is_busy() then
+		log("back() monarch is busy, ignoring request")
+		return false
+	end
+
+	local callbacks = callback_tracker()
+
 	local screen = table.remove(stack)
 	if screen then
 		log("back()", screen.id)
@@ -376,7 +674,7 @@ function M.back(data, cb)
 				if data then
 					top.data = data
 				end
-				back_in(top, screen, cb)
+				back_in(top, screen, callbacks.track())
 			end)
 		else
 			back_out(screen, top)
@@ -384,12 +682,115 @@ function M.back(data, cb)
 				if data then
 					top.data = data
 				end
-				back_in(top, screen, cb)
+				back_in(top, screen, callbacks.track())
 			end
 		end
-	elseif cb then
-		cb()
 	end
+
+	if cb then callbacks.when_done(cb) end
+
+	return true
+end
+
+
+--- Check if a screen is preloading via monarch.preload() or automatically
+-- via the Preload screen option
+-- @param id Screen id
+-- @return true if preloading
+function M.is_preloading(id)
+	assert(id, "You must provide a screen id")
+	id = tohash(id)
+	assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
+	local screen = screens[id]
+	return screen.preloading
+end
+
+
+--- Invoke a callback when a specific screen has been preloaded
+-- This is mainly useful on app start when wanting to show a screen that
+-- has the Preload flag set (since it will immediately start to load which
+-- would prevent a call to monarch.show from having any effect).
+function M.when_preloaded(id, cb)
+	assert(id, "You must provide a screen id")
+	id = tohash(id)
+	assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
+	local screen = screens[id]
+	if screen.preloaded or screen.loaded then
+		pcallfn(cb, id)
+	else
+		screen.preload_listeners[#screen.preload_listeners + 1] = cb
+	end
+end
+
+
+--- Preload a screen. This will load but not enable and show a screen. Useful for "heavier" screens
+-- that you wish to show without any delay.
+-- @param id (string|hash) - Id of the screen to preload
+-- @param cb (function) - Optional callback to invoke when screen is loaded
+function M.preload(id, cb)
+	if M.is_busy() then
+		log("preload() monarch is busy, ignoring request")
+		return false
+	end
+
+	assert(id, "You must provide a screen id")
+	id = tohash(id)
+	assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
+
+	local screen = screens[id]
+	log("preload()", screen.id)
+	if screen.preloaded or screen.loaded then
+		pcallfn(cb)
+		return true
+	end
+	
+	local function when_preloaded()
+		-- invoke any listeners added using monarch.when_preloaded()
+		while #screen.preload_listeners > 0 do
+			pcallfn(table.remove(screen.preload_listeners), id)
+		end
+		-- invoke the normal callback
+		pcallfn(cb)
+	end
+	run_coroutine(screen, when_preloaded, function()
+		screen.preloading = true
+		change_context(screen)
+		preload(screen)
+		screen.preloading = false
+	end)
+	return true
+end
+
+
+--- Unload a preloaded monarch screen
+-- @param id (string|hash) - Id of the screen to unload
+-- @param cb (function) - Optional callback to invoke when screen is unloaded
+function M.unload(id, cb)
+	if M.is_busy() then
+		log("unload() monarch is busy, ignoring request")
+		return false
+	end
+	assert(id, "You must provide a screen id")
+	id = tohash(id)
+	assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
+
+	if M.is_visible(id) then
+		log("You can't unload a visible screen")
+		return false
+	end
+
+	local screen = screens[id]
+	log("unload()", screen.id)
+	if not screen.preloaded and not screen.loaded then
+		log("unload() screen is not loaded", tostring(id))
+		pcallfn(cb)
+		return true
+	end
+	run_coroutine(screen, cb, function()
+		change_context(screen)
+		unload(screen)
+	end)
+	return true
 end
 
 
@@ -433,6 +834,45 @@ function M.get_stack()
 	return s
 end
 
+
+--- Get the screen on top of the stack
+-- @param offset Optional offset from the top of the stack, (eg -1 for the previous screen)
+-- @return Id of the requested screen
+function M.top(offset)
+	local screen = stack[#stack + (offset or 0)]
+	return screen and screen.id
+end
+
+
+--- Get the screen at the bottom of the stack
+-- @param offset Optional offset from the bottom of the stack
+-- @return Id of the requested screen
+function M.bottom(offset)
+	local screen = stack[1 + (offset or 0)]
+	return screen and screen.id
+end
+
+local function url_to_key(url)
+	return (url.socket or hash("")) .. (url.path or hash("")) .. (url.fragment or hash(""))
+end
+
+
+--- Add a listener to be notified of when screens are shown or hidden
+-- @param url The url to notify, nil for current url
+function M.add_listener(url)
+	url = url or msg.url()
+	transition_listeners[url_to_key(url)] = url
+end
+
+
+--- Remove a previously added listener
+-- @param url The url to remove, nil for current url
+function M.remove_listener(url)
+	url = url or msg.url()
+	transition_listeners[url_to_key(url)] = nil
+end
+
+
 function M.dump_stack()
 	local s = ""
 	for i, screen in ipairs(stack) do

monarch/screen.script

@@ -1,26 +1,31 @@
 local monarch
 
 go.property("screen_proxy", msg.url("#collectionproxy"))
-go.property("screen_id", hash(""))
+go.property("screen_id", hash("UNIQUE ID HERE"))
 go.property("popup", false)
 go.property("popup_on_popup", false)
+go.property("timestep_below_popup", 1)
 go.property("transition_url", msg.url())
 go.property("focus_url", msg.url())
 
 
 function init(self)
+	print("WARNING - screen.script is deprecated. Please use screen_proxy.script")
 	monarch = require "monarch.monarch"
+	local url = msg.url()
 	assert(not self.popup_on_popup or (self.popup_on_popup and self.popup), "Popup on Popups can only be set if the Popup flag is set")
-	monarch.register(
-		self.screen_id,
-		self.screen_proxy,
-		{
+	assert(self.screen_proxy ~= url, "You must specify either a proxy URL")
+	assert(self.timestep_below_popup >= 0, "Timestep must be positive")
+
+	local settings = {
 		popup = self.popup,
 		popup_on_popup = self.popup_on_popup,
-			transition_url = self.transition_url,
-			focus_url = self.focus_url
+		transition_url = self.transition_url ~= url and self.transition_url or nil,
+		focus_url = self.focus_url ~= url and self.focus_url or nil,
+		timestep_below_popup = self.timestep_below_popup,
 	}
-	)
+
+	monarch.register_proxy(self.screen_id, self.screen_proxy, settings)
 end
 
 function final(self)
@@ -34,11 +39,6 @@ function on_message(self, message_id, message, sender)
 		monarch.back()
 	elseif message_id == hash("back") then
 		monarch.back()
-	elseif message_id == monarch.TRANSITION.SHOW_IN
-		or message_id == monarch.TRANSITION.SHOW_OUT
-		or message_id == monarch.TRANSITION.BACK_IN
-		or message_id == monarch.TRANSITION.BACK_OUT then
-			msg.post(sender, monarch.TRANSITION.DONE)
 	else
 		monarch.on_message(message_id, message, sender)
 	end

monarch/screen_factory.script

@@ -0,0 +1,41 @@
+local monarch
+
+go.property("screen_factory", msg.url("#collectionfactory"))
+go.property("screen_id", hash("UNIQUE ID HERE"))
+go.property("popup", false)
+go.property("popup_on_popup", false)
+go.property("transition_id", hash(""))
+go.property("focus_id", hash(""))
+go.property("preload", false)
+
+
+function init(self)
+	monarch = require "monarch.monarch"
+	assert(not self.popup_on_popup or (self.popup_on_popup and self.popup), "Popup on Popups can only be set if the Popup flag is set")
+	assert(self.screen_factory ~= msg.url(), "You must specify either a factory URL")
+	
+	local settings = {
+		popup = self.popup,
+		popup_on_popup = self.popup_on_popup,
+		transition_id = self.transition_id,
+		focus_id = self.focus_id,
+		auto_preload = self.preload,
+	}
+	monarch.register_factory(self.screen_id, self.screen_factory, settings)
+end
+
+function final(self)
+	monarch.unregister(self.screen_id)
+end
+
+function on_message(self, message_id, message, sender)
+	if message_id == hash("show") then
+		monarch.show(self.screen_id, { clear = message.clear })
+	elseif message_id == hash("hide") then
+		monarch.back()
+	elseif message_id == hash("back") then
+		monarch.back()
+	else
+		monarch.on_message(message_id, message, sender)
+	end
+end

monarch/screen_proxy.script

@@ -0,0 +1,46 @@
+local monarch
+
+go.property("screen_proxy", msg.url("#collectionproxy"))
+go.property("screen_id", hash("UNIQUE ID HERE"))
+go.property("popup", false)
+go.property("popup_on_popup", false)
+go.property("timestep_below_popup", 1)
+go.property("transition_url", msg.url())
+go.property("focus_url", msg.url())
+go.property("preload", false)
+
+
+function init(self)
+	monarch = require "monarch.monarch"
+	local url = msg.url()
+	assert(not self.popup_on_popup or (self.popup_on_popup and self.popup), "Popup on Popups can only be set if the Popup flag is set")
+	assert(self.screen_proxy ~= url, "You must specify either a proxy URL")
+	assert(self.timestep_below_popup >= 0, "Timestep must be positive")
+	
+	local settings = {
+		popup = self.popup,
+		popup_on_popup = self.popup_on_popup,
+		transition_url = self.transition_url ~= url and self.transition_url or nil,
+		focus_url = self.focus_url ~= url and self.focus_url or nil,
+		timestep_below_popup = self.timestep_below_popup,
+		auto_preload = self.preload,
+	}
+
+	monarch.register_proxy(self.screen_id, self.screen_proxy, settings)
+end
+
+function final(self)
+	monarch.unregister(self.screen_id)
+end
+
+function on_message(self, message_id, message, sender)
+	if message_id == hash("show") then
+		monarch.show(self.screen_id, { clear = message.clear })
+	elseif message_id == hash("hide") then
+		monarch.back()
+	elseif message_id == hash("back") then
+		monarch.back()
+	else
+		monarch.on_message(message_id, message, sender)
+	end
+end

monarch/transitions/easings.lua

@@ -0,0 +1,26 @@
+local M = {}
+
+
+local function create(name)
+	assert(gui["EASING_OUT" .. name])
+	assert(gui["EASING_IN" .. name])
+	return {
+		IN = gui["EASING_OUT" .. name],
+		OUT = gui["EASING_IN" .. name],
+	}
+end
+
+
+function M.BACK() return create("BACK") end
+function M.BOUNCE() return create("BOUNCE") end
+function M.CIRC() return create("CIRC") end
+function M.CUBIC() return create("CUBIC") end
+function M.ELASTIC() return create("ELASTIC") end
+function M.EXPO() return create("EXPO") end
+function M.QUAD() return create("QUAD") end
+function M.QUART() return create("QUART") end
+function M.QUINT() return create("QUINT") end
+function M.SINE() return create("SINE") end
+
+
+return M

monarch/transitions/gui.lua

@@ -1,4 +1,5 @@
 local monarch = require "monarch.monarch"
+local easings = require "monarch.transitions.easings"
 
 local M = {}
 
@@ -87,6 +88,22 @@ function M.scale_out(node, from, easing, duration, delay, cb)
 	gui.animate(node, gui.PROP_SCALE, ZERO_SCALE, easing, duration, delay, cb)
 end
 
+function M.fade_out(node, from, easing, duration, delay, cb)
+	local to = gui.get_color(node)
+	to.w = 1
+	gui.set_color(node, to)
+	to.w = 0
+	gui.animate(node, gui.PROP_COLOR, to, easing, duration, delay, cb)
+end
+
+function M.fade_in(node, from, easing, duration, delay, cb)
+	local to = gui.get_color(node)
+	to.w = 0
+	gui.set_color(node, to)
+	to.w = 1
+	gui.animate(node, gui.PROP_COLOR, to, easing, duration, delay, cb)
+end
+
 --- Create a transition for a node
 -- @return Transition instance
 function M.create(node)
@@ -96,6 +113,8 @@ function M.create(node)
 
 	local transitions = {}
 
+	local current_transition = nil
+	
 	local initial_data = {}
 	initial_data.pos = gui.get_position(node)
 	initial_data.scale = gui.get_scale(node)
@@ -108,19 +127,28 @@ function M.create(node)
 			delay = delay,
 			in_progress = false,
 			urls = {},
+			id = nil
 		}
 	end
 
-	local function start_transition(transition, url)
-		table.insert(transition.urls, url)
-		if not transition.in_progress then
-			transition.in_progress = true
-			transition.fn(node, initial_data, transition.easing, transition.duration, transition.delay or 0, function()
+	local function finish_transition(transition)
 		transition.in_progress = false
+		local message = { transition = transition.id }
 		while #transition.urls > 0 do
 			local url = table.remove(transition.urls)
-					msg.post(url, monarch.TRANSITION.DONE)
+			msg.post(url, monarch.TRANSITION.DONE, message)
 		end
+	end
+
+	local function start_transition(transition, transition_id, url)
+		table.insert(transition.urls, url)
+		if not transition.in_progress then
+			table.insert(transition.urls, msg.url())
+			transition.in_progress = true
+			transition.id = transition_id
+			current_transition = transition
+			transition.fn(node, initial_data, transition.easing, transition.duration, transition.delay or 0, function()
+				finish_transition(transition)
 			end)
 		end
 	end
@@ -129,10 +157,19 @@ function M.create(node)
 	function instance.handle(message_id, message, sender)
 		if message_id == LAYOUT_CHANGED then
 			initial_data.pos = gui.get_position(node)
+			-- replay the current transition if the layout changes
+			-- this will ensure that things are still hidden if they
+			-- were transitioned out
+			if current_transition then
+				current_transition.fn(node, initial_data, current_transition.easing, 0, 0)
+				if current_transition.in_progress then
+					finish_transition(current_transition)
+				end
+			end
 		else
 			local transition = transitions[message_id]
 			if transition then
-				start_transition(transition, sender)
+				start_transition(transition, message_id, sender)
 			end
 		end
 	end
@@ -178,4 +215,72 @@ function M.create(node)
 	return instance
 end
 
+
+--- Create transition where the screen slides in from the right when shown and out
+-- to the left when hidden (and the reverse when going back)
+-- @param node
+-- @param duration
+-- @param delay Optional. Defaults to 0
+-- @param easing Optional. A constant from monarch.transitions.easing
+-- @return Transition instance
+function M.in_right_out_left(node, duration, delay, easing)
+	assert(node, "You must provide a node")
+	assert(duration, "You must provide a duration")
+	easing = easing or easings.QUAD()
+	return M.create(node)
+	.show_in(M.slide_in_right, easing.OUT, duration, delay or 0)
+	.show_out(M.slide_out_left, easing.IN, duration, delay or 0)
+	.back_in(M.slide_in_left, easing.OUT, duration, delay or 0)
+	.back_out(M.slide_out_right, easing.IN, duration, delay or 0)
+end
+
+
+function M.in_left_out_right(node, duration, delay, easing)
+	assert(node, "You must provide a node")
+	assert(duration, "You must provide a duration")
+	easing = easing or easings.QUAD()
+	return M.create(node)
+	.show_in(M.slide_in_left, easing.OUT, duration, delay or 0)
+	.show_out(M.slide_out_right, easing.IN, duration, delay or 0)
+	.back_in(M.slide_in_right, easing.OUT, duration, delay or 0)
+	.back_out(M.slide_out_left, easing.IN, duration, delay or 0)
+end
+
+
+function M.in_right_out_right(node, duration, delay, easing)
+	assert(node, "You must provide a node")
+	assert(duration, "You must provide a duration")
+	easing = easing or easings.QUAD()
+	return M.create(node)
+	.show_in(M.slide_in_right, easing.OUT, duration, delay or 0)
+	.show_out(M.slide_out_right, easing.IN, duration, delay or 0)
+	.back_in(M.slide_in_right, easing.OUT, duration, delay or 0)
+	.back_out(M.slide_out_right, easing.IN, duration, delay or 0)
+end
+
+
+function M.in_left_out_left(node, duration, delay, easing)
+	assert(node, "You must provide a node")
+	assert(duration, "You must provide a duration")
+	easing = easing or easings.QUAD()
+	return M.create(node)
+	.show_in(M.slide_in_left, easing.OUT, duration, delay or 0)
+	.show_out(M.slide_out_left, easing.IN, duration, delay or 0)
+	.back_in(M.slide_in_left, easing.OUT, duration, delay or 0)
+	.back_out(M.slide_out_left, easing.IN, duration, delay or 0)
+end
+
+
+function M.fade_in_out(node, duration, delay, easing)
+	assert(node, "You must provide a node")
+	assert(duration, "You must provide a duration")
+	easing = easing or easings.QUAD()
+	return M.create(node)
+	.show_in(M.fade_in, easing.OUT, duration, delay or 0)
+	.show_out(M.fade_out, easing.IN, duration, delay or 0)
+	.back_in(M.fade_in, easing.OUT, duration, delay or 0)
+	.back_out(M.fade_out, easing.IN, duration, delay or 0)
+end
+
+
 return M

monarch/utils/callback_tracker.lua

@@ -0,0 +1,42 @@
+local M = {}
+
+
+function M.create()
+	local instance = {}
+
+	local callback = nil
+	local callback_count = 0
+
+	local function invoke_if_done()
+		if callback_count == 0 and callback then
+			local ok, err = pcall(callback)
+			if not ok then print(err) end
+		end
+	end
+
+	--- Create a callback function and track when it is done
+	-- @return Callback function
+	function instance.track()
+		callback_count = callback_count + 1
+		return function()
+			callback_count = callback_count - 1
+			invoke_if_done()
+		end
+	end
+
+	--- Call a function when all callbacks have been triggered
+	-- @param cb Function to call when all 
+	function instance.when_done(cb)
+		callback = cb
+		invoke_if_done()
+	end
+
+	return instance
+end
+
+
+return setmetatable(M, {
+	__call = function(_, ...)
+		return M.create(...)
+	end
+})

test/data/background.collection

@@ -0,0 +1,22 @@
+name: "default"
+scale_along_z: 0
+embedded_instances {
+  id: "go"
+  data: ""
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale3 {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+  }
+}

test/data/screen_preload.collection

@@ -0,0 +1,37 @@
+name: "screen_preload"
+scale_along_z: 0
+embedded_instances {
+  id: "go"
+  data: "components {\n"
+  "  id: \"screen_preload\"\n"
+  "  component: \"/test/data/screen_preload.gui\"\n"
+  "  position {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "  }\n"
+  "  rotation {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "    w: 1.0\n"
+  "  }\n"
+  "}\n"
+  ""
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale3 {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+  }
+}

test/data/screen_preload.gui

@@ -0,0 +1,131 @@
+script: "/test/data/screen_preload.gui_script"
+fonts {
+  name: "example"
+  font: "/assets/example.font"
+}
+background_color {
+  x: 0.0
+  y: 0.0
+  z: 0.0
+  w: 0.0
+}
+nodes {
+  position {
+    x: 320.0
+    y: 697.0
+    z: 0.0
+    w: 1.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+    w: 1.0
+  }
+  size {
+    x: 200.0
+    y: 100.0
+    z: 0.0
+    w: 1.0
+  }
+  color {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+    w: 1.0
+  }
+  type: TYPE_BOX
+  blend_mode: BLEND_MODE_ALPHA
+  texture: ""
+  id: "box"
+  xanchor: XANCHOR_NONE
+  yanchor: YANCHOR_NONE
+  pivot: PIVOT_CENTER
+  adjust_mode: ADJUST_MODE_FIT
+  layer: ""
+  inherit_alpha: true
+  slice9 {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 0.0
+  }
+  clipping_mode: CLIPPING_MODE_NONE
+  clipping_visible: true
+  clipping_inverted: false
+  alpha: 1.0
+  template_node_child: false
+  size_mode: SIZE_MODE_AUTO
+}
+nodes {
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+    w: 1.0
+  }
+  size {
+    x: 200.0
+    y: 100.0
+    z: 0.0
+    w: 1.0
+  }
+  color {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  type: TYPE_TEXT
+  blend_mode: BLEND_MODE_ALPHA
+  text: "PRELOAD"
+  font: "example"
+  id: "text"
+  xanchor: XANCHOR_NONE
+  yanchor: YANCHOR_NONE
+  pivot: PIVOT_CENTER
+  outline {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+    w: 1.0
+  }
+  shadow {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+    w: 1.0
+  }
+  adjust_mode: ADJUST_MODE_FIT
+  line_break: false
+  parent: "box"
+  layer: ""
+  inherit_alpha: true
+  alpha: 1.0
+  outline_alpha: 1.0
+  shadow_alpha: 1.0
+  template_node_child: false
+  text_leading: 1.0
+  text_tracking: 0.0
+}
+material: "/builtins/materials/gui.material"
+adjust_reference: ADJUST_REFERENCE_PARENT
+max_nodes: 512

test/data/screen_preload.gui_script

@@ -0,0 +1,5 @@
+function init(self)
+	local monarch = require "monarch.monarch"
+	local data = monarch.data(hash("screen_preload"))
+	data.count = data.count + 1
+end

test/data/screens.collection

@@ -4,7 +4,7 @@ embedded_instances {
   id: "screen1"
   data: "components {\n"
   "  id: \"screen\"\n"
-  "  component: \"/monarch/screen.script\"\n"
+  "  component: \"/monarch/screen_proxy.script\"\n"
   "  position {\n"
   "    x: 0.0\n"
   "    y: 0.0\n"
@@ -62,7 +62,7 @@ embedded_instances {
   id: "screen2"
   data: "components {\n"
   "  id: \"screen\"\n"
-  "  component: \"/monarch/screen.script\"\n"
+  "  component: \"/monarch/screen_factory.script\"\n"
   "  position {\n"
   "    x: 0.0\n"
   "    y: 0.0\n"
@@ -81,10 +81,10 @@ embedded_instances {
   "  }\n"
   "}\n"
   "embedded_components {\n"
-  "  id: \"collectionproxy\"\n"
-  "  type: \"collectionproxy\"\n"
-  "  data: \"collection: \\\"/test/data/screen2.collection\\\"\\n"
-  "exclude: false\\n"
+  "  id: \"collectionfactory\"\n"
+  "  type: \"collectionfactory\"\n"
+  "  data: \"prototype: \\\"/test/data/screen2.collection\\\"\\n"
+  "load_dynamically: false\\n"
   "\"\n"
   "  position {\n"
   "    x: 0.0\n"
@@ -120,7 +120,7 @@ embedded_instances {
   id: "popup1"
   data: "components {\n"
   "  id: \"screen\"\n"
-  "  component: \"/monarch/screen.script\"\n"
+  "  component: \"/monarch/screen_proxy.script\"\n"
   "  position {\n"
   "    x: 0.0\n"
   "    y: 0.0\n"
@@ -142,11 +142,6 @@ embedded_instances {
   "    value: \"true\"\n"
   "    type: PROPERTY_TYPE_BOOLEAN\n"
   "  }\n"
-  "  properties {\n"
-  "    id: \"popup_on_popup\"\n"
-  "    value: \"false\"\n"
-  "    type: PROPERTY_TYPE_BOOLEAN\n"
-  "  }\n"
   "}\n"
   "embedded_components {\n"
   "  id: \"collectionproxy\"\n"
@@ -188,7 +183,7 @@ embedded_instances {
   id: "popup2"
   data: "components {\n"
   "  id: \"screen\"\n"
-  "  component: \"/monarch/screen.script\"\n"
+  "  component: \"/monarch/screen_proxy.script\"\n"
   "  position {\n"
   "    x: 0.0\n"
   "    y: 0.0\n"
@@ -252,3 +247,227 @@ embedded_instances {
     z: 1.0
   }
 }
+embedded_instances {
+  id: "transition1"
+  data: "components {\n"
+  "  id: \"screen\"\n"
+  "  component: \"/monarch/screen_proxy.script\"\n"
+  "  position {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "  }\n"
+  "  rotation {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "    w: 1.0\n"
+  "  }\n"
+  "  properties {\n"
+  "    id: \"screen_id\"\n"
+  "    value: \"transition1\"\n"
+  "    type: PROPERTY_TYPE_HASH\n"
+  "  }\n"
+  "  properties {\n"
+  "    id: \"transition_url\"\n"
+  "    value: \"transition1:/go\"\n"
+  "    type: PROPERTY_TYPE_URL\n"
+  "  }\n"
+  "}\n"
+  "embedded_components {\n"
+  "  id: \"collectionproxy\"\n"
+  "  type: \"collectionproxy\"\n"
+  "  data: \"collection: \\\"/test/data/transition1.collection\\\"\\n"
+  "exclude: false\\n"
+  "\"\n"
+  "  position {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "  }\n"
+  "  rotation {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "    w: 1.0\n"
+  "  }\n"
+  "}\n"
+  ""
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale3 {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+  }
+}
+embedded_instances {
+  id: "listener1"
+  data: ""
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale3 {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+  }
+}
+embedded_instances {
+  id: "listener2"
+  data: ""
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale3 {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+  }
+}
+embedded_instances {
+  id: "background"
+  data: "components {\n"
+  "  id: \"screen_factory\"\n"
+  "  component: \"/monarch/screen_factory.script\"\n"
+  "  position {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "  }\n"
+  "  rotation {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "    w: 1.0\n"
+  "  }\n"
+  "  properties {\n"
+  "    id: \"screen_id\"\n"
+  "    value: \"background\"\n"
+  "    type: PROPERTY_TYPE_HASH\n"
+  "  }\n"
+  "}\n"
+  "embedded_components {\n"
+  "  id: \"collectionfactory\"\n"
+  "  type: \"collectionfactory\"\n"
+  "  data: \"prototype: \\\"/test/data/background.collection\\\"\\n"
+  "load_dynamically: false\\n"
+  "\"\n"
+  "  position {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "  }\n"
+  "  rotation {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "    w: 1.0\n"
+  "  }\n"
+  "}\n"
+  ""
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale3 {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+  }
+}
+embedded_instances {
+  id: "screen_preload"
+  data: "components {\n"
+  "  id: \"screen\"\n"
+  "  component: \"/monarch/screen_factory.script\"\n"
+  "  position {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "  }\n"
+  "  rotation {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "    w: 1.0\n"
+  "  }\n"
+  "  properties {\n"
+  "    id: \"screen_id\"\n"
+  "    value: \"screen_preload\"\n"
+  "    type: PROPERTY_TYPE_HASH\n"
+  "  }\n"
+  "  properties {\n"
+  "    id: \"preload\"\n"
+  "    value: \"true\"\n"
+  "    type: PROPERTY_TYPE_BOOLEAN\n"
+  "  }\n"
+  "}\n"
+  "embedded_components {\n"
+  "  id: \"collectionfactory\"\n"
+  "  type: \"collectionfactory\"\n"
+  "  data: \"prototype: \\\"/test/data/screen_preload.collection\\\"\\n"
+  "load_dynamically: false\\n"
+  "\"\n"
+  "  position {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "  }\n"
+  "  rotation {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "    w: 1.0\n"
+  "  }\n"
+  "}\n"
+  ""
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale3 {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+  }
+}

test/data/transition1.collection

@@ -0,0 +1,37 @@
+name: "transition1"
+scale_along_z: 0
+embedded_instances {
+  id: "go"
+  data: "components {\n"
+  "  id: \"transition1\"\n"
+  "  component: \"/test/data/transition1.gui\"\n"
+  "  position {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "  }\n"
+  "  rotation {\n"
+  "    x: 0.0\n"
+  "    y: 0.0\n"
+  "    z: 0.0\n"
+  "    w: 1.0\n"
+  "  }\n"
+  "}\n"
+  ""
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale3 {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+  }
+}

test/data/transition1.gui

@@ -0,0 +1,131 @@
+script: "/test/data/transition1.gui_script"
+fonts {
+  name: "example"
+  font: "/assets/example.font"
+}
+background_color {
+  x: 0.0
+  y: 0.0
+  z: 0.0
+  w: 0.0
+}
+nodes {
+  position {
+    x: 320.0
+    y: 697.0
+    z: 0.0
+    w: 1.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+    w: 1.0
+  }
+  size {
+    x: 200.0
+    y: 100.0
+    z: 0.0
+    w: 1.0
+  }
+  color {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+    w: 1.0
+  }
+  type: TYPE_BOX
+  blend_mode: BLEND_MODE_ALPHA
+  texture: ""
+  id: "root"
+  xanchor: XANCHOR_NONE
+  yanchor: YANCHOR_NONE
+  pivot: PIVOT_CENTER
+  adjust_mode: ADJUST_MODE_FIT
+  layer: ""
+  inherit_alpha: true
+  slice9 {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 0.0
+  }
+  clipping_mode: CLIPPING_MODE_NONE
+  clipping_visible: true
+  clipping_inverted: false
+  alpha: 1.0
+  template_node_child: false
+  size_mode: SIZE_MODE_AUTO
+}
+nodes {
+  position {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+    w: 1.0
+  }
+  size {
+    x: 200.0
+    y: 100.0
+    z: 0.0
+    w: 1.0
+  }
+  color {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  type: TYPE_TEXT
+  blend_mode: BLEND_MODE_ALPHA
+  text: "transition 1"
+  font: "example"
+  id: "text"
+  xanchor: XANCHOR_NONE
+  yanchor: YANCHOR_NONE
+  pivot: PIVOT_CENTER
+  outline {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+    w: 1.0
+  }
+  shadow {
+    x: 1.0
+    y: 1.0
+    z: 1.0
+    w: 1.0
+  }
+  adjust_mode: ADJUST_MODE_FIT
+  line_break: false
+  parent: "root"
+  layer: ""
+  inherit_alpha: true
+  alpha: 1.0
+  outline_alpha: 1.0
+  shadow_alpha: 1.0
+  template_node_child: false
+  text_leading: 1.0
+  text_tracking: 0.0
+}
+material: "/builtins/materials/gui.material"
+adjust_reference: ADJUST_REFERENCE_PARENT
+max_nodes: 512

test/data/transition1.gui_script

@@ -0,0 +1,10 @@
+local transitions = require "monarch.transitions.gui"
+
+function init(self)
+	self.transition = transitions.in_right_out_left(gui.get_node("root"), 1)
+end
+
+function on_message(self, message_id, message, sender)
+	print(message_id)
+	self.transition.handle(message_id, message, sender)
+end

test/msg.lua

@@ -0,0 +1,52 @@
+local mock = require "deftest.mock.mock"
+
+
+local M = {}
+
+
+local recipients = {}
+
+local history = {}
+
+local function get_recipient(url)
+	recipients[url] = recipients[url] or {}
+	return recipients[url]
+end
+
+local function post(url, message_id, message)
+	local data = { url = url, message_id = message_id, message = message }
+	history[#history + 1] = data
+	local recipient = get_recipient(url)
+	recipient[#recipient + 1] = data
+	msg.post.original(url, message_id, message or {})
+end
+
+function M.mock()
+	recipients = {}
+	history = {}
+	mock.mock(msg)
+	msg.post.replace(post)
+end
+
+function M.unmock()
+	mock.unmock(msg)
+end
+
+
+
+function M.messages(url)
+	return url and get_recipient(url) or history
+end
+
+function M.first(url)
+	local messages = url and get_recipient(url) or history
+	return messages[1]
+end
+
+function M.last(url)
+	local messages = url and get_recipient(url) or history
+	return messages[#messages]
+end
+
+
+return M

test/test.script

@@ -5,5 +5,8 @@ local test_monarch = require "test.test_monarch"
 
 function init(self)
 	deftest.add(test_monarch)
-	deftest.run()
+	deftest.run({ 
+		coverage = { enabled = true },
+		--pattern = "preload",
+	})
 end

test/test_monarch.lua

@@ -1,22 +1,28 @@
 local cowait = require "test.cowait"
+local mock_msg = require "test.msg"
+local unload = require "deftest.util.unload"
 local monarch = require "monarch.monarch"
 
-local SCREEN1 = hash("screen1")
+local SCREEN1_STR = hash("screen1")
+local SCREEN1 = hash(SCREEN1_STR)
 local SCREEN2 = hash("screen2")
+local SCREEN_PRELOAD = hash("screen_preload")
+local BACKGROUND = hash("background")
 local POPUP1 = hash("popup1")
 local POPUP2 = hash("popup2")
 local FOOBAR = hash("foobar")
+local TRANSITION1 = hash("transition1")
 
 return function()
 
 	local screens_instances = {}
 
 	local function is_shown(screen_id)
-		return monarch.is_top(screen_id)
+		return monarch.is_visible(screen_id)
 	end
 
 	local function is_hidden(screen_id)
-		return not monarch.is_top(screen_id)
+		return not monarch.is_visible(screen_id)
 	end
 
 	local function wait_timeout(fn, ...)
@@ -28,12 +34,26 @@ return function()
 		return fn(...)
 	end
 
+	local function wait_until_done(fn)
+		local is_done = false
+		local function done()
+			is_done = true
+		end
+		fn(done)
+		wait_timeout(function() return is_done end)
+	end
+	local function wait_until_visible(screen_id)
+		return wait_timeout(is_visible, screen_id)
+	end
 	local function wait_until_shown(screen_id)
 		return wait_timeout(is_shown, screen_id)
 	end
 	local function wait_until_hidden(screen_id)
 		return wait_timeout(is_hidden, screen_id)
 	end
+	local function wait_until_not_busy()
+		return wait_timeout(function() return not monarch.is_busy() end)
+	end
 
 	local function assert_stack(expected_screens)
 		local actual_screens = monarch.get_stack()
@@ -50,12 +70,19 @@ return function()
 	
 	describe("monarch", function()
 		before(function()
+			mock_msg.mock()
 			monarch = require "monarch.monarch"
 			screens_instances = collectionfactory.create("#screensfactory")
+			monarch.debug()
 		end)
 
 		after(function()
-			package.loaded["monarch.monarch"] = nil
+			while #monarch.get_stack() > 0 do
+				monarch.back()
+				wait_until_not_busy()
+			end
+			mock_msg.unmock()
+			unload.unload("monarch%..*")
 			for id,instance_id in pairs(screens_instances) do
 				go.delete(instance_id)
 			end
@@ -65,12 +92,13 @@ return function()
 
 		it("should be able to tell if a screen exists", function()
 			assert(monarch.screen_exists(SCREEN1))
+			assert(monarch.screen_exists(SCREEN1_STR))
 			assert(not monarch.screen_exists(hash("foobar")))
 		end)
 
 
 		it("should be able to show screens and go back to previous screens", function()
-			monarch.show(SCREEN1)
+			monarch.show(SCREEN1_STR)
 			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
 			assert_stack({ SCREEN1 })
 
@@ -89,6 +117,64 @@ return function()
 			assert_stack({ })
 		end)
 
+		it("should be able to tell if a screen is visible or not", function()
+			assert(not monarch.is_visible(SCREEN1))
+			monarch.show(SCREEN1)
+			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
+			assert_stack({ SCREEN1 })
+			assert(monarch.is_visible(SCREEN1))
+			
+			monarch.show(SCREEN2)
+			assert(wait_until_hidden(SCREEN1), "Screen1 was never hidden")
+			assert(wait_until_shown(SCREEN2), "Screen2 was never shown")
+			assert_stack({ SCREEN1, SCREEN2 })
+			assert(not monarch.is_visible(SCREEN1))
+			assert(monarch.is_visible(SCREEN2))
+			
+			monarch.show(POPUP1)
+			assert(wait_until_shown(POPUP1), "Popup1 was never shown")
+			assert_stack({ SCREEN1, SCREEN2, POPUP1 })
+			assert(not monarch.is_visible(SCREEN1))
+			assert(monarch.is_visible(SCREEN2))
+			assert(monarch.is_visible(POPUP1))
+		end)
+
+		it("should be able to show a screen without adding it to the stack", function()
+			monarch.show(BACKGROUND, { no_stack = true })
+			assert(wait_until_shown(BACKGROUND), "Background was never shown")
+			assert_stack({ })
+
+			monarch.show(SCREEN1)
+			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
+			assert_stack({ SCREEN1 })
+		end)
+
+		it("should be able to hide a screen not added to the stack", function()
+			monarch.show(BACKGROUND, { no_stack = true })
+			assert(wait_until_shown(BACKGROUND), "Background was never shown")
+			assert_stack({ })
+
+			monarch.hide(BACKGROUND)
+			assert(wait_until_hidden(BACKGROUND), "Background was never hidden")
+			assert_stack({ })
+		end)
+
+		it("should be able to hide the top screen", function()
+			monarch.show(SCREEN1)
+			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
+			assert_stack({ SCREEN1 })
+
+			monarch.show(SCREEN2)
+			assert(wait_until_hidden(SCREEN1), "Screen1 was never hidden")
+			assert(wait_until_shown(SCREEN2), "Screen2 was never shown")
+			assert_stack({ SCREEN1, SCREEN2 })
+
+			assert(monarch.hide(SCREEN1) == false)
+			assert(monarch.hide(SCREEN2) == true)
+			assert(wait_until_hidden(SCREEN2), "Screen2 was never hidden")
+			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
+			assert_stack({ SCREEN1 })
+		end)
 
 		it("should be able to pass data to a screen when showning it or going back to it", function()
 			local data1 = { foo = "bar" }
@@ -133,7 +219,7 @@ return function()
 		end)
 		
 
-		it("should be able to show one popup on top of another the Popup On Popup flag is set", function()
+		it("should be able to show one popup on top of another if the Popup On Popup flag is set", function()
 			monarch.show(SCREEN1)
 			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
 			assert_stack({ SCREEN1 })
@@ -146,6 +232,23 @@ return function()
 		end)
 
 		
+		it("should prevent further operations while hiding/showing a screen", function()
+			assert(monarch.show(SCREEN1) == true)
+			assert(monarch.show(SCREEN2) == false)
+			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
+			assert_stack({ SCREEN1 })
+
+			assert(monarch.show(SCREEN2) == true)
+			assert(wait_until_shown(SCREEN2), "Screen2 was never shown")
+			assert_stack({ SCREEN1, SCREEN2 })
+
+			assert(monarch.back() == true)
+			assert(monarch.back() == false)
+			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
+			assert_stack({ SCREEN1 })
+		end)
+		
+		
 		it("should close any open popups when showing a popup without the Popup On Popup flag", function()
 			monarch.show(SCREEN1)
 			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
@@ -174,5 +277,133 @@ return function()
 			assert_stack({ SCREEN1, SCREEN2 })
 		end)
 
+
+		it("should be able to get the id of the screen at the top and bottom of the stack", function()
+			assert(monarch.top() == nil)
+			assert(monarch.bottom() == nil)
+			assert(monarch.top(1) == nil)
+			assert(monarch.bottom(-1) == nil)
+						
+			monarch.show(SCREEN1)
+			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
+			assert(monarch.top() == SCREEN1)
+			assert(monarch.top(0) == SCREEN1)
+			assert(monarch.top(1) == nil)
+			assert(monarch.bottom() == SCREEN1)
+			assert(monarch.bottom(0) == SCREEN1)
+			assert(monarch.bottom(-1) == nil)
+									
+			monarch.show(SCREEN2)
+			assert(wait_until_hidden(SCREEN1), "Screen1 was never hidden")
+			assert(wait_until_shown(SCREEN2), "Screen2 was never shown")
+			assert_stack({ SCREEN1, SCREEN2 })
+			assert(monarch.top(0) == SCREEN2)
+			assert(monarch.top(-1) == SCREEN1)
+			assert(monarch.bottom(0) == SCREEN1)
+			assert(monarch.bottom(1) == SCREEN2)
+		end)
+
+		it("should be busy while transition is running", function()
+			monarch.show(TRANSITION1)
+			assert(wait_until_shown(TRANSITION1), "Transition1 was never shown")
+			assert(monarch.is_busy())
+			assert(wait_until_not_busy())
+		end)
+
+		it("should be able to preload a screen and wait for it", function()
+			assert(not monarch.is_preloading(TRANSITION1))
+			monarch.preload(TRANSITION1)
+			assert(monarch.is_preloading(TRANSITION1))
+			wait_until_done(function(done)
+				monarch.when_preloaded(TRANSITION1, done)
+			end)
+			assert(not monarch.is_preloading(TRANSITION1))
+		end)
+		
+		it("should ignore any preload calls while busy", function()
+			monarch.show(TRANSITION1)
+			-- previously a call to preload() while also showing a screen would
+			-- lock up monarch. See issue #32
+			monarch.preload(TRANSITION1)
+			assert(wait_until_shown(TRANSITION1), "Transition1 was never shown")
+		end)
+		
+		it("should be able to notify listeners of navigation events", function()
+			local URL1 = msg.url(screens_instances[hash("/listener1")])
+			local URL2 = msg.url(screens_instances[hash("/listener2")])
+			monarch.add_listener(URL1)
+			monarch.add_listener(URL2)
+
+			monarch.show(SCREEN1)
+			assert(mock_msg.messages(URL1)[1].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
+			assert(mock_msg.messages(URL1)[1].message.screen == SCREEN1)
+			assert(mock_msg.messages(URL2)[1].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
+			assert(mock_msg.messages(URL2)[1].message.screen == SCREEN1)
+			assert(wait_until_not_busy())
+			assert(mock_msg.messages(URL1)[2].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
+			assert(mock_msg.messages(URL1)[2].message.screen == SCREEN1)
+			assert(mock_msg.messages(URL2)[2].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
+			assert(mock_msg.messages(URL2)[2].message.screen == SCREEN1)
+												
+			monarch.remove_listener(URL2)
+			monarch.show(SCREEN2)
+			assert(wait_until_not_busy())
+
+			assert(#mock_msg.messages(URL1) == 6)
+			assert(#mock_msg.messages(URL2) == 2)
+			assert(mock_msg.messages(URL1)[3].message_id == monarch.SCREEN_TRANSITION_OUT_STARTED)
+			assert(mock_msg.messages(URL1)[3].message.screen == SCREEN1)
+			assert(mock_msg.messages(URL1)[4].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
+			assert(mock_msg.messages(URL1)[4].message.screen == SCREEN2)
+			assert(mock_msg.messages(URL1)[5].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
+			assert(mock_msg.messages(URL1)[5].message.screen == SCREEN2)
+			assert(mock_msg.messages(URL1)[6].message_id == monarch.SCREEN_TRANSITION_OUT_FINISHED)
+			assert(mock_msg.messages(URL1)[6].message.screen == SCREEN1)
+						
+			monarch.back()
+			assert(wait_until_not_busy())
+						
+			assert(#mock_msg.messages(URL1) == 10)
+			assert(#mock_msg.messages(URL2) == 2)
+			assert(mock_msg.messages(URL1)[7].message_id == monarch.SCREEN_TRANSITION_OUT_STARTED)
+			assert(mock_msg.messages(URL1)[7].message.screen == SCREEN2)
+			assert(mock_msg.messages(URL1)[8].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
+			assert(mock_msg.messages(URL1)[8].message.screen == SCREEN1)
+			assert(mock_msg.messages(URL1)[9].message_id == monarch.SCREEN_TRANSITION_OUT_FINISHED)
+			assert(mock_msg.messages(URL1)[9].message.screen == SCREEN2)
+			assert(mock_msg.messages(URL1)[10].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
+			assert(mock_msg.messages(URL1)[10].message.screen == SCREEN1)
+		end)
+
+		it("should be able to show a screen even while it is preloading", function()
+			assert(monarch.is_preloading(SCREEN_PRELOAD))
+			monarch.show(SCREEN_PRELOAD, nil, { count = 1 })
+			assert(wait_until_shown(SCREEN_PRELOAD), "Screen_preload was never shown")
+		end)
+		
+		it("should be able to preload a screen and always keep it loaded", function()
+			monarch.show(SCREEN_PRELOAD, nil, { count = 1 })
+			assert(wait_until_shown(SCREEN_PRELOAD), "Screen_preload was never shown")
+			-- first time the screen gets loaded it will increment the count
+			assert(monarch.data(SCREEN_PRELOAD).count == 2)
+
+			monarch.show(SCREEN_PRELOAD, { clear = true }, { count = 1 })
+			assert(wait_until_shown(SCREEN_PRELOAD), "Screen_preload was never shown")
+			-- second time the screen gets shown it will already be loaded and not increment the count
+			assert(monarch.data(SCREEN_PRELOAD).count == 1)
+		end)
+
+
+		it("should be able to reload a preloaded screen", function()
+			monarch.show(SCREEN_PRELOAD, nil, { count = 1 })
+			assert(wait_until_shown(SCREEN_PRELOAD), "Screen_preload was never shown")
+			-- first time the screen gets loaded it will increment the count
+			assert(monarch.data(SCREEN_PRELOAD).count == 2)
+
+			monarch.show(SCREEN_PRELOAD, { clear = true, reload = true }, { count = 1 })
+			assert(wait_until_shown(SCREEN_PRELOAD), "Screen_preload was never shown")
+			-- second time the screen gets shown it will be reloaded and increment the count
+			assert(monarch.data(SCREEN_PRELOAD).count == 2)
+		end)
 	end)
 end