Create LICENSE.md

Replace strings with constants / new type of transactions / information for the focus messages

.luacheckrc

@@ -0,0 +1,42 @@
+std = "max"
+files['.luacheckrc'].global = false
+unused_args = false
+
+globals = {
+  "sys",
+  "go",
+  "gui",
+  "label",
+  "render",
+  "crash",
+  "sprite",
+  "sound",
+  "tilemap",
+  "spine",
+  "particlefx",
+  "physics",
+  "factory",
+  "collectionfactory",
+  "iac",
+  "msg",
+  "vmath",
+  "url",
+  "http",
+  "image",
+  "json",
+  "zlib",
+  "iap",
+  "push",
+  "facebook",
+  "hash",
+  "hash_to_hex",
+  "pprint",
+  "init",
+  "final",
+  "update",
+  "on_input",
+  "on_message",
+  "on_reload",
+  "window",
+  "unityads"
+}

LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Björn Ritzl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -76,7 +76,7 @@ You can add optional transitions when navigating between screens. The default be
 * ```transition_show_in```
 * ```transition_show_out```
 * ```transition_back_in```
-* ``transition_back_out```
+* ```transition_back_out```
 
 When a transition is completed it is up to the developer to send a ```transition_done``` message back to the sender to indicate that the transition is completed and that Monarch can continue the navigation sequence. Monarch comes with a system for setting up transitions easily in a gui_script. Example:
 
@@ -98,20 +98,20 @@ When a transition is completed it is up to the developer to send a ```transition
 	end
 
 ## Screen focus gain/loss
-Monarch will send focus gain and focus loss messages if a Focus Url was provided when the screen was created. Example:
+Monarch will send focus gain and focus loss messages if a Focus Url was provided when the screen was created. The focus gained message will contain the id of the previous screen and the focus loss message will contain the id of the next screen. Example:
 
 	local monarch = require "monarch.monarch"
 
 	function on_message(self, message_id, message, sender)
 		if message_id == monarch.FOCUS_GAINED then
-			print("Focus gained")
+			print("Focus gained, previous screen: ", message.id)
 		elseif message_id == monarch.FOCUS_LOST then
-			print("Focus lost")
+			print("Focus lost, next screen: ", message.id)
 		end
 	end
 
 ## Callbacks
