2013-03-10 02:39:09 +00:00
|
|
|
|
2013-05-14 14:29:06 +00:00
|
|
|
(function() {
|
|
|
|
'use strict';
|
2013-03-10 02:39:09 +00:00
|
|
|
|
2013-12-24 18:13:19 +00:00
|
|
|
Elm.fullscreen = function(module, ports) {
|
2013-05-14 14:29:06 +00:00
|
|
|
var style = document.createElement('style');
|
|
|
|
style.type = 'text/css';
|
|
|
|
style.innerHTML = "html,head,body { padding:0; margin:0; }" +
|
|
|
|
"body { font-family: calibri, helvetica, arial, sans-serif; }";
|
|
|
|
document.head.appendChild(style);
|
2013-05-21 08:03:51 +00:00
|
|
|
var container = document.createElement('div');
|
|
|
|
document.body.appendChild(container);
|
2014-01-06 06:49:04 +00:00
|
|
|
return init(ElmRuntime.Display.FULLSCREEN, container, module, ports || {});
|
2013-05-14 14:29:06 +00:00
|
|
|
};
|
|
|
|
|
2013-12-24 18:13:19 +00:00
|
|
|
Elm.embed = function(module, container, ports) {
|
2013-05-15 05:38:11 +00:00
|
|
|
var tag = container.tagName;
|
|
|
|
if (tag !== 'DIV') {
|
2013-06-03 06:46:02 +00:00
|
|
|
throw new Error('Elm.node must be given a DIV, not a ' + tag + '.');
|
|
|
|
} else if (container.hasChildNodes()) {
|
|
|
|
throw new Error('Elm.node must be given an empty DIV. No children allowed!');
|
2013-05-15 05:38:11 +00:00
|
|
|
}
|
2014-01-06 06:49:04 +00:00
|
|
|
return init(ElmRuntime.Display.COMPONENT, container, module, ports || {});
|
2013-05-14 14:29:06 +00:00
|
|
|
};
|
|
|
|
|
2013-12-24 18:13:19 +00:00
|
|
|
Elm.worker = function(module, ports) {
|
2014-01-06 06:49:04 +00:00
|
|
|
return init(ElmRuntime.Display.NONE, {}, module, ports || {});
|
2013-05-14 14:29:06 +00:00
|
|
|
};
|
|
|
|
|
2014-01-06 06:49:04 +00:00
|
|
|
function init(display, container, module, ports, moduleToReplace) {
|
2013-03-10 02:39:09 +00:00
|
|
|
// defining state needed for an instance of the Elm RTS
|
|
|
|
var inputs = [];
|
2013-05-11 20:42:45 +00:00
|
|
|
|
2013-11-18 16:22:36 +00:00
|
|
|
var updateInProgress = false;
|
2013-03-10 02:39:09 +00:00
|
|
|
function notify(id, v) {
|
2013-11-18 16:22:36 +00:00
|
|
|
if (updateInProgress) {
|
|
|
|
throw new Error(
|
|
|
|
'The notify function has been called synchronously!\n' +
|
|
|
|
'This can lead to frames being dropped.\n' +
|
|
|
|
'Definitely report this to <https://github.com/evancz/Elm/issues>\n');
|
|
|
|
}
|
|
|
|
updateInProgress = true;
|
2013-06-03 06:46:02 +00:00
|
|
|
var timestep = Date.now();
|
|
|
|
for (var i = inputs.length; i--; ) {
|
2013-11-18 16:22:36 +00:00
|
|
|
inputs[i].recv(timestep, id, v);
|
2013-06-03 06:46:02 +00:00
|
|
|
}
|
2013-11-18 16:22:36 +00:00
|
|
|
updateInProgress = false;
|
2013-03-10 02:39:09 +00:00
|
|
|
}
|
|
|
|
|
2013-06-03 06:46:02 +00:00
|
|
|
var listeners = [];
|
|
|
|
function addListener(relevantInputs, domNode, eventName, func) {
|
|
|
|
domNode.addEventListener(eventName, func);
|
|
|
|
var listener = {
|
|
|
|
relevantInputs: relevantInputs,
|
|
|
|
domNode: domNode,
|
|
|
|
eventName: eventName,
|
|
|
|
func: func
|
|
|
|
};
|
|
|
|
listeners.push(listener);
|
|
|
|
}
|
|
|
|
|
2014-01-06 06:49:04 +00:00
|
|
|
var portUses = {}
|
|
|
|
for (var key in ports) {
|
|
|
|
portUses[key] = 0;
|
|
|
|
}
|
2013-05-11 20:42:45 +00:00
|
|
|
// create the actual RTS. Any impure modules will attach themselves to this
|
2013-03-10 02:39:09 +00:00
|
|
|
// object. This permits many Elm programs to be embedded per document.
|
2013-06-03 06:46:02 +00:00
|
|
|
var elm = {
|
|
|
|
notify:notify,
|
|
|
|
node:container,
|
|
|
|
display:display,
|
|
|
|
id:ElmRuntime.guid(),
|
|
|
|
addListener:addListener,
|
2013-12-24 18:13:19 +00:00
|
|
|
inputs:inputs,
|
2014-01-06 06:49:04 +00:00
|
|
|
ports: { incoming:ports, outgoing:{}, uses:portUses }
|
2013-05-14 14:29:06 +00:00
|
|
|
};
|
2013-03-21 09:29:23 +00:00
|
|
|
|
2013-05-31 17:40:49 +00:00
|
|
|
function swap(newModule) {
|
2013-06-03 06:46:02 +00:00
|
|
|
removeListeners(listeners);
|
2013-05-31 17:40:49 +00:00
|
|
|
var div = document.createElement('div');
|
2014-01-06 06:49:04 +00:00
|
|
|
var newElm = init(display, div, newModule, ports, elm);
|
2013-06-03 07:19:48 +00:00
|
|
|
inputs = [];
|
2013-05-31 17:40:49 +00:00
|
|
|
// elm.swap = newElm.swap;
|
|
|
|
return newElm;
|
|
|
|
}
|
|
|
|
|
2013-08-04 20:27:08 +00:00
|
|
|
var Module = {};
|
|
|
|
var reportAnyErrors = function() {};
|
|
|
|
try {
|
2013-09-30 07:44:31 +00:00
|
|
|
Module = module.make(elm);
|
2014-01-06 06:49:04 +00:00
|
|
|
checkPorts(elm);
|
2013-08-04 20:27:08 +00:00
|
|
|
} catch(e) {
|
2013-08-04 21:45:04 +00:00
|
|
|
var directions = "<br/> Open the developer console for more details."
|
2014-03-02 05:04:33 +00:00
|
|
|
Module.main = Elm.Text.make(elm).leftAligned('<code>' + e.message + directions + '</code>');
|
2013-08-04 20:27:08 +00:00
|
|
|
reportAnyErrors = function() { throw e; }
|
|
|
|
}
|
2013-05-31 01:41:43 +00:00
|
|
|
inputs = ElmRuntime.filterDeadInputs(inputs);
|
2013-06-03 06:46:02 +00:00
|
|
|
filterListeners(inputs, listeners);
|
2014-01-06 06:49:04 +00:00
|
|
|
addReceivers(elm.ports.outgoing);
|
2013-05-31 17:40:49 +00:00
|
|
|
if (display !== ElmRuntime.Display.NONE) {
|
|
|
|
var graphicsNode = initGraphics(elm, Module);
|
|
|
|
}
|
|
|
|
if (typeof moduleToReplace !== 'undefined') {
|
|
|
|
ElmRuntime.swap(moduleToReplace, elm);
|
|
|
|
|
|
|
|
// rerender scene if graphics are enabled.
|
|
|
|
if (typeof graphicsNode !== 'undefined') {
|
|
|
|
graphicsNode.recv(0, true, 0);
|
|
|
|
}
|
|
|
|
}
|
2013-05-31 01:41:43 +00:00
|
|
|
|
2013-08-04 20:27:08 +00:00
|
|
|
reportAnyErrors();
|
2014-01-14 13:05:35 +00:00
|
|
|
return { swap:swap, ports:elm.ports.outgoing };
|
2013-05-31 01:41:43 +00:00
|
|
|
};
|
2013-03-10 02:39:09 +00:00
|
|
|
|
2014-01-06 06:49:04 +00:00
|
|
|
function checkPorts(elm) {
|
|
|
|
var portUses = elm.ports.uses;
|
|
|
|
for (var key in portUses) {
|
|
|
|
var uses = portUses[key]
|
|
|
|
if (uses === 0) {
|
|
|
|
throw new Error(
|
2014-01-14 13:00:19 +00:00
|
|
|
"Initialization Error: provided port '" + key +
|
|
|
|
"' to a module that does not take it as in input.\n" +
|
|
|
|
"Remove '" + key + "' from the module initialization code.");
|
2014-01-06 06:49:04 +00:00
|
|
|
} else if (uses > 1) {
|
|
|
|
throw new Error(
|
|
|
|
"Initialization Error: port '" + key +
|
|
|
|
"' has been declared multiple times in the Elm code.\n" +
|
|
|
|
"Remove declarations until there is exactly one.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-03 06:46:02 +00:00
|
|
|
function filterListeners(inputs, listeners) {
|
|
|
|
loop:
|
|
|
|
for (var i = listeners.length; i--; ) {
|
|
|
|
var listener = listeners[i];
|
|
|
|
for (var j = inputs.length; j--; ) {
|
|
|
|
if (listener.relevantInputs.indexOf(inputs[j].id) >= 0) {
|
|
|
|
continue loop;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
listener.domNode.removeEventListener(listener.eventName, listener.func);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function removeListeners(listeners) {
|
|
|
|
for (var i = listeners.length; i--; ) {
|
|
|
|
var listener = listeners[i];
|
|
|
|
listener.domNode.removeEventListener(listener.eventName, listener.func);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-04 10:41:06 +00:00
|
|
|
// add receivers for built-in ports if they are defined
|
|
|
|
function addReceivers(ports) {
|
2014-01-06 06:49:04 +00:00
|
|
|
if ('log' in ports) {
|
|
|
|
ports.log.subscribe(function(v) { console.log(v) });
|
|
|
|
}
|
|
|
|
if ('stdout' in ports) {
|
2014-01-14 10:48:58 +00:00
|
|
|
var process = process || {};
|
|
|
|
var handler = process.stdout
|
|
|
|
? function(v) { process.stdout.write(v); }
|
2014-01-06 06:49:04 +00:00
|
|
|
: function(v) { console.log(v); };
|
|
|
|
ports.stdout.subscribe(handler);
|
|
|
|
}
|
|
|
|
if ('stderr' in ports) {
|
2014-01-14 10:48:58 +00:00
|
|
|
var process = process || {};
|
|
|
|
var handler = process.stderr
|
|
|
|
? function(v) { process.stderr.write(v); }
|
2014-01-06 06:49:04 +00:00
|
|
|
: function(v) { console.log('Error:' + v); };
|
|
|
|
ports.stderr.subscribe(handler);
|
|
|
|
}
|
|
|
|
if ('title' in ports) {
|
2014-01-13 20:12:18 +00:00
|
|
|
if (typeof ports.title === 'string') {
|
|
|
|
document.title = ports.title;
|
|
|
|
} else {
|
|
|
|
ports.title.subscribe(function(v) { document.title = v; });
|
|
|
|
}
|
2014-01-06 06:49:04 +00:00
|
|
|
}
|
|
|
|
if ('redirect' in ports) {
|
|
|
|
ports.redirect.subscribe(function(v) {
|
|
|
|
if (v.length > 0) window.location = v;
|
|
|
|
});
|
|
|
|
}
|
2014-01-15 11:59:49 +00:00
|
|
|
if ('favicon' in ports) {
|
|
|
|
if (typeof ports.favicon === 'string') {
|
|
|
|
changeFavicon(ports.favicon);
|
|
|
|
} else {
|
|
|
|
ports.favicon.subscribe(changeFavicon);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
function changeFavicon(src) {
|
|
|
|
var link = document.createElement('link');
|
|
|
|
var oldLink = document.getElementById('elm-favicon');
|
|
|
|
link.id = 'elm-favicon';
|
|
|
|
link.rel = 'shortcut icon';
|
|
|
|
link.href = src;
|
|
|
|
if (oldLink) {
|
|
|
|
document.head.removeChild(oldLink);
|
|
|
|
}
|
|
|
|
document.head.appendChild(link);
|
|
|
|
}
|
2014-01-04 10:41:06 +00:00
|
|
|
}
|
|
|
|
|
2013-05-31 01:41:43 +00:00
|
|
|
function initGraphics(elm, Module) {
|
2013-05-31 17:40:49 +00:00
|
|
|
if (!('main' in Module))
|
|
|
|
throw new Error("'main' is missing! What do I display?!");
|
|
|
|
|
2013-05-31 01:41:43 +00:00
|
|
|
var signalGraph = Module.main;
|
2013-05-11 20:42:45 +00:00
|
|
|
|
2013-05-31 01:41:43 +00:00
|
|
|
// make sure the signal graph is actually a signal & extract the visual model
|
2013-09-30 07:44:31 +00:00
|
|
|
var Signal = Elm.Signal.make(elm);
|
2013-05-31 01:41:43 +00:00
|
|
|
if (!('recv' in signalGraph)) {
|
|
|
|
signalGraph = Signal.constant(signalGraph);
|
|
|
|
}
|
|
|
|
var currentScene = signalGraph.value;
|
2013-10-31 13:47:31 +00:00
|
|
|
|
2013-08-04 22:27:02 +00:00
|
|
|
// Add the currentScene to the DOM
|
2013-05-31 01:41:43 +00:00
|
|
|
var Render = ElmRuntime.use(ElmRuntime.Render.Element);
|
2013-05-31 01:52:02 +00:00
|
|
|
elm.node.appendChild(Render.render(currentScene));
|
2013-10-31 13:47:31 +00:00
|
|
|
|
2013-03-10 02:39:09 +00:00
|
|
|
// set up updates so that the DOM is adjusted as necessary.
|
2014-01-20 18:55:03 +00:00
|
|
|
var savedScene = currentScene;
|
|
|
|
function domUpdate(newScene) {
|
2013-04-19 05:25:18 +00:00
|
|
|
ElmRuntime.draw(function(_) {
|
2014-01-20 18:55:03 +00:00
|
|
|
Render.update(elm.node.firstChild, savedScene, newScene);
|
2013-09-30 08:32:27 +00:00
|
|
|
if (elm.Native.Window) elm.Native.Window.values.resizeIfNeeded();
|
2014-01-20 18:55:03 +00:00
|
|
|
savedScene = newScene;
|
2013-08-04 22:27:02 +00:00
|
|
|
});
|
2013-03-10 02:39:09 +00:00
|
|
|
}
|
2014-01-20 18:55:03 +00:00
|
|
|
var renderer = A2(Signal.lift, domUpdate, signalGraph);
|
2013-08-04 22:27:02 +00:00
|
|
|
|
|
|
|
// must check for resize after 'renderer' is created so
|
|
|
|
// that changes show up.
|
2013-09-30 08:32:27 +00:00
|
|
|
if (elm.Native.Window) elm.Native.Window.values.resizeIfNeeded();
|
2013-08-04 22:27:02 +00:00
|
|
|
|
|
|
|
return renderer;
|
2013-05-31 01:41:43 +00:00
|
|
|
}
|
2013-05-14 14:29:06 +00:00
|
|
|
|
2013-10-31 13:47:31 +00:00
|
|
|
}());
|