rewrite editor script to use editor.transact api (#115)

Fixes #

.github/workflows/ci-workflow.yml

@@ -7,13 +7,13 @@ jobs:
         name: Build and run
         runs-on: ubuntu-latest
         steps:
-          - uses: actions/checkout@v1
+          - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11
-          - uses: actions/setup-java@v1
+          - uses: actions/setup-java@99b8673ff64fbf99d8d325f52d9a5bdedb8483e9
             with:
-                java-version: '11'
+                java-version: '21.0.5+11.0.LTS'
+                distribution: 'temurin'
           - name: Run.sh
             env:
                 DEFOLD_USER: bjorn.ritzl@gmail.com
                 DEFOLD_AUTH: foobar
-                DEFOLD_BOOSTRAP_COLLECTION: /test/test.collectionc
             run: ./.test/run.sh

.gitignore

@@ -9,3 +9,6 @@ build
 builtins
 .internal
 luacov.report.out
+/.editor_settings
+manifest.private.der
+manifest.public.der

.test/run.sh

@@ -5,7 +5,6 @@ else
 	PLATFORM="$1"
 fi
 
-
 echo "${PLATFORM}"
 
 # {"version": "1.2.89", "sha1": "5ca3dd134cc960c35ecefe12f6dc81a48f212d40"}
@@ -16,26 +15,28 @@ echo "Using Defold dmengine_headless version ${SHA1}"
 # Create dmengine_headless and bob.jar URLs
 DMENGINE_URL="http://d.defold.com/archive/${SHA1}/engine/${PLATFORM}/dmengine_headless"
 BOB_URL="http://d.defold.com/archive/${SHA1}/bob/bob.jar"
+DMENGINE_FILE=dmengine_headless_${SHA1}
+BOB_FILE=bob_${SHA1}.jar
 
 # Download dmengine_headless
-echo "Downloading ${DMENGINE_URL}"
+if ! [ -f ${DMENGINE_FILE} ]; then
-curl -L -o dmengine_headless ${DMENGINE_URL}
+	echo "Downloading ${DMENGINE_URL} to ${DMENGINE_FILE}"
-chmod +x dmengine_headless
+	curl -L -o ${DMENGINE_FILE} ${DMENGINE_URL}
+	chmod +x ${DMENGINE_FILE}
+fi
 
 # Download bob.jar
-echo "Downloading ${BOB_URL}"
+if ! [ -f ${BOB_FILE} ]; then
-curl -L -o bob.jar ${BOB_URL}
+	echo "Downloading ${BOB_URL} to ${BOB_FILE}"
+	curl -L -o ${BOB_FILE} ${BOB_URL}
+fi
 
 # Fetch libraries
-echo "Running bob.jar - resolving dependencies"
+echo "Running ${BOB_FILE} - resolving dependencies"
-java -jar bob.jar --auth "foobar" --email "john@doe.com" resolve
+java -jar ${BOB_FILE} --auth "foobar" --email "john@doe.com" resolve
 
-echo "Running bob.jar - building"
+echo "Running ${BOB_FILE} - building"
-java -jar bob.jar --debug build --keep-unused
+java -jar ${BOB_FILE} --debug build --settings=test.settings
 
-echo "Starting dmengine_headless"
+echo "Starting ${DMENGINE_FILE}"
-if [ -n "${DEFOLD_BOOSTRAP_COLLECTION}" ]; then
+./${DMENGINE_FILE}
-	./dmengine_headless --config=bootstrap.main_collection=${DEFOLD_BOOSTRAP_COLLECTION}
-else
-	./dmengine_headless
-fi

README.md

@@ -20,10 +20,15 @@ Or point to the ZIP file of a [specific release](https://github.com/britzl/monar
 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.
+Right click in on a`.gui`, `.gui_script` or `.collection` file in the outline and selected the menu item, it creates the other two file types with the same name as the selected 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.
+
+You can also right click on directory to get the option to create a monarch scene from it, the directory should be empty (or only contain other monarch scene files).Use the option and it will create all three files inside of the directory.
 
 <img src="/docs/editor_script.gif" width="200px">
 
+You can use Monarchs editor script with your own custom templates. Create the template files you want, these are normal defold files. Then inside of your game.project file add a path to the files you created.
+
+
 ## Creating screens
 Monarch screens are created in individual collections and either loaded through collection proxies or created through collection factories.
 

README_API.md

@@ -40,13 +40,18 @@ Clear the stack of screens completely. Any visible screen will be hidden by navi
 * `callback` (function) - Optional function to call when the stack has been cleared.
 
 
-## monarch.back([data], [callback])
+## monarch.back([options], [data], [callback])
 Go back to a previous Monarch screen. This operation will be added to the queue if Monarch is busy.
 
 **PARAMETERS**
+* `options` (table) - Options when showing the new screen (see below).
 * `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.
 
+The options table can contain the following fields:
+
+* `sequential` (boolean) - If the `sequential` flag is set Monarch will start loading the screen only after the previous screen finished transitioning out.
+
 
 ## monarch.preload(screen_id, [options], [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. This operation will be added to the queue if Monarch is busy.
@@ -177,7 +182,7 @@ Remove a previously added listener.
 
 
 ## monarch.post(screen_id, message_id, [message])
-Post a message to a visible screen. If the screen is created through a collection proxy it must have specified a receiver url. If the screen is created through a collection factory the function will post the message to all game objects within the collection.
+Post a message to a visible screen. The screen must have set a message listener using `monarch.on_post()`.
 
 **PARAMETERS**
 * `screen_id` (string|hash) - Id of the screen to post message to
@@ -207,12 +212,21 @@ IMPORTANT! You must call `monarch.on_message(message_id, message, sender)` from
 * `fn` (function) - The function to call screen focus changes
 
 
-## monarch.on_post(screen_id, fn)
+## monarch.on_post(screen_id, fn_or_url)
-Set a function to be called when `msg.post()` is called on a specific screen. IMPORTANT! You must call `monarch.on_message(message_id, message, sender)` from the same script as this function was called.
+Set either a function to be called when `msg.post()` is called on a specific screen or a URL where the message is sent.
+
+IMPORTANT! If you provide a function you must also make sure to call `monarch.on_message(message_id, message, sender)` from the same script as this function was called.
 
 **PARAMETERS**
 * `screen_id` (string|hash) - Id of the screen
-* `fn` (function) - The function to call when the screen receives a message using `msg.post`
+* `fn_or_url` (function) - The function to call or URL to send message to
+
+
+## monarch.has_missing_resources(screen_id)
+Check if a screen has any missing resources. If the screen is loaded by a collection proxy with Load Dynamically this will use `collectionproxy.missing_resources()`. For other cases this function will always return false.
+
+**RETURN**
+* `result` (boolean) - true if the screen has missing resources
 
 
 ## monarch.debug()

README_TRANSITIONS.md

@@ -114,7 +114,7 @@ end
 
 function on_message(self, message_id, message, sender)
 	if message_id == hash("my_resize_message") then
-		self.transition.window_resized(message.width, message.height)
+		transition.window_resized(message.width, message.height)
 	end
 end
 ```

example/advanced/about.gui_script

@@ -5,11 +5,13 @@ function init(self)
 	msg.post(".", "acquire_input_focus")
 	gui.set_render_order(15)
 
-	self.transition = transitions.create(gui.get_node("root"))
+	local transition = transitions.create(gui.get_node("root"))
 		.show_in(transitions.slide_in_top, gui.EASING_OUTQUAD, 0.6, 0)
 		.show_out(transitions.slide_out_top, gui.EASING_INQUAD, 0.6, 0)
 		.back_in(transitions.slide_in_top, gui.EASING_OUTQUAD, 0.6, 0)
 		.back_out(transitions.slide_out_top, gui.EASING_INQUAD, 0.6, 0)
+
+	monarch.on_transition("about", transition)
 end
 
 function on_input(self, action_id, action)
@@ -27,5 +29,5 @@ function on_input(self, action_id, action)
 end
 
 function on_message(self, message_id, message, sender)
-	self.transition.handle(message_id, message, sender)
+	monarch.on_message(message_id, message, sender)
 end

example/advanced/advanced.collection

@@ -21,16 +21,6 @@ embedded_instances {
   "    value: \"menu\"\n"
   "    type: PROPERTY_TYPE_HASH\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"
   "  property_decls {\n"
   "  }\n"
   "}\n"
@@ -146,11 +136,6 @@ embedded_instances {
   "    value: \"pregame\"\n"
   "    type: PROPERTY_TYPE_HASH\n"
   "  }\n"
-  "  properties {\n"
-  "    id: \"transition_url\"\n"
-  "    value: \"pregame:/go#pregame\"\n"
-  "    type: PROPERTY_TYPE_URL\n"
-  "  }\n"
   "  property_decls {\n"
   "  }\n"
   "}\n"
@@ -211,11 +196,6 @@ embedded_instances {
   "    value: \"game\"\n"
   "    type: PROPERTY_TYPE_HASH\n"
   "  }\n"
-  "  properties {\n"
-  "    id: \"transition_url\"\n"
-  "    value: \"game:/go#game\"\n"
-  "    type: PROPERTY_TYPE_URL\n"
-  "  }\n"
   "  property_decls {\n"
   "  }\n"
   "}\n"
@@ -287,16 +267,6 @@ embedded_instances {
   "    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: \"focus_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"
@@ -376,11 +346,6 @@ embedded_instances {
   "    value: \"true\"\n"
   "    type: PROPERTY_TYPE_BOOLEAN\n"
   "  }\n"
-  "  properties {\n"
-  "    id: \"transition_url\"\n"
-  "    value: \"confirm:/go#confirm\"\n"
-  "    type: PROPERTY_TYPE_URL\n"
-  "  }\n"
   "  property_decls {\n"
   "  }\n"
   "}\n"

example/advanced/confirm.gui_script

@@ -7,11 +7,13 @@ function init(self)
 	self.no = gui.get_node("no_button")
 	gui.set_render_order(15)
 
-	self.transition = transitions.create(gui.get_node("root"))
+	local 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)
 		.back_in(transitions.scale_in, gui.EASING_OUTBACK, 0.3, 0)
 		.back_out(transitions.scale_out, gui.EASING_INBACK, 0.3, 0)
+
+	monarch.on_transition("confirm", transition)
 end
 
 function on_input(self, action_id, action)
@@ -27,7 +29,7 @@ function on_input(self, action_id, action)
 			end
 		elseif gui.pick_node(self.no, action.x, action.y) then
 			print("no")
-			monarch.back(function()
+			monarch.back(nil, nil, function()
 				print("back from popup done")
 			end)
 		end
@@ -35,5 +37,5 @@ function on_input(self, action_id, action)
 end
 
 function on_message(self, message_id, message, sender)
-	self.transition.handle(message_id, message, sender)
+	monarch.on_message(message_id, message, sender)
 end

example/advanced/game.gui_script

@@ -3,11 +3,12 @@ local transitions = require "monarch.transitions.gui"
 
 function init(self)
 	msg.post(".", "acquire_input_focus")
-	
+
 	local data = monarch.data(hash("game"))
 	gui.set_text(gui.get_node("level"), tostring(data.level))
 
-	self.transition = transitions.in_right_out_left(gui.get_node("root"), 0.6, 0)
+	local transition = transitions.in_right_out_left(gui.get_node("root"), 0.6, 0)
+	monarch.on_transition("game", transition)
 end
 
 function on_input(self, action_id, action)
@@ -21,5 +22,5 @@ function on_input(self, action_id, action)
 end
 
 function on_message(self, message_id, message, sender)
-	self.transition.handle(message_id, message, sender)
+	monarch.on_message(message_id, message, sender)
 end

example/advanced/menu.gui_script

@@ -8,7 +8,8 @@ function init(self)
 
 	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)
+	local transition = transitions.fade_in_out(gui.get_node("root"), 0.6, 0)
+	monarch.on_transition("menu", transition)
 end
 
 function on_input(self, action_id, action)
@@ -28,7 +29,7 @@ function on_input(self, action_id, action)
 end
 
 function on_message(self, message_id, message, sender)
-	self.transition.handle(message_id, message, sender)
+	monarch.on_message(message_id, message, sender)
 	if message_id == monarch.FOCUS.GAINED then
 		gui.set_text(gui.get_node("timestamp"), os.date())
 	end

example/advanced/popup.gui_script

@@ -9,12 +9,13 @@ function init(self)
 	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"))
+	local 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)
 		.back_in(transitions.scale_in, gui.EASING_OUTBACK, 0.3, 0)
 		.back_out(transitions.scale_out, gui.EASING_INBACK, 0.3, 0)
+	monarch.on_transition("popup", transition)
 end
 
 function on_input(self, action_id, action)
@@ -26,7 +27,7 @@ function on_input(self, action_id, action)
 			end)
 		elseif gui.pick_node(self.cancel, action.x, action.y) then
 			print("cancel")
-			monarch.back(function()
+			monarch.back(nil, nil, function()
 				print("back from popup done")
 			end)
 		elseif gui.pick_node(self.about, action.x, action.y) then
@@ -39,5 +40,5 @@ function on_input(self, action_id, action)
 end
 
 function on_message(self, message_id, message, sender)
-	self.transition.handle(message_id, message, sender)
+	monarch.on_message(message_id, message, sender)
 end

example/advanced/pregame.gui_script

@@ -5,8 +5,9 @@ function init(self)
 	msg.post(".", "acquire_input_focus")
 	self.play = gui.get_node("play_button")
 	self.back = gui.get_node("back_button")
-	
+
-	self.transition = transitions.in_right_out_left(gui.get_node("root"), 0.6, 0)
+	local transition = transitions.in_right_out_left(gui.get_node("root"), 0.6, 0)
+	monarch.on_transition("pregame", transition)
 end
 
 function on_input(self, action_id, action)
@@ -18,7 +19,7 @@ function on_input(self, action_id, action)
 			end)
 		elseif gui.pick_node(self.back, action.x, action.y) then
 			print("back")
-			monarch.back(function()
+			monarch.back(nil, nil, function()
 				print("back from pregame done")
 			end)
 		end
@@ -26,5 +27,5 @@ function on_input(self, action_id, action)
 end
 
 function on_message(self, message_id, message, sender)
-	self.transition.handle(message_id, message, sender)
+	monarch.on_message(message_id, message, sender)
 end

example/slidingwindow/slidingwindow.script

@@ -4,10 +4,25 @@ function init(self)
 	monarch.debug()
 	msg.post("@render:/", "clear_color", { color = vmath.vector4(0.4, 0.6, 0.8,1.0) })
 	msg.post("#", "init_monarch") -- wait until init() has been called for all screen.script instances
+	monarch.add_listener()
+end
+
+function final(self)
+	monarch.remove_listener()
 end
 
 function on_message(self, message_id, message, sender)
 	if message_id == hash("init_monarch") then
 		monarch.show(hash("window1"))
+	elseif message_id == monarch.SCREEN_TRANSITION_IN_STARTED then
+		print("Monarch screen transition in started", message.screen)
+	elseif message_id == monarch.SCREEN_TRANSITION_IN_FINISHED then
+		print("Monarch screen transition in finished", message.screen)
+	elseif message_id == monarch.SCREEN_TRANSITION_OUT_STARTED then
+		print("Monarch screen transition out started", message.screen)
+	elseif message_id == monarch.SCREEN_TRANSITION_OUT_FINISHED then
+		print("Monarch screen transition out finished", message.screen)
+	elseif message_id == monarch.SCREEN_TRANSITION_FAILED then
+		print("Monarch screen transition failed")
 	end
 end

example/slidingwindow/window2.gui_script

@@ -23,6 +23,5 @@ function on_input(self, action_id, action)
 end
 
 function on_message(self, message_id, message, sender)
-	print("window2", message_id, message, sender)
 	monarch.on_message(message_id, message, sender)
 end

game.project

@@ -2,10 +2,9 @@
 title = Monarch
 version = 0.9
 dependencies#0 = https://github.com/britzl/deftest/archive/2.7.0.zip
-dependencies#1 = https://github.com/defold/lua-language-server/releases/download/v0.0.3/release.zip
 
 [bootstrap]
-main_collection = /example/slidingwindow/slidingwindow.collectionc
+main_collection = /example/advanced/advanced.collectionc
 
 [input]
 game_binding = /input/game.input_bindingc
@@ -20,10 +19,10 @@ display_profiles = /example/example.display_profilesc
 shared_state = 1
 
 [ios]
-bundle_identifier = com.example.todo
+bundle_identifier = com.defold.monarch
 
 [osx]
-bundle_identifier = com.example.todo
+bundle_identifier = com.defold.monarch
 
 [library]
 include_dirs = monarch

monarch/editor-script/make_monarch.editor_script

@@ -1,8 +1,13 @@
 local M = {}
 
 local collection_template
-local gui_script_content
+local gui_script_template
-local gui_file_content
+local gui_template
+
+local function _log(msg)
+    io.stdout:write("ERROR:MONARCH: " .. msg .. "\n")
+    io.stdout:flush()
+end
 
 local function ends_with(str, ending)
     return ending == "" or str:sub(-#ending) == ending
@@ -13,48 +18,143 @@ local function file_exists(name)
     if f~=nil then io.close(f) return true else return false end
 end
 
-local function get_filename(path)   
+local function get_filename(path)
     local main, filename, extension = path:match("(.-)([^\\/]-%.?([^%.\\/]*))$")
     return main, filename
 end
 
-local function create_files(file_path)
+local function get_template(game_project_path)
+    -- The input file can be the "compiled" file. If they are they end with "c".
+    -- If they end with "c" remove the last charater.
+    local path = editor.get("/game.project", game_project_path)
+    if path == nil then
+        return
+    end
+    if ends_with(path, "c") then
+        return path:sub(1, -2)
+    end
+    return path
+end
+
+local function get_template_content(type_string)
+    local default_template = {
+        collection = collection_template,
+        gui_script = gui_script_template,
+        gui = gui_template,
+    }
+    local custom_template = {
+        collection = get_template("monarch.collection_template"),
+        gui_script = get_template("monarch.gui_script_template"),
+        gui = get_template("monarch.gui_template"),
+    }
+    local template = custom_template[type_string]
+    if template ~= nil then
+        local file = io.open("." .. template, "rb")
+        if file == nil then
+            _log("Could not read " .. type_string .. " template '" .. template .. "'")
+            return
+        end
+        local content = file:read("*a")
+        file:close()
+        return content
+    end
+    return default_template[type_string]
+end
+
+local function add_monarch_go(collection_file, gui_file, name)
+    return editor.tx.add(collection_file, "children", {
+        type = "go",
+        id = "monarch",
+        components = {
+            {
+                type = "component-reference",
+                id = name,
+                path = gui_file,
+            }
+        }
+    })
+end
+
+local function create_collection(collection_file, gui_file, name)
+    local _collection_content = get_template_content("collection")
+    if _collection_content == nil then
+        _log("Could not create colletion file at " .. gui)
+        return
+    end
+    local collection = io.open("." .. collection_file, "w")
+    if collection == nil then
+        _log("Could not create colletion file at " .. collection_file)
+        return
+    end
+    collection:write(_collection_content)
+    collection:close()
+    return add_monarch_go(collection_file, gui_file, name)
+end
+
+local function create_gui(gui_file, gui_script_file)
+    local gui_content = get_template_content("gui")
+    if gui_content == nil then
+        _log("Could not create gui file at " .. gui)
+        return
+    end
+    local gui = io.open("." .. gui_file, "w")
+    if gui == nil then
+        _log("Could not create gui file at " .. gui)
+        return
+    end
+    gui:write(gui_content)
+    gui:close()
+
+    return editor.tx.set(gui_file, "script", gui_script_file)
+end
+
+local function create_files(directory, name)
     -- Construct paths
-    local path = editor.get(file_path, "path")
+    local target_collection_path = directory .. name .. ".collection"
-    local main, filename = get_filename(path)
+    local target_gui_script_path = directory .. name .. ".gui_script"
-    local basename = filename:match("(.+)%..+")
+    local target_gui_path = directory .. name .. ".gui"
-    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_gui_script_path) then
-    if not file_exists(target_collection_path) then
+        local gui_script_template_content = get_template_content("gui_script")
-        local collection_content = collection_template(path, basename)
+        if gui_script_template_content == nil then
-        local collection = io.open(target_collection_path, "w")
+            return
-        collection:write(collection_content)
+        end
-        collection:close()
+        local gui_script = io.open("." .. target_gui_script_path, "w")
-    end
+        gui_script:write(gui_script_template_content)
-    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 transactions = {}
-        local gui_content = gui_template(path)
+
-        local gui = io.open(target_gui_path, "w")
+    if file_exists("." .. target_gui_path) then
-        gui:write(gui_content)
+        -- If the gui file exists change the script.
-        gui:close()
+        table.insert(transactions, editor.tx.set(target_gui_path, "script", target_gui_script_path)
+    )
+    else
+        -- If the gui file doesn't exist create a new one.
+        local transaction = create_gui(target_gui_path, target_gui_script_path)
+        if transaction == nil then
+            return
+        end
+        table.insert(transactions, transaction)
+    end
+    if file_exists("." .. target_collection_path) then
+        --- If the collection already exists we will add the monarch go to it.
+        local transaction = add_monarch_go(target_collection_path, target_gui_path, name)
+        if transaction == nil then
+            return
+        end
+        table.insert(transactions, transaction)
+    else
+        -- If the collection doesn't exists we create a new one.
+        local transaction = create_collection(target_collection_path, target_gui_path, name)
+        if transaction == nil then
+            return
+        end
+        table.insert(transactions, transaction)
+    end
+    if #transactions > 1 then
+        editor.transact(transactions)
+        editor.save()
     end
 end
 
@@ -68,30 +168,54 @@ function M.get_commands()
             },
             active = function(opts)
                 local path = editor.get(opts.selection, "path")
-                return ends_with(path, ".gui")
+                return ends_with(path, ".gui") or ends_with(path, ".gui_script") or ends_with(path, ".collection")
             end,
             run = function(opts)
-                create_files(opts.selection)
+                local path = editor.get(opts.selection, "path")
+                local directory, filename = get_filename(path)
+
+                local basename = filename:match("(.+)%..+")
+                create_files(directory, basename)
+            end
+        },
+        {
+            label="Create Monarch Scene From Directory",
+            locations = {"Assets"},
+            query = {
+                selection = {type = "resource", cardinality = "one"}
+            },
+            active = function(opts)
+                local _is_directory = editor.resource_attributes(editor.get(opts.selection, "path")).is_directory
+                if not _is_directory then
+                    return false
+                end
+                local _children = editor.get(opts.selection, "children")
+                if #_children >= 3 then
+                    return false
+                end
+                for i = 1, #_children do
+                    local _path = editor.get(_children[i], "path")
+                    if not (ends_with(_path, ".gui") or ends_with(_path, ".collection") or ends_with(_path, ".gui_script")) then
+                        return false
+                    end
+                end
+                return true
+            end,
+            run = function(opts)
+                local path = editor.get(opts.selection, "path")
+                local _, filename = get_filename(path)
+                create_files(path .. "/", filename)
             end
         }
     }
 end
 
-gui_template = function(gui_script)
+gui_template = [[
-    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"
+gui_script_template = [[local monarch = require "monarch.monarch"
 
 function init(self)
     msg.post(".", "acquire_input_focus")
@@ -113,49 +237,10 @@ function on_reload(self)
 end
 ]]
 
-
+collection_template = [[
-collection_template = function(gui_script, name)
+name: "m"
-    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/ext.properties

@@ -0,0 +1,10 @@
+[monarch]
+
+collection_template.type = resource
+collection_template.filter = collection
+
+gui_script_template.type = resource
+gui_script_template.filter = gui_script
+
+gui_template.type = resource
+gui_template.filter = gui

monarch/monarch.lua

@@ -3,17 +3,25 @@ local async = require "monarch.utils.async"
 
 local M = {}
 
-local CONTEXT = hash("monarch_context")
+local WAITFOR_COWAIT = hash("waitfor_cowait")
-local PROXY_LOADED = hash("proxy_loaded")
+local WAITFOR_CONTEXT = hash("waitfor_monarch_context")
-local PROXY_UNLOADED = hash("proxy_unloaded")
+local WAITFOR_PROXY_LOADED = hash("waitfor_proxy_loaded")
-local LAYOUT_CHANGED = hash("layout_changed")
+local WAITFOR_PROXY_UNLOADED = hash("waitfor_proxy_unloaded")
+local WAITFOR_TRANSITION_DONE = hash("waitfor_transition_done")
 
-local RELEASE_INPUT_FOCUS = hash("release_input_focus")
+local MSG_CONTEXT = hash("monarch_context")
-local ACQUIRE_INPUT_FOCUS = hash("acquire_input_focus")
+local MSG_PROXY_LOADED = hash("proxy_loaded")
-local ASYNC_LOAD = hash("async_load")
+local MSG_PROXY_UNLOADED = hash("proxy_unloaded")
-local UNLOAD = hash("unload")
+local MSG_LAYOUT_CHANGED = hash("layout_changed")
-local ENABLE = hash("enable")
+local MSG_RELEASE_INPUT_FOCUS = hash("release_input_focus")
-local DISABLE = hash("disable")
+local MSG_ACQUIRE_INPUT_FOCUS = hash("acquire_input_focus")
+local MSG_ASYNC_LOAD = hash("async_load")
+local MSG_UNLOAD = hash("unload")
+local MSG_ENABLE = hash("enable")
+local MSG_DISABLE = hash("disable")
+
+
+local DEPRECATED = hash("__DEPRECATED__")
 
 -- transition messages
 M.TRANSITION = {}
@@ -82,10 +90,13 @@ local function assign(to, from)
 	return to
 end
 
-local function cowait(delay)
+local function cowait(screen, delay)
+	log("cowait()", screen.id, delay)
 	local co = coroutine.running()
 	assert(co, "You must run this from within a coroutine")
+	screen.wait_for = WAITFOR_COWAIT
 	timer.delay(delay, false, function()
+		screen.wait_for = nil
 		assert(coroutine.resume(co))
 	end)
 	coroutine.yield()
@@ -217,6 +228,17 @@ function M.is_visible(id)
 end
 
 
+--- Check if a screen is loaded
+-- @param id (string|hash)
+-- @return true if the screen is loaded
+function M.is_loaded(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
+
+
 --- Check if a screen is a popup
 -- @param id Screen id
 -- @return true if the screen is a popup
@@ -261,12 +283,6 @@ end
 --		  keep input focus when below a popup
 --		* others_keep_input_focus_when_below_screen - If screens below this
 --		  screen should keep input focus
--- 		* transition_url - URL to a script that is responsible for the
---		  screen transitions
--- 		* focus_url - URL to a script that is to be notified of focus
---		  lost/gained events
---		* receiver_url - URL to a script that is to receive messages sent
---		  using monarch.send()
 --		* 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")
@@ -276,6 +292,15 @@ function M.register_proxy(id, proxy, settings)
 	screen.focus_url = settings and settings.focus_url
 	screen.receiver_url = settings and settings.receiver_url
 	screen.auto_preload = settings and settings.auto_preload
+	if screen.transition_url.fragment == DEPRECATED then
+		screen.transition_url = nil
+	end
+	if screen.focus_url.fragment == DEPRECATED then
+		screen.focus_url = nil
+	end
+	if screen.receiver_url.fragment == DEPRECATED then
+		screen.receiver_url = nil
+	end
 	if screen.auto_preload then
 		M.preload(id)
 	end
@@ -298,10 +323,6 @@ M.register = M.register_proxy
 --		  keep input focus when below a popup
 --		* others_keep_input_focus_when_below_screen - If screens below this
 --		  screen should keep input focus
--- 		* 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")
@@ -310,6 +331,13 @@ function M.register_factory(id, factory, settings)
 	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.transition_id == DEPRECATED then
+		screen.transition_id = nil
+	end
+	if screen.focus_id == DEPRECATED then
+		screen.focus_id = nil
+	end
 	if screen.auto_preload then
 		M.preload(id)
 	end
@@ -323,6 +351,7 @@ function M.unregister(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
 	-- remove screen from stack
 	for i = #stack, 1, -1 do
@@ -330,16 +359,20 @@ function M.unregister(id)
 			table.remove(stack, i)
 		end
 	end
+	screen.unregistered = true
+	if screen.wait_for then
+		assert(coroutine.resume(screen.co))
+	end
 end
 
 local function acquire_input(screen)
 	log("acquire_input()", screen.id)
 	if not screen.input then
 		if screen.proxy then
-			msg.post(screen.script, ACQUIRE_INPUT_FOCUS)
+			msg.post(screen.script, MSG_ACQUIRE_INPUT_FOCUS)
 		elseif screen.factory then
 			for id,instance in pairs(screen.factory_ids) do
-				msg.post(instance, ACQUIRE_INPUT_FOCUS)
+				msg.post(instance, MSG_ACQUIRE_INPUT_FOCUS)
 			end
 		end
 		screen.input = true
@@ -357,10 +390,10 @@ local function release_input(screen, next_screen)
 		local release_focus = not keep_if_next_is_popup and not keep_when_below_next
 		if release_focus then
 			if screen.proxy then
-				msg.post(screen.script, RELEASE_INPUT_FOCUS)
+				msg.post(screen.script, MSG_RELEASE_INPUT_FOCUS)
 			elseif screen.factory then
 				for id,instance in pairs(screen.factory_ids) do
-					msg.post(instance, RELEASE_INPUT_FOCUS)
+					msg.post(instance, MSG_RELEASE_INPUT_FOCUS)
 				end
 			end
 			screen.input = false
@@ -370,24 +403,25 @@ end
 
 local function change_context(screen)
 	log("change_context()", screen.id)
-	screen.wait_for = CONTEXT
+	screen.wait_for = WAITFOR_CONTEXT
-	msg.post(screen.script, CONTEXT, { id = screen.id })
+	msg.post(screen.script, MSG_CONTEXT, { id = screen.id })
 	coroutine.yield()
 	screen.wait_for = nil
 end
 
 local function unload(screen, force)
+	if screen.unregistered then return end
 	if screen.proxy then
 		log("unload() proxy", screen.id)
 		if screen.auto_preload and not force then
 			if screen.loaded then
-				msg.post(screen.proxy, DISABLE)
+				msg.post(screen.proxy, MSG_DISABLE)
 				screen.loaded = false
 			end
 			screen.preloaded = true
 		else
-			screen.wait_for = PROXY_UNLOADED
+			screen.wait_for = WAITFOR_PROXY_UNLOADED
-			msg.post(screen.proxy, UNLOAD)
+			msg.post(screen.proxy, MSG_UNLOAD)
 			coroutine.yield()
 			screen.loaded = false
 			screen.preloaded = false
@@ -396,7 +430,9 @@ local function unload(screen, force)
 	elseif screen.factory then
 		log("unload() factory", screen.id)
 		for id, instance in pairs(screen.factory_ids) do
-			go.delete(instance)
+			if go.exists(instance) then
+				go.delete(instance)
+			end
 		end
 		screen.factory_ids = nil
 		if screen.auto_preload and not force then
@@ -411,8 +447,8 @@ local function unload(screen, force)
 	-- 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(screen, 0)
-	cowait(0)
+	cowait(screen, 0)
 end
 
 
@@ -428,16 +464,19 @@ local function preload(screen)
 	screen.preloading = true
 	if screen.proxy then
 		log("preload() proxy")
-		local missing_resources = collectionproxy.missing_resources(screen.proxy)
+		if M.has_missing_resources(screen.id) then
-		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
+		screen.wait_for = WAITFOR_PROXY_LOADED
-		msg.post(screen.proxy, ASYNC_LOAD)
+		msg.post(screen.proxy, MSG_ASYNC_LOAD)
 		coroutine.yield()
+		screen.wait_for = nil
+		if screen.unregistered then
+			return false, "Screen was unregistered while loading"
+		end
 	elseif screen.factory then
 		log("preload() factory")
 		if collectionfactory.get_status(screen.factory) == collectionfactory.STATUS_UNLOADED then
@@ -445,6 +484,9 @@ local function preload(screen)
 				assert(coroutine.resume(screen.co))
 			end)
 			coroutine.yield()
+			if screen.unregistered then
+				return false, "Screen was unregistered while loading"
+			end
 		end
 
 		if collectionfactory.get_status(screen.factory) ~= collectionfactory.STATUS_LOADED then
@@ -476,11 +518,15 @@ local function load(screen)
 	end
 
 	if screen.proxy then
-		msg.post(screen.proxy, ENABLE)
+		msg.post(screen.proxy, MSG_ENABLE)
 	elseif screen.factory then
 		screen.factory_ids = collectionfactory.create(screen.factory)
-		screen.transition_url = screen.factory_ids[screen.transition_id]
+		if screen.transition_id then
-		screen.focus_url = screen.factory_ids[screen.focus_id]
+			screen.transition_url = screen.factory_ids[screen.transition_id]
+		end
+		if screen.focus_id then
+			screen.focus_url = screen.factory_ids[screen.focus_id]
+		end
 	end
 	screen.loaded = true
 	screen.preloaded = false
@@ -489,8 +535,9 @@ end
 
 local function transition(screen, message_id, message, wait)
 	log("transition()", screen.id)
+	if screen.unregistered then return end
 	if screen.transition_url then
-		screen.wait_for = M.TRANSITION.DONE
+		screen.wait_for = WAITFOR_TRANSITION_DONE
 		msg.post(screen.transition_url, message_id, message)
 		if wait then
 			coroutine.yield()
@@ -512,14 +559,15 @@ end
 
 local function focus_lost(screen, next_screen)
 	log("focus_lost()", screen.id)
+	if screen.unregistered then return end
 	if screen.focus_url then
 		msg.post(screen.focus_url, M.FOCUS.LOST, { id = next_screen and next_screen.id })
 		-- if there's no transition on the screen losing focus and it gets
 		-- unloaded this will happen before the focus_lost message reaches
 		-- the focus_url
 		-- we add a delay to ensure the message queue has time to be processed
-		cowait(0)
+		cowait(screen, 0)
-		cowait(0)
+		cowait(screen, 0)
 	else
 		log("focus_lost() no focus url - ignoring")
 	end
@@ -640,7 +688,7 @@ local function show_in(screen, previous_screen, reload, add_to_stack, wait_for_t
 			return
 		end
 		-- wait one frame so that the init() of any script have time to run before starting transitions
-		cowait(0)
+		cowait(screen, 0)
 		reset_timestep(screen)
 		transition(screen, M.TRANSITION.SHOW_IN, { previous_screen = previous_screen and previous_screen.id }, wait_for_transition)
 		screen.visible = true
@@ -666,7 +714,7 @@ local function back_in(screen, previous_screen, wait_for_transition, cb)
 			return
 		end
 		-- wait one frame so that the init() of any script have time to run before starting transitions
-		cowait(0)
+		cowait(screen, 0)
 		reset_timestep(screen)
 		if previous_screen and not previous_screen.popup then
 			transition(screen, M.TRANSITION.BACK_IN, { previous_screen = previous_screen.id }, wait_for_transition)
@@ -683,8 +731,8 @@ local function back_out(screen, next_screen, wait_for_transition, cb)
 	log("back_out()", screen.id)
 	assert(wait_for_transition ~= nil)
 	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
+		notify_transition_listeners(M.SCREEN_TRANSITION_OUT_STARTED, { screen = screen.id, next_screen = next_screen and next_screen.id })
 		change_context(screen)
 		release_input(screen, next_screen)
 		focus_lost(screen, next_screen)
@@ -831,13 +879,10 @@ function M.show(id, options, data, cb)
 				show_in(screen, top, options and options.reload, add_to_stack, WAIT_FOR_TRANSITION, callbacks.track())
 			else
 				-- show screen
-				local cb = callbacks.track()
+				show_in(screen, top, options and options.reload, add_to_stack, WAIT_FOR_TRANSITION, callbacks.track())
-				show_in(screen, top, options and options.reload, add_to_stack, DO_NOT_WAIT_FOR_TRANSITION, function()
+				if add_to_stack and top and not top.popup then
-					if add_to_stack and top and not top.popup then
+					show_out(top, screen, WAIT_FOR_TRANSITION, callbacks.track())
-						show_out(top, screen, WAIT_FOR_TRANSITION, callbacks.track())
+				end
-					end
-					cb()
-				end)
 			end
 
 			callbacks.when_done(function()
@@ -880,7 +925,7 @@ function M.hide(id, cb)
 			log("hide() you can only hide the screen at the top of the stack", id)
 			return false
 		end
-		return M.back(id, cb)
+		return M.back(nil, nil, cb)
 	else
 		log("hide() queuing action", id)
 		queue_action(function(action_done, action_error)
@@ -933,21 +978,27 @@ end
 
 
 -- Go back to the previous screen in the stack.
+-- @param options (table) - Table with options when backing out from the screen (can be nil).
+--		Valid values:
+-- 		* sequential - Set to true to wait for the current screen to hide itself out before starting the
+--				   back in transition even when transitioning to a different scene ID.
+
 -- @param data (*) - Optional data to set for the previous screen
 -- @param cb (function) - Optional callback to invoke when the previous screen is visible again
-function M.back(data, cb)
+function M.back(options, data, cb)
 	log("back() queuing action")
 
 	queue_action(function(action_done)
 		local callbacks = callback_tracker()
-		local back_cb = callbacks.track()
 		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
+			local same_screen = top and top.id == screen.id
+			if same_screen or (options and options.sequential) then
+				local back_cb = callbacks.track()
 				back_out(screen, top, WAIT_FOR_TRANSITION, function()
 					if data then
 						top.data = data
@@ -965,16 +1016,16 @@ function M.back(data, cb)
 					-- we do this to ensure that we do not reset the times step of the screen
 					-- we go back to until it is no longer obscured by the popup
 					if screen.popup and not top.popup then
+						local back_cb = callbacks.track()
 						back_out(screen, top, WAIT_FOR_TRANSITION, function()
 							back_in(top, screen, WAIT_FOR_TRANSITION, back_cb)
 						end)
 					else
-						back_in(top, screen, DO_NOT_WAIT_FOR_TRANSITION, function()
+						back_in(top, screen, WAIT_FOR_TRANSITION, callbacks.track())
-							back_out(screen, top, WAIT_FOR_TRANSITION, back_cb)
+						back_out(screen, top, WAIT_FOR_TRANSITION, callbacks.track())
-						end)
 					end
 				else
-					back_out(screen, top, WAIT_FOR_TRANSITION, back_cb)
+					back_out(screen, top, WAIT_FOR_TRANSITION, callbacks.track())
 				end
 			end
 		end
@@ -1081,6 +1132,20 @@ function M.preload(id, options, cb)
 	return true -- return true for legacy reasons (before queue existed)
 end
 
+--- Check if a screen has missing resources, always returns false for factory
+-- @param id (string|hash) - Id of the screen to preload
+function M.has_missing_resources(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]
+	if screen.proxy then
+		local missing_resources = collectionproxy.missing_resources(screen.proxy)
+		return #missing_resources > 0
+	end
+	return false
+end
 
 --- Unload a preloaded monarch screen
 -- @param id (string|hash) - Id of the screen to unload
@@ -1132,8 +1197,8 @@ end
 -- @return error (string|nil) Error message if unable to send message
 function M.post(id, message_id, message)
 	assert(id, "You must provide a screen id")
-	if not M.is_visible(id) then
+	if not M.is_loaded(id) then
-		return false, "Unable to post message to screen if it isn't visible"
+		return false, "Unable to post message to screen if it isn't loaded"
 	end
 
 	assert(message_id, "You must provide a message_id")
@@ -1141,45 +1206,39 @@ function M.post(id, message_id, message)
 	assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
 
 	local screen = screens[id]
-	if screen.proxy then
+	if screen.receiver_url then
-		if screen.receiver_url then
+		log("post() sending message to", screen.receiver_url)
-			log("post() sending message to", screen.receiver_url)
+		msg.post(screen.receiver_url, message_id, message)
-			msg.post(screen.receiver_url, message_id, message)
-		else
-			return false, "Unable to post message since screen has no receiver url specified"
-		end
 	else
-		for id,instance in pairs(screen.factory_ids) do
+		return false, "Unable to post message since screen has no receiver url specified. Set one using monarch.on_post()."
-			msg.post(instance, message_id, message)
-		end
 	end
 	return true
 end
 
 
 function M.on_message(message_id, message, sender)
-	if message_id == PROXY_LOADED then
+	if message_id == MSG_PROXY_LOADED then
 		local screen = find_screen(sender)
 		assert(screen, "Unable to find screen for loaded proxy")
-		if screen.wait_for == PROXY_LOADED then
+		if screen.wait_for == WAITFOR_PROXY_LOADED then
 			assert(coroutine.resume(screen.co))
 		end
-	elseif message_id == PROXY_UNLOADED then
+	elseif message_id == MSG_PROXY_UNLOADED then
 		local screen = find_screen(sender)
 		assert(screen, "Unable to find screen for unloaded proxy")
-		if screen.wait_for == PROXY_UNLOADED then
+		if screen.wait_for == WAITFOR_PROXY_UNLOADED then
 			assert(coroutine.resume(screen.co))
 		end
-	elseif message_id == CONTEXT then
+	elseif message_id == MSG_CONTEXT then
 		local screen = find_screen(sender)
 		assert(screen, "Unable to find screen for current script url")
-		if screen.wait_for == CONTEXT then
+		if screen.wait_for == WAITFOR_CONTEXT then
 			assert(coroutine.resume(screen.co))
 		end
 	elseif message_id == M.TRANSITION.DONE then
 		local screen = find_transition_screen(sender)
 		assert(screen, "Unable to find screen for transition")
-		if screen.wait_for == M.TRANSITION.DONE then
+		if screen.wait_for == WAITFOR_TRANSITION_DONE then
 			assert(coroutine.resume(screen.co))
 		end
 	elseif message_id == M.TRANSITION.SHOW_IN
@@ -1192,7 +1251,7 @@ function M.on_message(message_id, message, sender)
 		if screen.transition_fn then
 			screen.transition_fn(message_id, message, sender)
 		end
-	elseif message_id == LAYOUT_CHANGED then
+	elseif message_id == MSG_LAYOUT_CHANGED then
 		local screen = find_screen(sender)
 		if screen and screen.transition_fn then
 			screen.transition_fn(message_id, message, sender)
@@ -1291,24 +1350,36 @@ function M.on_focus_changed(id, fn)
 end
 
 ---
--- Set a function to call when a screen is sent a message using monarch.post()
+-- Set either a function to be called when msg.post() is called on a specific
--- The function will receive (message_id, message, sender)
+-- screen or a URL where the message is sent.
--- IMPORTANT! You must call monarch.on_message() from the same script as
+-- IMPORTANT! If you provide a function you must also make sure to call
--- this function was called
+-- monarch.on_message(message_id, message, sender) from the same script as
+-- this function was called.
 -- @param id Screen id to associate the message listener function with
--- @param fn Message listener function
+-- @param fn_or_url The function to call or URL to send message to
-function M.on_post(id, fn)
+function M.on_post(id, fn_or_url)
 	assert(id, "You must provide a screen id")
-	assert(fn, "You must provide a post receiver function")
 	id = tohash(id)
 	assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
 	local screen = screens[id]
-	screen.receiver_url = msg.url()
+
-	screen.receiver_fn = fn
+	local t = type(fn_or_url)
+	if t == "function" then
+		screen.receiver_fn = fn_or_url
+		screen.receiver_url = msg.url()
+	elseif t == "userdata" or t == "string" then
+		screen.receiver_fn = nil
+		screen.receiver_url = fn_or_url
+	else
+		screen.receiver_fn = nil
+		screen.receiver_url = msg.url()
+	end
 end
 
+local empty_hash = hash("")
+
 local function url_to_key(url)
-	return (url.socket or hash("")) .. (url.path or hash("")) .. (url.fragment or hash(""))
+	return (url.socket or empty_hash) .. (url.path or empty_hash) .. (url.fragment or empty_hash)
 end
 
 

monarch/screen_factory.script

@@ -6,8 +6,8 @@ go.property("popup", false)
 go.property("popup_on_popup", false)
 go.property("screen_keeps_input_focus_when_below_popup", false)
 go.property("others_keep_input_focus_when_below_screen", false)
-go.property("transition_id", hash(""))
+go.property("transition_id", hash("__DEPRECATED__"))
-go.property("focus_id", hash(""))
+go.property("focus_id", hash("__DEPRECATED__"))
 go.property("preload", false)
 
 
@@ -15,7 +15,7 @@ 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,

monarch/screen_proxy.script

@@ -7,9 +7,9 @@ go.property("popup_on_popup", false)
 go.property("timestep_below_popup", 1)
 go.property("screen_keeps_input_focus_when_below_popup", false)
 go.property("others_keep_input_focus_when_below_screen", false)
-go.property("transition_url", msg.url())
+go.property("transition_url", msg.url("#__DEPRECATED__"))
-go.property("focus_url", msg.url())
+go.property("focus_url", msg.url("#__DEPRECATED__"))
-go.property("receiver_url", msg.url())
+go.property("receiver_url", msg.url("#__DEPRECATED__"))
 go.property("preload", false)
 
 
@@ -19,7 +19,7 @@ function init(self)
 	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,

test.settings

@@ -0,0 +1,2 @@
+[bootstrap]
+main_collection = /test/test.collectionc

test/data/screen1.gui_script

@@ -1,5 +1,11 @@
+local monarch
+
 function init(self)
-	print("init - screen1")
+	monarch = require "monarch.monarch"
+	print("init - screen1", msg.url())
+	monarch.on_post("screen1", function(message_id, message, sender)
+		_G.screen1_on_post = message or true
+	end)
 end
 
 function final(self)
@@ -7,7 +13,8 @@ function final(self)
 end
 
 function on_message(self, message_id, message, sender)
+	monarch.on_message(message_id, message, sender)
 	if message_id == hash("foobar") then
-		_G.screen1_foobar = message or true
+		_G.screen1_on_message = message or true
 	end
 end

test/data/screen2.gui_script

@@ -1,5 +1,11 @@
+local monarch
+
 function init(self)
-	print("init - screen2")
+	monarch = require "monarch.monarch"
+	print("init - screen2", msg.url())
+	monarch.on_post("screen2", function(message_id, message, sender)
+		_G.screen2_on_post = message or true
+	end)
 end
 
 function final(self)
@@ -7,7 +13,8 @@ function final(self)
 end
 
 function on_message(self, message_id, message, sender)
+	monarch.on_message(message_id, message, sender)
 	if message_id == hash("foobar") then
-		_G.screen2_foobar = message or true
+		_G.screen2_on_message = message or true
 	end
 end

test/msg.lua

@@ -64,5 +64,17 @@ function M.last(url)
 	return messages[#messages]
 end
 
+function M.filter(url, fn)
+	local t = {}
+	local messages = M.messages(url)
+	for i=1,#messages do
+		local message = messages[i]
+		if fn(message) then
+			t[#t + 1] = message
+		end
+	end
+	return t
+end
+
 
 return M

test/test_monarch.lua

@@ -12,7 +12,6 @@ local FOCUS1 = hash("focus1")
 local BACKGROUND = hash("background")
 local POPUP1 = hash("popup1")
 local POPUP2 = hash("popup2")
-local FOOBAR = hash("foobar")
 local TRANSITION1 = hash("transition1")
 
 local function check_stack(expected_screens)
@@ -82,7 +81,7 @@ return function()
 			monarch.when_preloaded(screen_id, done)
 		end)
 	end
-		
+
 	describe("monarch", function()
 		before(function()
 			mock_msg.mock()
@@ -143,12 +142,12 @@ return function()
 			monarch.show(SCREEN1)
 			assert(wait_until_stack({ SCREEN1 }))
 			assert(wait_until_visible(SCREEN1))
-			
+
 			monarch.show(SCREEN2)
 			assert(wait_until_stack({ SCREEN1, SCREEN2 }))
 			assert(wait_until_hidden(SCREEN1))
 			assert(wait_until_visible(SCREEN2))
-			
+
 			monarch.show(POPUP1)
 			assert(wait_until_stack({ SCREEN1, SCREEN2, POPUP1 }))
 			assert(wait_until_hidden(SCREEN1))
@@ -156,6 +155,17 @@ return function()
 			assert(wait_until_visible(POPUP1))
 		end)
 
+		it("should be able to tell if a screen is loaded or not", function()
+			assert(not monarch.is_loaded(SCREEN1))
+			monarch.show(SCREEN1)
+			assert(wait_until_visible(SCREEN1))
+			assert(monarch.is_loaded(SCREEN1))
+			
+			monarch.hide(SCREEN1)
+			assert(wait_until_hidden(SCREEN1))
+			assert(not monarch.is_loaded(SCREEN1))
+		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_visible(BACKGROUND), "Background was never shown")
@@ -220,7 +230,7 @@ return function()
 			assert(monarch.data(SCREEN2) == data2, "Expected data on screen2 doesn't match actual data")
 
 			local data_back = { going = "back" }
-			monarch.back(data_back)
+			monarch.back(nil, data_back)
 			assert(wait_until_visible(SCREEN1))
 
 			assert(monarch.data(SCREEN1) == data_back, "Expected data on screen1 doesn't match actual data")
@@ -408,43 +418,37 @@ return function()
 
 			monarch.show(SCREEN1)
 			assert(wait_until_not_busy())
-			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(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_IN_STARTED)
-			assert(mock_msg.messages(URL1)[3].message.screen == SCREEN2)
-			assert(mock_msg.messages(URL1)[4].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
-			assert(mock_msg.messages(URL1)[4].message.screen == SCREEN2)
-			assert(mock_msg.messages(URL1)[5].message_id == monarch.SCREEN_TRANSITION_OUT_STARTED)
-			assert(mock_msg.messages(URL1)[5].message.screen == SCREEN1)
-			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)
+			local messages = mock_msg.filter(URL1, function(m)
-			assert(#mock_msg.messages(URL2) == 2)
+				return m.message.screen == SCREEN1
-			assert(mock_msg.messages(URL1)[7].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
+			end)
-			assert(mock_msg.messages(URL1)[7].message.screen == SCREEN1)
+			assert(messages[1].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
-			assert(mock_msg.messages(URL1)[8].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
+			assert(messages[2].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
-			assert(mock_msg.messages(URL1)[8].message.screen == SCREEN1)
+			assert(messages[3].message_id == monarch.SCREEN_TRANSITION_OUT_STARTED)
-			assert(mock_msg.messages(URL1)[9].message_id == monarch.SCREEN_TRANSITION_OUT_STARTED)
+			assert(messages[4].message_id == monarch.SCREEN_TRANSITION_OUT_FINISHED)
-			assert(mock_msg.messages(URL1)[9].message.screen == SCREEN2)
+			assert(messages[5].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
-			assert(mock_msg.messages(URL1)[10].message_id == monarch.SCREEN_TRANSITION_OUT_FINISHED)
+			assert(messages[6].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
-			assert(mock_msg.messages(URL1)[10].message.screen == SCREEN2)
+
+			messages = mock_msg.filter(URL2, function(m)
+				return m.message.screen == SCREEN1
+			end)
+			assert(messages[1].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
+			assert(messages[2].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
+			
+			messages = mock_msg.filter(URL1, function(m)
+				return m.message.screen == SCREEN2
+			end)
+			assert(messages[1].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
+			assert(messages[2].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
+			assert(messages[3].message_id == monarch.SCREEN_TRANSITION_OUT_STARTED)
+			assert(messages[4].message_id == monarch.SCREEN_TRANSITION_OUT_FINISHED)
 		end)
 		
 		it("should be able to show a screen even while it is preloading", function()
@@ -491,49 +495,56 @@ return function()
 
 
 		it("should be able to post messages without message data to visible screens", function()
-			_G.screen1_foobar = nil
+			_G.screen1_on_message = nil
-			_G.screen2_foobar = nil
+			_G.screen1_on_post = nil
+			_G.screen2_on_message = nil
+			_G.screen2_on_post = nil
 
 			-- proxy screen
 			monarch.show(SCREEN1)
 			wait_until_visible(SCREEN1)
 			assert(monarch.post(SCREEN1, "foobar"), "Expected monarch.post() to return true")
 			cowait(0.1)
-			assert(_G.screen1_foobar, "Screen1 never received a message")
+			assert(_G.screen1_on_message, "Screen1 never received a message")
+			assert(_G.screen1_on_post, "Screen1 never received a callback")
 
 			-- factory screen
 			monarch.show(SCREEN2)
 			wait_until_visible(SCREEN2)
 			assert(monarch.post(SCREEN2, "foobar"), "Expected monarch.post() to return true")
 			cowait(0.1)
-			assert(_G.screen2_foobar, "Screen2 never received a message")
+			assert(_G.screen2_on_message, "Screen2 never received a message")
+			assert(_G.screen2_on_post, "Screen2 never received a callback")
 		end)
 
 
 		it("should be able to post messages with message data to visible screens", function()
-			_G.screen1_foobar = nil
+			_G.screen1_on_message = nil
-			_G.screen2_foobar = nil
+			_G.screen1_on_post = nil
+			_G.screen2_on_message = nil
+			_G.screen2_on_post = nil
 
 			-- proxy screen
 			monarch.show(SCREEN1)
 			wait_until_visible(SCREEN1)
 			assert(monarch.post(SCREEN1, "foobar", { foo = "bar" }), "Expected monarch.post() to return true")
 			cowait(0.1)
-			assert(_G.screen1_foobar, "Screen1 never received a message")
+			assert(_G.screen1_on_message, "Screen1 never received a message")
-			assert(_G.screen1_foobar.foo == "bar", "Screen1 never received message data")
+			assert(_G.screen1_on_message.foo == "bar", "Screen1 never received message data")
-			
+
 			-- factory screen
 			monarch.show(SCREEN2)
 			wait_until_visible(SCREEN2)
 			assert(monarch.post(SCREEN2, "foobar", { foo = "bar" }), "Expected monarch.post() to return true")
 			cowait(0.1)
-			assert(_G.screen2_foobar, "Screen2 never received a message")
+			assert(_G.screen2_on_message, "Screen2 never received a message")
-			assert(_G.screen2_foobar.foo == "bar", "Screen2 never received message data")
+			assert(_G.screen2_on_message.foo == "bar", "Screen2 never received message data")
 		end)
 
 
 		it("should not be able to post messages to hidden screens", function()
-			_G.screen1_foobar = nil
+			_G.screen1_on_message = nil
+			_G.screen1_on_post = nil
 
 			monarch.show(SCREEN1)
 			monarch.show(SCREEN2)
@@ -542,7 +553,7 @@ return function()
 			local ok, err = monarch.post(SCREEN1, "foobar")
 			assert(not ok and err, "Expected monarch.post() to return false plus an error message")
 			cowait(0.1)
-			assert(not _G.screen1_foobar, "Screen1 should not have received a message")
+			assert(not _G.screen1_on_message, "Screen1 should not have received a message")
 		end)