-Both the ```monarch.show()``` and ```monarch.back()``` functions take an optional callback function that will be invoked when the ```transition_show_in``` (or the ```transition_back_in``` in the case of a ```monarch.back()``` call) transition is completed. Tthe transition is considered completed when a ```transition_done``` message has been received (see section on [transitions](#transitions) above).
+Both the ```monarch.show()``` and ```monarch.back()``` functions take an optional callback function that will be invoked when the ```transition_show_in``` (or the ```transition_back_in``` in the case of a ```monarch.back()``` call) transition is completed. The transition is considered completed when a ```transition_done``` message has been received (see section on [transitions](#transitions) above).
 
 ## Monarch API
 
@@ -127,6 +127,7 @@ Show a Monarch screen
 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).
 
 ### monarch.back([data], [callback])
 Go back to a previous Monarch screen
@@ -135,6 +136,7 @@ Go back to a previous Monarch screen
 * ```data``` (table) - Optional data to associate with the screen you are going back to.  Retrieve using ```monarch.data()```.
 * ```callback``` (function) - Function to call when the previous screen is visible.
 
+
 ### monarch.data(screen_id)
 Get the data associated with a screen (from a call to ```monarch.show()``` or ```monarch.back()```).
 
@@ -143,3 +145,13 @@ Get the data associated with a screen (from a call to ```monarch.show()``` or ``
 
 **RETURN**
 * ```data``` (table) - Data associated with the screen.
+
+
+### monarch.screen_exists(screen_id)
+Check if a Monarch screen exists.
+
+**PARAMETERS**
+* ```screen_id``` (hash) - Id of the screen to get data for
+
+**RETURN**
+* ```exists``` (boolean) - True if the screen exists.

example/main.script

@@ -1,6 +1,14 @@
 local monarch = require "monarch.monarch"
 
 function init(self)
-	monarch.show(hash("menu"))
+	self.wait = true
 	msg.post("@render:/", "clear_color", { color = vmath.vector4(0.4, 0.6, 0.8,1.0) })
 end
+
+function update(self)
+	-- Ensure that the initial screen has had enough time to register
+	if self.wait == true and monarch.screen_exists(hash("menu")) then
+		self.wait = false
+		monarch.show(hash("menu"))
+	end	
+end

example/popup.gui_script

@@ -8,10 +8,10 @@ function init(self)
 	gui.set_render_order(15)
 
 	self.transition = transitions.create(gui.get_node("root"))
-		.show_in(transitions.slide_in_top, gui.EASING_OUTQUAD, 0.6, 0)
+		.show_in(transitions.scale_in, gui.EASING_OUTBACK, 0.3, 0)
-		.show_out(transitions.slide_out_top, gui.EASING_INQUAD, 0.6, 0)
+		.show_out(transitions.scale_out, gui.EASING_INBACK, 0.3, 0)
-		.back_in(transitions.slide_in_top, gui.EASING_OUTQUAD, 0.6, 0)
+		.back_in(transitions.scale_in, gui.EASING_OUTBACK, 0.3, 0)
-		.back_out(transitions.slide_out_top, gui.EASING_INQUAD, 0.6, 0)
+		.back_out(transitions.scale_out, gui.EASING_INBACK, 0.3, 0)
 end
 
 function on_input(self, action_id, action)

monarch/monarch.lua

@@ -8,9 +8,22 @@ local CONTEXT = hash("monarch_context")
 local PROXY_LOADED = hash("proxy_loaded")
 local PROXY_UNLOADED = hash("proxy_unloaded")
 
-M.TRANSITION_DONE = hash("transition_done")
+local RELEASE_INPUT_FOCUS = hash("release_input_focus")
-M.FOCUS_GAINED = hash("monarch_focus_gained")
+local ACQUIRE_INPUT_FOCUS = hash("acquire_input_focus")
-M.FOCUS_LOST = hash("monarch_focus_lost")
+local ASYNC_LOAD = hash("async_load")
+local UNLOAD = hash("unload")
+local ENABLE = hash("enable")
+
+M.TRANSITION = {}
+M.TRANSITION.DONE = hash("transition_done")
+M.TRANSITION.SHOW_IN = hash("transition_show_in")
+M.TRANSITION.SHOW_OUT = hash("transition_show_out")
+M.TRANSITION.BACK_IN = hash("transition_back_in")
+M.TRANSITION.BACK_OUT = hash("transition_back_out")
+
+M.FOCUS = {}
+M.FOCUS.GAINED = hash("monarch_focus_gained")
+M.FOCUS.LOST = hash("monarch_focus_lost")
 
 
 local function screen_from_proxy(proxy)
@@ -60,18 +73,18 @@ local function show_out(screen, next_screen, cb)
 	local co
 	co = coroutine.create(function()
 		screen.co = co
-		msg.post(screen.script, "release_input_focus")
+		msg.post(screen.script, RELEASE_INPUT_FOCUS)
 		msg.post(screen.script, CONTEXT)
 		coroutine.yield()
 		if not next_screen.popup then
-			msg.post(screen.transition_url, "transition_show_out")
+			msg.post(screen.transition_url, M.TRANSITION.SHOW_OUT)
 			coroutine.yield()
-			msg.post(screen.proxy, "unload")
+			msg.post(screen.proxy, UNLOAD)
 			coroutine.yield()
 			screen.loaded = false
 		end
 		if screen.focus_url then
-			msg.post(screen.focus_url, M.FOCUS_LOST)
+			msg.post(screen.focus_url, M.FOCUS.LOST, {id = next_screen.id})
 		end
 		screen.co = nil
 		if cb then cb() end
@@ -79,14 +92,14 @@ local function show_out(screen, next_screen, cb)
 	coroutine.resume(co)
 end
 
-local function show_in(screen, reload, cb)
+local function show_in(screen, previous_screen, reload, cb)
 	local co
 	co = coroutine.create(function()
 		screen.co = co
 		msg.post(screen.script, CONTEXT)
 		coroutine.yield()
 		if reload and screen.loaded then
-			msg.post(screen.proxy, "unload")
+			msg.post(screen.proxy, UNLOAD)
 			coroutine.yield()
 			screen.loaded = false
 		end
@@ -94,17 +107,17 @@ local function show_in(screen, reload, cb)
 		-- and the popup asked to show this screen again
 		-- in that case we shouldn't attempt to load it again
 		if not screen.loaded then
-			msg.post(screen.proxy, "async_load")
+			msg.post(screen.proxy, ASYNC_LOAD)
 			coroutine.yield()
-			msg.post(screen.proxy, "enable")
+			msg.post(screen.proxy, ENABLE)
 			screen.loaded = true
 		end
 		stack[#stack + 1] = screen
-		msg.post(screen.transition_url, "transition_show_in")
+		msg.post(screen.transition_url, M.TRANSITION.SHOW_IN)
 		coroutine.yield()
-		msg.post(screen.script, "acquire_input_focus")
+		msg.post(screen.script, ACQUIRE_INPUT_FOCUS)
 		if screen.focus_url then
-			msg.post(screen.focus_url, M.FOCUS_GAINED)
+			msg.post(screen.focus_url, M.FOCUS.GAINED, {id = previous_screen and previous_screen.id})
 		end
 		screen.co = nil
 		if cb then cb() end
@@ -119,16 +132,16 @@ local function back_in(screen, previous_screen, cb)
 		msg.post(screen.script, CONTEXT)
 		coroutine.yield()
 		if not previous_screen.popup then
-			msg.post(screen.proxy, "async_load")
+			msg.post(screen.proxy, ASYNC_LOAD)
 			coroutine.yield()
-			msg.post(screen.proxy, "enable")
+			msg.post(screen.proxy, ENABLE)
 			screen.loaded = true
-			msg.post(screen.transition_url, "transition_back_in")
+			msg.post(screen.transition_url, M.TRANSITION.BACK_IN)
 			coroutine.yield()
 		end
-		msg.post(screen.script, "acquire_input_focus")
+		msg.post(screen.script, ACQUIRE_INPUT_FOCUS)
 		if screen.focus_url then
-			msg.post(screen.focus_url, M.FOCUS_GAINED)
+			msg.post(screen.focus_url, M.FOCUS.GAINED, {id = previous_screen.id})
 		end
 		screen.co = nil
 		if cb then cb() end
@@ -136,20 +149,20 @@ local function back_in(screen, previous_screen, cb)
 	coroutine.resume(co)
 end
 
-local function back_out(screen, cb)
+local function back_out(screen, next_screen, cb)
 	local co
 	co = coroutine.create(function()
 		screen.co = co
-		msg.post(screen.script, "release_input_focus")
+		msg.post(screen.script, RELEASE_INPUT_FOCUS)
 		msg.post(screen.script, CONTEXT)
 		coroutine.yield()
-		msg.post(screen.transition_url, "transition_back_out")
+		msg.post(screen.transition_url, M.TRANSITION.BACK_OUT)
 		coroutine.yield()
-		msg.post(screen.proxy, "unload")
+		msg.post(screen.proxy, UNLOAD)
 		coroutine.yield()
 		screen.loaded = false
 		if screen.focus_url then
-			msg.post(screen.focus_url, M.FOCUS_LOST)
+			msg.post(screen.focus_url, M.FOCUS.LOST, {id = next_screen and next_screen.id})
 		end
 		screen.co = nil
 		if cb then cb() end
@@ -167,6 +180,13 @@ function M.data(id)
 	return screens[id].data
 end
 
+--- Checks to see if a screen id is registered
+-- @param id Id of the screen to check if is registered
+-- @return True or False if the screen id is registered or not
+function M.screen_exists(id)
+	return screens[id] ~= nil
+end
+
 --- Show a new screen
 -- @param id Id of the screen to show
 -- @param options Table with options when showing the screen (can be nil). Valid values:
@@ -210,7 +230,7 @@ function M.show(id, options, data, cb)
 	end
 
 	-- show screen
-	show_in(screen, options and options.reload, cb)
+	show_in(screen, top, options and options.reload, cb)
 end
 
 
@@ -220,8 +240,8 @@ end
 function M.back(data, cb)
 	local screen = table.remove(stack)
 	if screen then
-		back_out(screen, cb)
 		local top = stack[#stack]
+		back_out(screen, top, cb)
 		if top then
 			if data then
 				screen.data = data
@@ -247,7 +267,7 @@ function M.on_message(message_id, message, sender)
 		local screen = screen_from_script()
 		assert(screen, "Unable to find screen for current script url")
 		coroutine.resume(screen.co)
-	elseif message_id == M.TRANSITION_DONE then
+	elseif message_id == M.TRANSITION.DONE then
 		local screen = screen_from_script()
 		assert(screen, "Unable to find screen for current script url")
 		coroutine.resume(screen.co)

monarch/screen.script

@@ -22,11 +22,11 @@ function on_message(self, message_id, message, sender)
 		monarch.back()
 	elseif message_id == hash("back") then
 		monarch.back()
-	elseif message_id == hash("transition_show_in")
+	elseif message_id == monarch.TRANSITION.SHOW_IN
-		or message_id == hash("transition_show_out")
+		or message_id == monarch.TRANSITION.SHOW_OUT
-		or message_id == hash("transition_back_in")
+		or message_id == monarch.TRANSITION.BACK_IN
-		or message_id == hash("transition_back_out") then
+		or message_id == monarch.TRANSITION.BACK_OUT then
-		msg.post(sender, "transition_done")
+			msg.post(sender, monarch.TRANSITION.DONE)
 		else
 			monarch.on_message(message_id, message, sender)
 		end

monarch/transitions/gui.lua

@@ -1,3 +1,5 @@
+local monarch = require "monarch.monarch"
+
 local M = {}
 
 local WIDTH = tonumber(sys.get_config("display.width"))
@@ -8,32 +10,34 @@ local RIGHT = vmath.vector3(WIDTH * 2, 0, 0)
 local TOP = vmath.vector3(0, HEIGHT * 2, 0)
 local BOTTOM = vmath.vector3(0, - HEIGHT * 2, 0)
 
+local ZERO_SCALE = vmath.vector3(0, 0, 1)
+
 function M.instant(node, to, easing, duration, delay, url)
-	msg.post(url, "transition_done")
+	msg.post(url, monarch.TRANSITION.DONE)
 end
 
 local function slide_in(direction, node, to, easing, duration, delay, url)
 	local from = to + direction
 	gui.set_position(node, from)
 	gui.animate(node, gui.PROP_POSITION, to, easing, duration, delay, function()
-		msg.post(url, "transition_done")
+		msg.post(url, monarch.TRANSITION.DONE)
 	end)
 end
 
 function M.slide_in_left(node, to, easing, duration, delay, url)
-	return slide_in(LEFT, node, to, easing, duration, delay, url)
+	return slide_in(LEFT, node, to.pos, easing, duration, delay, url)
 end
 
 function M.slide_in_right(node, to, easing, duration, delay, url)
-	slide_in(RIGHT, node, to, easing, duration, delay, url)
+	slide_in(RIGHT, node, to.pos, easing, duration, delay, url)
 end
 
 function M.slide_in_top(node, to, easing, duration, delay, url)
-	slide_in(TOP, node, to, easing, duration, delay, url)
+	slide_in(TOP, node, to.pos, easing, duration, delay, url)
 end
 
 function M.slide_in_bottom(node, to, easing, duration, delay, url)
-	slide_in(BOTTOM, node, to, easing, duration, delay, url)
+	slide_in(BOTTOM, node, to.pos, easing, duration, delay, url)
 end
 
 
@@ -41,24 +45,38 @@ local function slide_out(direction, node, from, easing, duration, delay, url)
 	local to = from + direction
 	gui.set_position(node, from)
 	gui.animate(node, gui.PROP_POSITION, to, easing, duration, delay, function()
-		msg.post(url, "transition_done")
+		msg.post(url, monarch.TRANSITION.DONE)
 	end)
 end
 
 function M.slide_out_left(node, from, easing, duration, delay, url)
-	slide_out(LEFT, node, from, easing, duration, delay, url)
+	slide_out(LEFT, node, from.pos, easing, duration, delay, url)
 end
 
 function M.slide_out_right(node, from, easing, duration, delay, url)
-	slide_out(RIGHT, node, from, easing, duration, delay, url)
+	slide_out(RIGHT, node, from.pos, easing, duration, delay, url)
 end
 
 function M.slide_out_top(node, from, easing, duration, delay, url)
-	slide_out(TOP, node, from, easing, duration, delay, url)
+	slide_out(TOP, node, from.pos, easing, duration, delay, url)
 end
 
 function M.slide_out_bottom(node, from, easing, duration, delay, url)
-	slide_out(BOTTOM, node, from, easing, duration, delay, url)
+	slide_out(BOTTOM, node, from.pos, easing, duration, delay, url)
+end
+
+function M.scale_in(node, to, easing, duration, delay, url)
+	gui.set_scale(node, ZERO_SCALE)
+	gui.animate(node, gui.PROP_SCALE, to.scale, easing, duration, delay, function()
+		msg.post(url, monarch.TRANSITION.DONE)
+	end)
+end
+
+function M.scale_out(node, from, easing, duration, delay, url)
+	gui.set_scale(node, from.scale)
+	gui.animate(node, gui.PROP_SCALE, ZERO_SCALE, easing, duration, delay, function()
+		msg.post(url, monarch.TRANSITION.DONE)
+	end)
 end
 
 --- Create a transition for a node
@@ -69,13 +87,15 @@ function M.create(node)
 	local instance = {}
 
 	local transitions = {
-		[hash("transition_show_in")] = M.instant,
+		[monarch.TRANSITION.SHOW_IN] = M.instant,
-		[hash("transition_show_out")] = M.instant,
+		[monarch.TRANSITION.SHOW_OUT] = M.instant,
-		[hash("transition_back_in")] = M.instant,
+		[monarch.TRANSITION.BACK_IN] = M.instant,
-		[hash("transition_back_out")] = M.instant,
+		[monarch.TRANSITION.BACK_OUT] = M.instant,
 	}
 
-	local initial_position = gui.get_position(node)
+	local initial_data = {}
+	initial_data.pos = gui.get_position(node)
+	initial_data.scale = gui.get_scale(node)
 
 	-- Forward on_message calls here
 	function instance.handle(message_id, message, sender)
@@ -91,8 +111,8 @@ function M.create(node)
 	-- @param duration Transition duration
 	-- @param delay Transition delay
 	function instance.show_in(fn, easing, duration, delay)
-		transitions[hash("transition_show_in")] = function(url)
+		transitions[monarch.TRANSITION.SHOW_IN] = function(url)
-			fn(node, initial_position, easing, duration, delay or 0, url)
+			fn(node, initial_data, easing, duration, delay or 0, url)
 		end
 		return instance
 	end
@@ -100,8 +120,8 @@ function M.create(node)
 	-- Specify the transition function when this node is transitioned
 	-- from when showing another screen
 	function instance.show_out(fn, easing, duration, delay)
-		transitions[hash("transition_show_out")] = function(url)
+		transitions[monarch.TRANSITION.SHOW_OUT] = function(url)
-			fn(node, initial_position, easing, duration, delay or 0, url)
+			fn(node, initial_data, easing, duration, delay or 0, url)
 		end
 		return instance
 	end
@@ -109,8 +129,8 @@ function M.create(node)
 	--- Specify the transition function when this node is transitioned
 	-- to when navigating back in the screen stack
 	function instance.back_in(fn, easing, duration, delay)
-		transitions[hash("transition_back_in")] = function(url)
+		transitions[monarch.TRANSITION.BACK_IN] = function(url)
-			fn(node, initial_position, easing, duration, delay or 0, url)
+			fn(node, initial_data, easing, duration, delay or 0, url)
 		end
 		return instance
 	end
@@ -118,8 +138,8 @@ function M.create(node)
 	--- Specify the transition function when this node is transitioned
 	-- from when navigating back in the screen stack
 	function instance.back_out(fn, easing, duration, delay)
-		transitions[hash("transition_back_out")] = function(url)
+		transitions[monarch.TRANSITION.BACK_OUT] = function(url)
-			fn(node, initial_position, easing, duration, delay or 0, url)
+			fn(node, initial_data, easing, duration, delay or 0, url)
 		end
 		return instance
 	end