Implement better behaviour for replace() on popups (#64)

Fixes #56

.github/workflows/ci-workflow.yml

@@ -0,0 +1,19 @@
+name: CI
+
+on: [push]
+
+jobs:
+    build_and_run:
+        name: Build and run
+        runs-on: ubuntu-latest
+        steps:
+          - uses: actions/checkout@v1
+          - uses: actions/setup-java@v1
+            with:
+                java-version: '11'
+          - name: Run.sh
+            env:
+                DEFOLD_USER: bjorn.ritzl@gmail.com
+                DEFOLD_AUTH: foobar
+                DEFOLD_BOOSTRAP_COLLECTION: /test/test.collectionc
+            run: ./.travis/run.sh

.travis.yml

@@ -1,5 +1,7 @@
 sudo: required
 
+dist: bionic
+
 script:
   - sudo unlink /usr/bin/gcc && sudo ln -s /usr/bin/gcc-5 /usr/bin/gcc
   - gcc --version
@@ -15,14 +17,10 @@ addons:
 language: java
 
 jdk:
-  - oraclejdk8
-
-dist: trusty
+  - oraclejdk11
 
 env:
   global:
-    - DEFOLD_AUTH=foobar
-    - DEFOLD_USER=bjorn.ritzl@gmail.com
     - DEFOLD_BOOSTRAP_COLLECTION=/test/test.collectionc
 
 script:

.travis/run.sh

@@ -26,11 +26,9 @@ chmod +x dmengine_headless
 echo "Downloading ${BOB_URL}"
 curl -o bob.jar ${BOB_URL}
 
-# Fetch libraries if DEFOLD_AUTH and DEFOLD_USER are set
-if [ -n "${DEFOLD_AUTH}" ] && [ -n "${DEFOLD_USER}" ]; then
-	echo "Running bob.jar - resolving dependencies"
-	java -jar bob.jar --auth "${DEFOLD_AUTH}" --email "${DEFOLD_USER}" resolve
-fi
+# Fetch libraries
+echo "Running bob.jar - resolving dependencies"
+java -jar bob.jar --auth "foobar" --email "john@doe.com" resolve
 
 echo "Running bob.jar - building"
 java -jar bob.jar --debug build --keep-unused

README.md

@@ -1,6 +1,6 @@
 ![](docs/logo.jpg)
 
-[![Build Status](https://travis-ci.org/britzl/monarch.svg?branch=master)](https://travis-ci.org/britzl/monarch)
+[![Build Status](https://travis-ci.com/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)
 
@@ -19,6 +19,10 @@ Or point to the ZIP file of a [specific release](https://github.com/britzl/monar
 # 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.
 
+## Editor Script
+Right click in on a`.gui` file in the outline and selected the menu item, it creates a `.collection` and a `.gui_script` with the same name as the `.gui` file. It adds the file with some basic setup done to them, adding the selected gui script to the created gui scene and in turns adds the gui scene to the newly created collection.
+
+<img src="/docs/editor_script.gif" width="200px">
 
 ## Creating screens
 Monarch screens are created in individual collections and either loaded through collection proxies or created through collection factories.
@@ -73,12 +77,12 @@ The navigation in Monarch is based around a stack of screens. When a screen is s
 ### Showing a new screen
 You show a screen in one of two ways:
 
-1. Post a ```show``` message to the ```screen.script```
+1. Post a ```show``` message to the screen script (either `screen_proxy.script` or `screen_factory.script`)
 2. Call ```monarch.show()``` (see below)
 
 Showing a screen will push it to the top of the stack and trigger an optional transition. The previous screen will be hidden (with an optional transition) unless the screen to be shown is a [popup](#popups).
 
-NOTE: You must ensure that the ```init()``` function of the ```screen.script``` has run. The ```init()``` function is responsible for registering the screen and it's not possible to show it until this has happened. A good practice is to delay the first call by posting a message to a controller script or similar before calling ```monarch.show()``` the first time:
+NOTE: You must ensure that the ```init()``` function of the screen script (either `screen_proxy.script` or `screen_factory.script`) has run. The ```init()``` function is responsible for registering the screen and it's not possible to show it until this has happened. A good practice is to delay the first call by posting a message to a controller script or similar before calling ```monarch.show()``` the first time:
 
 	function init(self)
 		msg.post("#", "show_first_screen")
@@ -113,7 +117,7 @@ Monarch can also show a screen without adding it to the stack. This can be used
 ### Going back to a previous screen
 You navigate back in the screen hierarchy in one of two ways:
 
-1. Post a ```back``` message to the ```screen.script```
+1. Post a ```back``` message to the screen script (either `screen_proxy.script` or `screen_factory.script`)
 2. Call ```monarch.back()``` (see below)
 
 
@@ -188,6 +192,15 @@ Monarch comes with a system for setting up transitions easily in a gui_script us
 		end
 	end
 
+It is also possible to assign transitions to multiple nodes:
+
+	function init(self)
+		self.transition = transitions.create() -- note that no node is passed to transition.create()!
+			.show_in(gui.get_node("node1"), transitions.slide_in_right, gui.EASING_OUTQUAD, 0.6, 0)
+			.show_in(gui.get_node("node2"), transitions.slide_in_right, gui.EASING_OUTQUAD, 0.6, 0)
+	end
+
+
 The predefined transitions provided by ```monarch.transitions.gui``` are:
 
 * ```slide_in_right```
@@ -292,7 +305,7 @@ Both the ```monarch.show()``` and ```monarch.back()``` functions take an optiona
 ## Monarch API
 
 ### monarch.show(screen_id, [options], [data], [callback])
-Show a Monarch screen. Note that the screen must be registered before it can be shown. The ```init()``` function of the ```screen.script``` takes care of registration.
+Show a Monarch screen. Note that the screen must be registered before it can be shown. The ```init()``` function of the screen script (either `screen_proxy.script` or `screen_factory.script`) takes care of registration. This operation will be added to the queue if Monarch is busy.
 
 **PARAMETERS**
 * ```screen_id``` (string|hash) - Id of the screen to show.
@@ -305,13 +318,15 @@ 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).
 * ```no_stack``` (boolean) - If the `no_stack` flag is set Monarch will load the screen without adding it to the screen stack.
+* ```sequential``` (boolean) - If the `sequential` flag is set Monarch will start loading the screen only after the previous screen finished transitioning out.
+* ```pop``` (number) - If `pop` is set to a number, Monarch will pop that number of screens from the stack before adding the new one.
 
-**RETURN**
-* ```success``` (boolean) - True if the process of showing the screen was started successfully. False if already busy showing/hiding a screen.
+### monarch.replace(screen_id, [options], [data], [callback])
+Replace the top of the stack with a new screen. Equivalent to calling `monarch.show()` with `pop = 1`. It takes the same parameters as `monarch.show()`.
 
 
 ### 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.
+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. This operation will be added to the queue if Monarch is busy.
 
 **PARAMETERS**
 * ```screen_id``` (string|hash) - Id of the screen to hide.
@@ -322,18 +337,15 @@ Hide a screen that has been shown using the `no_stack` option. If used on a scre
 
 
 ### monarch.back([data], [callback])
-Go back to a previous Monarch screen
+Go back to a previous Monarch screen. This operation will be added to the queue if Monarch is busy.
 
 **PARAMETERS**
 * ```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.
+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. This operation will be added to the queue if Monarch is busy.
 
 **PARAMETERS**
 * ```screen_id``` (string|hash) - Id of the screen to preload.
@@ -359,7 +371,7 @@ Invoke a callback when a 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.
+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. This operation will be added to the queue if Monarch is busy.
 
 **PARAMETERS**
 * ```screen_id``` (string|hash) - Id of the screen to unload.

example/confirm.gui_script

@@ -18,9 +18,13 @@ function on_input(self, action_id, action)
 	if action_id == hash("touch") and action.released then
 		if gui.pick_node(self.yes, action.x, action.y) then
 			print("yes")
-			monarch.show(monarch.data("confirm").next, nil, nil, function()
-				print("next screen show done")
-			end)
+			if monarch.data("confirm").next then
+				monarch.show(monarch.data("confirm").next, nil, nil, function()
+					print("next screen show done")
+				end)
+			else
+				print("no next screen in data")
+			end
 		elseif gui.pick_node(self.no, action.x, action.y) then
 			print("no")
 			monarch.back(function()

example/main.script

@@ -8,8 +8,7 @@ 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)
+		monarch.show(hash("background"), { no_stack = true })
+		monarch.show(hash("menu"))
 	end
 end

example/menu.gui_script

@@ -19,7 +19,7 @@ function on_input(self, action_id, action)
 			end)
 		elseif gui.pick_node(gui.get_node("about_button"), action.x, action.y) then
 			monarch.show(hash("about"), nil, nil, function()
-			print("showing about done")
+				print("showing about done")
 			end)
 		elseif gui.pick_node(gui.get_node("back_button"), action.x, action.y) then
 			monarch.back()

monarch/editor-script/make_monarch.editor_script

@@ -0,0 +1,161 @@
+local M = {}
+
+local collection_template
+local gui_script_content
+local gui_file_content
+
+local function ends_with(str, ending)
+    return ending == "" or str:sub(-#ending) == ending
+end
+
+local function file_exists(name)
+    local f=io.open(name,"r")
+    if f~=nil then io.close(f) return true else return false end
+end
+
+local function get_filename(path)   
+    local main, filename, extension = path:match("(.-)([^\\/]-%.?([^%.\\/]*))$")
+    return main, filename
+end
+
+local function create_files(file_path)
+    -- Construct paths
+    local path = editor.get(file_path, "path")
+    local main, filename = get_filename(path)
+    local basename = filename:match("(.+)%..+")
+    local target_collection_path = "." .. main .. basename .. ".collection"
+    local target_gui_script_path = "." .. main .. basename .. ".gui_script"
+    local target_gui_path = "." .. main .. basename .. ".gui"
+
+    -- Create the files if they don't exists
+    if not file_exists(target_collection_path) then
+        local collection_content = collection_template(path, basename)
+        local collection = io.open(target_collection_path, "w")
+        collection:write(collection_content)
+        collection:close()
+    end
+    if not file_exists(target_gui_script_path) then
+        local gui_script = io.open(target_gui_script_path, "w")
+        gui_script:write(gui_script_content)
+        gui_script:close()
+
+        -- Put the gui_script path into the gui file
+        local gui_file = io.open("." .. path, "rb")
+        local gui_text = gui_file:read("*a")
+        gui_file:close()
+
+        gui_text = string.gsub(gui_text, 'script: "%.*"', [[script: "]] .. main .. basename .. ".gui_script" .. [["]])
+
+        gui_file = io.open("." .. path, "w")
+        gui_file:write(gui_text)
+        gui_file:close()
+    end
+    if not file_exists(target_gui_path) then
+        local gui_content = gui_template(path)
+        local gui = io.open(target_gui_path, "w")
+        gui:write(gui_content)
+        gui:close()
+    end
+end
+
+function M.get_commands()
+    return {
+        {
+            label="Create Monarch Scene From...",
+            locations = {"Assets"},
+            query = {
+                selection = {type = "resource", cardinality = "one"}
+            },
+            active = function(opts)
+                local path = editor.get(opts.selection, "path")
+                return ends_with(path, ".gui") or ends_with(path, ".collection") or ends_with(path, ".gui_script")
+            end,
+            run = function(opts)
+                create_files(opts.selection)
+            end
+        }
+    }
+end
+
+gui_template = function(gui_script)
+    return [[script: "]].. gui_script .. [["
+background_color {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 0.0
+}
+material: "/builtins/materials/gui.material"
+adjust_reference: ADJUST_REFERENCE_PARENT
+max_nodes: 512
+]] 
+end
+
+gui_script_content = [[local monarch = require "monarch.monarch"
+
+function init(self)
+    msg.post(".", "acquire_input_focus")
+end
+
+function final(self)
+end
+
+function update(self, dt)
+end
+
+function on_message(self, message_id, message, sender)
+end
+
+function on_input(self, action_id, action)
+end
+
+function on_reload(self)
+end
+]]
+
+
+collection_template = function(gui_script, name)
+    return [[name: "]].. name .. [["
+scale_along_z: 0
+embedded_instances {
+  id: "go"
+  data: "components {\n"
+  "  id: \"monarch\"\n"
+  "  component: \"]].. gui_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"
+  "}\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
+  }
+}
+]]
+
+end
+
+
+
+return M

monarch/monarch.lua

@@ -31,6 +31,7 @@ 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")
+M.SCREEN_TRANSITION_FAILED = hash("monarch_screen_transition_failed")
 
 
 -- all registered screens
@@ -68,6 +69,16 @@ local function pcallfn(fn, ...)
 	end
 end
 
+local function assign(to, from)
+	if not from then
+		return to
+	end
+	for k, v in pairs(from) do
+		to[k] = v
+	end
+	return to
+end
+
 local function cowait(delay)
 	local co = coroutine.running()
 	assert(co, "You must run this from within a coroutine")
@@ -77,6 +88,43 @@ local function cowait(delay)
 	coroutine.yield()
 end
 
+
+
+local queue = {}
+
+local function queue_error(message)
+	print(message)
+	log("queue() error - clearing queue")
+	while next(queue) do
+		table.remove(queue)
+	end
+end
+
+local process_queue
+process_queue = function()
+	if M.is_busy() then
+		log("queue() busy")
+		return
+	end
+	action = table.remove(queue, 1)
+	if not action then
+		log("queue() empty")
+		return
+	end
+	log("queue() next action", action)
+	local ok, err = pcall(action, process_queue, queue_error)
+	if not ok then
+		queue_error(err)
+	end
+end
+
+local function queue_action(action)
+	log("queue() adding", action)
+	table.insert(queue, action)
+	process_queue()
+end
+
+
 local function notify_transition_listeners(message_id, message)
 	log("notify_transition_listeners()", message_id)
 	for _,url in pairs(transition_listeners) do
@@ -234,6 +282,8 @@ 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)))
+	log("unregister()", id)
+	local screen = screens[id]
 	screens[id] = nil
 end
 
@@ -282,9 +332,8 @@ local function change_context(screen)
 end
 
 local function unload(screen, force)
-	log("unload()", screen.id)
-
 	if screen.proxy then
+		log("unload() proxy", screen.id)
 		if screen.auto_preload and not force then
 			msg.post(screen.proxy, DISABLE)
 			screen.loaded = false
@@ -298,6 +347,7 @@ local function unload(screen, force)
 			screen.wait_for = nil
 		end
 	elseif screen.factory then
+		log("unload() factory", screen.id)
 		for id, instance in pairs(screen.factory_ids) do
 			go.delete(instance)
 		end
@@ -311,6 +361,11 @@ local function unload(screen, force)
 			screen.preloaded = false
 		end
 	end
+	-- we need to wait here in case the unloaded screen contained any screens
+	-- if this is the case we need to let these sub-screens have their final()
+	-- functions called so that they have time to call unregister()
+	cowait(0)
+	cowait(0)
 end
 
 
@@ -320,14 +375,24 @@ local function preload(screen)
 
 	if screen.preloaded then
 		log("preload() screen already preloaded", screen.id)
-		return
+		return true
 	end
 
+	screen.preloading = true
 	if screen.proxy then
+		log("preload() proxy")
+		local missing_resources = collectionproxy.missing_resources(screen.proxy)
+		if #missing_resources > 0 then
+			local error_message = ("preload() collection proxy %s is missing resources"):format(tostring(screen.id))
+			log(error_message)
+			screen.preloading = false
+			return false, error_message
+		end
 		screen.wait_for = PROXY_LOADED
 		msg.post(screen.proxy, ASYNC_LOAD)
 		coroutine.yield()
 	elseif screen.factory then
+		log("preload() factory")
 		if collectionfactory.get_status(screen.factory) == collectionfactory.STATUS_UNLOADED then
 			collectionfactory.load(screen.factory, function(self, url, result)
 				assert(coroutine.resume(screen.co))
@@ -336,11 +401,16 @@ local function preload(screen)
 		end
 
 		if collectionfactory.get_status(screen.factory) ~= collectionfactory.STATUS_LOADED then
-			log("preload() error loading factory resources")
-			return
+			local error_message = ("preload() error while loading factory resources for screen %s"):format(tostring(screen.id))
+			log(error_message)
+			screen.preloading = false
+			return false, error_message
 		end
 	end
+	log("preload() preloading done", screen.id)
 	screen.preloaded = true
+	screen.preloading = false
+	return true
 end
 
 local function load(screen)
@@ -349,14 +419,13 @@ local function load(screen)
 
 	if screen.loaded then
 		log("load() screen already loaded", screen.id)
-		return
+		return true
 	end
 
-	preload(screen)
-
-	if not screen.preloaded then
+	local ok, err = preload(screen)
+	if not ok then
 		log("load() screen wasn't preloaded", screen.id)
-		return
+		return false, err
 	end
 
 	if screen.proxy then
@@ -368,6 +437,7 @@ local function load(screen)
 	end
 	screen.loaded = true
 	screen.preloaded = false
+	return true
 end
 
 local function transition(screen, message_id, message)
@@ -419,20 +489,22 @@ local function reset_timestep(screen)
 	end
 end
 
-local function run_coroutine(screen, cb, fn)
+local function run_coroutine(screen, done_cb, fn)
 	local co
 	co = coroutine.create(function()
 		screen.co = co
+		-- don't pcall the function!
+		-- it may contain a call to for instance change_context()
+		-- this will result in a yield across metamethod/C call boundary
 		fn()
 		screen.co = nil
-		pcallfn(cb)
+		pcallfn(done_cb)
 	end)
 	assert(coroutine.resume(co))
 end
 
 local function disable(screen, next_screen)
 	log("disable()", screen.id)
-	local next_is_popup = next_screen and next_screen.popup
 	run_coroutine(screen, nil, function()
 		change_context(screen)
 		release_input(screen, next_screen)
@@ -488,13 +560,14 @@ local function show_in(screen, previous_screen, reload, add_to_stack, cb)
 		if reload and screen.loaded then
 			log("show_in() reloading", screen.id)
 			unload(screen, reload)
-			-- we need to wait here in case the unloaded screen contained any screens
-			-- if this is the case we need to let these sub-screens have their final()
-			-- functions called so that they have time to call unregister()
-			cowait(0)
-			cowait(0)
 		end
-		load(screen)
+		local ok, err = load(screen)
+		if not ok then
+			log("show_in()", err)
+			active_transition_count = active_transition_count - 1
+			notify_transition_listeners(M.SCREEN_TRANSITION_FAILED, { screen = screen.id })
+			return
+		end
 		if add_to_stack then
 			stack[#stack + 1] = screen
 		end
@@ -513,7 +586,13 @@ local function back_in(screen, previous_screen, cb)
 		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)
-		load(screen)
+		local ok, err = load(screen)
+		if not ok then
+			log("back_in()", err)
+			active_transition_count = active_transition_count - 1
+			notify_transition_listeners(M.SCREEN_TRANSITION_FAILED, { screen = screen.id })
+			return
+		end
 		reset_timestep(screen)
 		if previous_screen and not previous_screen.popup then
 			transition(screen, M.TRANSITION.BACK_IN, { previous_screen = previous_screen.id })
@@ -578,85 +657,126 @@ end
 -- 		* 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.
+-- 		* sequential - Set to true to wait for the previous screen to show itself out before starting the
+--				   show in transition even when transitioning to a different scene ID.
+-- 		* no_stack - Set to true to load the screen without adding it to the screen stack.
+-- 		* pop - The number of screens to pop from the stack before adding the new one.
 -- @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]
-	screen.data = data
+	log("show() queuing action", id)
+	queue_action(function(action_done, action_error)
+		log("show()", id)
+		local screen = screens[id]
+		if not screen then
+			action_error(("show() there is no longer a screen with id %s"):format(tostring(id)))
+			return
+		end
+		screen.data = data
 
-	log("show()", screen.id)
+		local co
+		co = coroutine.create(function()
+
+			local callbacks = callback_tracker()
+
+			local top = stack[#stack]
+			-- 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 and top then
+				-- manipulate the current top
+				-- close popup(s) if needed
+				-- transition out
+				local pop = options and options.pop or 0
+				local is_not_popup = not screen.popup
+				local pop_all_popups = is_not_popup -- pop all popups when transitioning screens
 
-	local co
-	co = coroutine.create(function()
-		local top = stack[#stack]
-		-- 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(s) if needed
-			-- transition out
-			if top then
 				-- keep top popup visible if new screen can be shown on top of a popup
-				if top.popup and screen.popup_on_popup then
+				if top.popup and screen.popup and screen.popup_on_popup then
 					disable(top, screen)
 				else
-					-- close all popups, one by one
-					while top.popup do
-						stack[#stack] = nil
-						show_out(top, screen, function()
-							assert(coroutine.resume(co))
-						end)
-						coroutine.yield()
-						top = stack[#stack]
+					pop_all_popups = true
+				end
+
+				-- close popups, one by one, either all of them or the number specified by options.pop
+				while top and top.popup do
+					if not pop_all_popups then
+						if pop <= 0 then break end
+						pop = pop - 1
 					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, callbacks.track())
+					stack[#stack] = nil
+					show_out(top, screen, callbacks.track())
+					callbacks.yield_until_done()
+					top = stack[#stack]
+				end
+
+				-- unload the previous screen and transition out from top
+				-- wait until we are done if showing the same screen as is already visible
+				if top and not top.popup then
+					local same_screen = top and top.id == screen.id
+					show_out(top, screen, callbacks.track())
+					if same_screen or (options and options.sequential) then
+						callbacks.yield_until_done()
+					end
+				end
+
+				-- if the screen we want to show is in the stack
+				-- already and the clear flag is set then we need
+				-- to remove every screen on the stack up until and
+				-- including the screen itself
+				if options and options.clear then
+					log("show() clearing")
+					while M.in_stack(id) do
+						table.remove(stack)
+					end
+				end
+
+				-- pop screens off the stack
+				if is_not_popup then
+					for i = 1, pop do
+						local stack_top = #stack
+						if stack_top < 1 then break end
+						stack[stack_top] = nil
 					end
 				end
 			end
-		end
 
-		-- if the screen we want to show is in the stack
-		-- already and the clear flag is set then we need
-		-- to remove every screen on the stack up until and
-		-- including the screen itself
-		if options and options.clear then
-			log("show() clearing")
-			while M.in_stack(id) do
-				table.remove(stack)
+			-- 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()
+					assert(coroutine.resume(co))
+				end)
+				coroutine.yield()
 			end
-		end
+			show_in(screen, top, options and options.reload, add_to_stack, callbacks.track())
 
-		-- 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()
-				assert(coroutine.resume(co))
+			callbacks.when_done(function()
+				pcallfn(cb)
+				pcallfn(action_done)
 			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)
+		assert(coroutine.resume(co))
 	end)
-	assert(coroutine.resume(co))
+	return true -- return true for legacy reasons (before queue existed)
+end
 
-	return true
+
+--- Replace the top of the stack with a new screen
+-- @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.
+-- 		* no_stack - Set to true to load the screen without adding it to the screen stack.
+-- @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
+function M.replace(id, options, data, cb)
+	return M.show(id, assign({ pop = 1 }, options), data, cb)
 end
 
 
@@ -664,18 +784,12 @@ end
 -- 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
+-- @return true if successfully hiding, false if busy or for some other reason unable to hide the screen
 function M.hide(id, cb)
-	if M.is_busy() then
-		log("hide() 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("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)
@@ -683,55 +797,67 @@ function M.hide(id, cb)
 		end
 		return M.back(id, cb)
 	else
-		if M.is_visible(id) then
-			back_out(screen, nil, cb)
-		else
-			pcallfn(cb)
-		end
+		log("hide() queuing action", id)
+		queue_action(function(action_done, action_error)
+			log("hide()", id)
+			local callbacks = callback_tracker()
+			if M.is_visible(id) then
+				local screen = screens[id]
+				if not screen then
+					action_error(("hide() there is no longer a screen with id %s"):format(tostring(id)))
+					return
+				end
+				back_out(screen, nil, callbacks.track())
+			end
+			callbacks.when_done(function()
+				pcallfn(cb)
+				pcallfn(action_done)
+			end)
+		end)
 	end
 	return true
 end
 
 
--- Go back to the previous screen in the stack
+-- Go back to the previous screen in the stack.
 -- @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
+	log("back() queuing action")
 
-	local callbacks = callback_tracker()
-
-	local screen = table.remove(stack)
-	if screen then
-		log("back()", screen.id)
-		local top = stack[#stack]
-		-- if we go back to the same screen we need to first hide it
-		-- and wait until it is hidden before we show it again
-		if top and screen.id == top.id then
-			back_out(screen, top, function()
-				if data then
-					top.data = data
+	queue_action(function(action_done)
+		local callbacks = callback_tracker()
+		local screen = table.remove(stack)
+		if screen then
+			log("back()", screen.id)
+			local top = stack[#stack]
+			-- if we go back to the same screen we need to first hide it
+			-- and wait until it is hidden before we show it again
+			if top and screen.id == top.id then
+				back_out(screen, top, function()
+					if data then
+						top.data = data
+					end
+					back_in(top, screen, callbacks.track())
+				end)
+			else
+				back_out(screen, top, callbacks.track())
+				if top then
+					if data then
+						top.data = data
+					end
+					back_in(top, screen, callbacks.track())
 				end
-				back_in(top, screen, callbacks.track())
-			end)
-		else
-			back_out(screen, top)
-			if top then
-				if data then
-					top.data = data
-				end
-				back_in(top, screen, callbacks.track())
 			end
 		end
-	end
 
-	if cb then callbacks.when_done(cb) end
+		callbacks.when_done(function()
+			pcallfn(cb)
+			pcallfn(action_done)
+		end)
+	end)
 
-	return true
+	return true -- return true for legacy reasons (before queue existed)
 end
 
 
@@ -746,7 +872,13 @@ function M.is_preloading(id)
 	local screen = screens[id]
 	return screen.preloading
 end
-
+function M.is_preloaded(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.preloaded
+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
@@ -770,37 +902,44 @@ end
 -- @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)
+	log("preload() queuing action", id)
+	queue_action(function(action_done, action_error)
+		log("preload()", id)
+
+		local screen = screens[id]
+		if not screen then
+			action_error(("preload() there is no longer a screen with id %s"):format(tostring(id)))
+			return
 		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
+
+		if screen.preloaded or screen.loaded then
+			pcallfn(cb)
+			pcallfn(action_done)
+			return
+		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)
+			pcallfn(action_done)
+		end
+		run_coroutine(screen, when_preloaded, function()
+			change_context(screen)
+			local ok, err = preload(screen)
+			if not ok then
+				action_error(err)
+			end
+		end)
 	end)
-	return true
+	return true -- return true for legacy reasons (before queue existed)
 end
 
 
@@ -808,31 +947,41 @@ end
 -- @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
+	log("unload() queuing action", id)
+	queue_action(function(action_done, action_error)
+		if M.is_visible(id) then
+			action_error("unload() you can't unload a visible screen")
+			return
+		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)
+		log("unload()", id)
+		local screen = screens[id]
+		if not screen then
+			action_error(("unload() there is no longer a screen with id %s"):format(tostring(id)))
+			return
+		end
+
+		if not screen.preloaded and not screen.loaded then
+			log("unload() screen is not loaded", tostring(id))
+			pcallfn(cb)
+			pcallfn(action_done)
+			return
+		end
+
+		local function when_unloaded()
+			pcallfn(cb)
+			pcallfn(action_done)
+		end
+		run_coroutine(screen, when_unloaded, function()
+			change_context(screen)
+			unload(screen)
+		end)
 	end)
-	return true
+	return true -- return true for legacy reasons (before queue existed)
 end
 
 
@@ -851,8 +1000,8 @@ function M.post(id, message_id, message)
 	assert(message_id, "You must provide a message_id")
 	id = tohash(id)
 	assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
-	local screen = screens[id]
 
+	local screen = screens[id]
 	if screen.proxy then
 		if screen.receiver_url then
 			log("post() sending message to", screen.receiver_url)

monarch/transitions/gui.lua

@@ -174,6 +174,7 @@ local function create()
 		if t.in_progress_count == 0 then
 			table.insert(t.urls, msg.url())
 			current_transition = t
+			current_transition.id = transition_id
 			if #t.transitions > 0 then
 				for i=1,#t.transitions do
 					local transition = t.transitions[i]
@@ -206,7 +207,7 @@ local function create()
 					transition.fn(transition.node, transition.node_data, transition.easing, 0, 0)
 				end
 				if current_transition.in_progress_count > 0 then
-					finish_transition(message_id)
+					finish_transition(current_transition.id)
 				end
 			end
 		elseif message_id == monarch.TRANSITION.SHOW_IN

monarch/utils/callback_tracker.lua

@@ -7,6 +7,10 @@ function M.create()
 	local callback = nil
 	local callback_count = 0
 
+	local function is_done()
+		return callback_count == 0
+	end
+
 	local function invoke_if_done()
 		if callback_count == 0 and callback then
 			local ok, err = pcall(callback)
@@ -37,6 +41,20 @@ function M.create()
 		invoke_if_done()
 	end
 
+	function instance.yield_until_done()
+		local co = coroutine.running()
+		callback = function()
+			local ok, err = coroutine.resume(co)
+			if not ok then
+				print(err)
+			end
+		end
+		invoke_if_done()
+		if not is_done() then
+			coroutine.yield()
+		end
+	end
+
 	return instance
 end
 

test/data/child.collection

@@ -0,0 +1,22 @@
+name: "child"
+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/screen2.collection

@@ -35,3 +35,66 @@ embedded_instances {
     z: 1.0
   }
 }
+embedded_instances {
+  id: "child"
+  data: "components {\n"
+  "  id: \"screen_proxy\"\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: \"child\"\n"
+  "    type: PROPERTY_TYPE_HASH\n"
+  "  }\n"
+  "  properties {\n"
+  "    id: \"popup\"\n"
+  "    value: \"true\"\n"
+  "    type: PROPERTY_TYPE_BOOLEAN\n"
+  "  }\n"
+  "}\n"
+  "embedded_components {\n"
+  "  id: \"collectionproxy\"\n"
+  "  type: \"collectionproxy\"\n"
+  "  data: \"collection: \\\"/test/data/child.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
+  }
+}

test/msg.lua

@@ -8,9 +8,25 @@ local recipients = {}
 
 local history = {}
 
+local function url_to_key(url)
+	if type(url) == "string" then
+		url = msg.url(url)
+	end
+	local ok, err = pcall(function() return url.socket end)
+	if not ok then
+		return url
+	end
+	if url.socket then
+		return hash_to_hex(url.socket or hash("")) ..  hash_to_hex(url.path or hash("")) ..  hash_to_hex(url.fragment or hash(""))
+	else
+		return url
+	end
+end
+
 local function get_recipient(url)
-	recipients[url] = recipients[url] or {}
-	return recipients[url]
+	local key = url_to_key(url)
+	recipients[key] = recipients[key] or {}
+	return recipients[key]
 end
 
 local function post(url, message_id, message)

test/test.script

@@ -2,11 +2,13 @@ local deftest = require "deftest.deftest"
 
 local test_monarch = require "test.test_monarch"
 local test_callback_tracker = require "test.test_callback_tracker"
+local test_transitions = require "test.test_transitions"
 
 
 function init(self)
 	deftest.add(test_monarch)
 	deftest.add(test_callback_tracker)
+	deftest.add(test_transitions)
 	deftest.run({ 
 		coverage = { enabled = true },
 		pattern = "",

test/test_monarch.lua

@@ -6,6 +6,7 @@ local monarch = require "monarch.monarch"
 local SCREEN1_STR = hash("screen1")
 local SCREEN1 = hash(SCREEN1_STR)
 local SCREEN2 = hash("screen2")
+local CHILD = hash("child")
 local SCREEN_PRELOAD = hash("screen_preload")
 local FOCUS1 = hash("focus1")
 local BACKGROUND = hash("background")
@@ -14,6 +15,26 @@ local POPUP2 = hash("popup2")
 local FOOBAR = hash("foobar")
 local TRANSITION1 = hash("transition1")
 
+local function check_stack(expected_screens)
+	local actual_screens = monarch.get_stack()
+	if #actual_screens ~= #expected_screens then
+		return false, "Stack length mismatch"
+	end
+	for i=1,#actual_screens do
+		if actual_screens[i] ~= expected_screens[i] then
+			return false, "Stack content not matching"
+		end
+	end
+	return true
+end
+
+local telescope = require "deftest.telescope"
+telescope.make_assertion(
+	"stack",
+	function(_, ...) return telescope.assertion_message_prefix .. "stack to match" end,
+	function(expected_screens) return check_stack(expected_screens) end
+)
+
 return function()
 
 	local screens_instances = {}
@@ -26,6 +47,10 @@ return function()
 		return not monarch.is_visible(screen_id)
 	end
 
+	local function is_preloading(screen_id)
+		return monarch.is_preloading(screen_id)
+	end
+
 	local function wait_timeout(fn, ...)
 		local args = { ... }
 		cowait(function() return fn(unpack(args)) end, 5)
@@ -46,23 +71,18 @@ return function()
 	local function wait_until_hidden(screen_id)
 		return wait_timeout(is_hidden, screen_id)
 	end
+	local function wait_until_preloading(screen_id)
+		return wait_timeout(is_preloading, 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()
-		if #actual_screens ~= #expected_screens then
-			error("Stack length mismatch", 2)
-		end
-		for i=1,#actual_screens do
-			if actual_screens[i] ~= expected_screens[i] then
-				error("Stack content not matching", 2)
-			end
-		end
+	local function wait_until_loaded(screen_id)
+		wait_until_done(function(done)
+			monarch.when_preloaded(screen_id, done)
+		end)
 	end
-
-	
+		
 	describe("monarch", function()
 		before(function()
 			mock_msg.mock()
@@ -72,6 +92,7 @@ return function()
 		end)
 
 		after(function()
+			print("[TEST] done")
 			while #monarch.get_stack() > 0 do
 				monarch.back()
 				wait_until_not_busy()
@@ -112,6 +133,22 @@ return function()
 			assert_stack({ })
 		end)
 
+		it("should be able to replace screens at the top of the stack", function()
+			monarch.show(SCREEN1_STR)
+			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 })
+
+			monarch.replace(SCREEN1)
+			assert(wait_until_hidden(SCREEN2), "Screen2 was never hidden")
+			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
+			assert_stack({ SCREEN1, SCREEN1 })
+		end)
+
 		it("should be able to tell if a screen is visible or not", function()
 			assert(not monarch.is_visible(SCREEN1))
 			monarch.show(SCREEN1)
@@ -171,7 +208,7 @@ return function()
 			assert_stack({ SCREEN1 })
 		end)
 
-		it("should be able to pass data to a screen when showning it or going back to it", function()
+		it("should be able to pass data to a screen when showing it or going back to it", function()
 			local data1 = { foo = "bar" }
 			monarch.show(SCREEN1, nil, data1)
 			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
@@ -185,7 +222,7 @@ return function()
 
 			local data_back = { going = "back" }
 			monarch.back(data_back)
-			assert_stack({ SCREEN1 })
+			assert(wait_until_shown(SCREEN1))
 
 			assert(monarch.data(SCREEN1) == data_back, "Expected data on screen1 doesn't match actual data")
 		end)
@@ -226,23 +263,32 @@ return function()
 			assert_stack({ SCREEN1, POPUP1, POPUP2 })
 		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)
+		it("should prevent further operations while hiding/showing a screen", function()
+			monarch.show(SCREEN1)
+			monarch.show(SCREEN2)
+			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
 			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 })
+			assert(monarch.back())
+			assert(monarch.back())
+			assert(wait_until_hidden(SCREEN1), "Screen1 was never hidden")
+			assert(wait_until_hidden(SCREEN2), "Screen2 was never hidden")
 		end)
-		
+
+
+		it("should not perform further operations if an operation fails", function()
+			monarch.show(SCREEN2) -- SCREEN2 contains CHILD
+			wait_until_not_busy()
+			assert_stack({ SCREEN2 })
+			monarch.back() -- this will unload SCREEN2 and CHILD
+			monarch.show(CHILD) -- this will fail since CHILD has been unloaded
+			monarch.show(SCREEN1) -- this should be ignored
+			wait_until_not_busy()
+			assert_stack({ })
+		end)
+				
 		
 		it("should close any open popups when showing a popup without the Popup On Popup flag", function()
 			monarch.show(SCREEN1)
@@ -272,6 +318,59 @@ return function()
 			assert_stack({ SCREEN1, SCREEN2 })
 		end)
 
+		it("should close any open popups when replacing a non-popup", function()
+			monarch.show(SCREEN1)
+			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
+			assert_stack({ SCREEN1 })
+			monarch.show(POPUP1)
+			assert(wait_until_shown(POPUP1), "Popup1 was never shown")
+			assert_stack({ SCREEN1, POPUP1 })
+			monarch.show(POPUP2)
+			assert(wait_until_shown(POPUP2), "Popup2 was never shown")
+			assert_stack({ SCREEN1, POPUP1, POPUP2 })
+			monarch.replace(SCREEN2)
+			assert(wait_until_shown(SCREEN2), "Screen2 was never shown")
+			assert_stack({ SCREEN2 })
+		end)
+
+		it("should replace a popup", function()
+			monarch.show(SCREEN1)
+			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
+			assert_stack({ SCREEN1 })
+			monarch.show(POPUP1)
+			assert(wait_until_shown(POPUP1), "Popup1 was never shown")
+			assert_stack({ SCREEN1, POPUP1 })
+			monarch.replace(POPUP2)
+			assert(wait_until_shown(POPUP2), "Popup2 was never shown")
+			assert_stack({ SCREEN1, POPUP2 })
+		end)
+
+		it("should replace a pop-up two levels down", function()
+			monarch.show(SCREEN1)
+			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
+			assert_stack({ SCREEN1 })
+			monarch.show(POPUP1)
+			assert(wait_until_shown(POPUP1), "Popup1 was never shown")
+			assert_stack({ SCREEN1, POPUP1 })
+			monarch.show(POPUP2)
+			assert(wait_until_shown(POPUP2), "Popup2 was never shown")
+			assert_stack({ SCREEN1, POPUP1, POPUP2 })
+			monarch.show(POPUP2, { pop = 2 })
+			assert(wait_until_shown(POPUP2), "Popup2 was never shown")
+			assert_stack({ SCREEN1, POPUP2 })
+		end)
+
+		it("shouldn't over-pop popups", function()
+			monarch.show(SCREEN1)
+			assert(wait_until_shown(SCREEN1), "Screen1 was never shown")
+			assert_stack({ SCREEN1 })
+			monarch.show(POPUP1)
+			assert(wait_until_shown(POPUP1), "Popup1 was never shown")
+			assert_stack({ SCREEN1, POPUP1 })
+			monarch.show(POPUP2, { pop = 10 })
+			assert(wait_until_shown(POPUP2), "Popup2 was never shown")
+			assert_stack({ SCREEN1, POPUP2 })
+		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)
@@ -308,7 +407,6 @@ return function()
 		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)
@@ -364,31 +462,25 @@ return function()
 			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)
+			assert(mock_msg.messages(URL1)[9].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
+			assert(mock_msg.messages(URL1)[9].message.screen == SCREEN1)
+			assert(mock_msg.messages(URL1)[10].message_id == monarch.SCREEN_TRANSITION_OUT_FINISHED)
+			assert(mock_msg.messages(URL1)[10].message.screen == SCREEN2)
 		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 })
+			monarch.show(SCREEN_PRELOAD)
 			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)
+			monarch.back()
+			assert(wait_until_hidden(SCREEN_PRELOAD), "Screen_preload was never hidden")
+			assert(monarch.is_preloaded(SCREEN_PRELOAD))
 		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")

test/test_transitions.lua

@@ -0,0 +1,46 @@
+local cowait = require "test.cowait"
+local mock_msg = require "test.msg"
+local mock_gui = require "deftest.mock.gui"
+local unload = require "deftest.util.unload"
+local monarch = require "monarch.monarch"
+local transitions = require "monarch.transitions.gui"
+local easing = require "monarch.transitions.easings"
+
+return function()
+
+describe("transitions", function()
+	before(function()
+		mock_msg.mock()
+		mock_gui.mock()
+		transitions = require "monarch.transitions.gui"
+	end)
+
+	after(function()
+		mock_msg.unmock()
+		mock_gui.unmock()
+		unload.unload("monarch%..*")
+	end)
+
+
+	it("should replay and immediately finish on layout change", function()
+		function dummy_transition(node, to, easing, duration, delay, cb)
+			print("dummy transition")
+		end
+
+		local node = gui.new_box_node(vmath.vector3(), vmath.vector3(100, 100, 0))
+		local duration = 2
+		local t = transitions.create(node)
+		.show_in(dummy_transition, easing.OUT, duration, delay or 0)
+		.show_out(dummy_transition, easing.IN, duration, delay or 0)
+		.back_in(dummy_transition, easing.OUT, duration, delay or 0)
+		.back_out(dummy_transition, easing.IN, duration, delay or 0)
+
+		t.handle(monarch.TRANSITION.SHOW_IN)
+		t.handle(hash("layout_changed"))
+		local messages = mock_msg.messages(msg.url())
+		assert(#messages == 1, "Expected one message to have been received")
+		assert(messages[1].message_id == monarch.TRANSITION.DONE, "Expected a TRANSITION.DONE message")
+	end)
+end)
+
+end