<!DOCTYPE html> <script>(function() { // If window.HTMLWidgets is already defined, then use it; otherwise create a // new object. This allows preceding code to set options that affect the // initialization process (though none currently exist). window.HTMLWidgets = window.HTMLWidgets || {}; // See if we’re running in a viewer pane. If not, we’re in a web browser. var viewerMode = window.HTMLWidgets.viewerMode = /bviewer_pane=1b/.test(window.location); // See if we’re running in Shiny mode. If not, it’s a static document. // Note that static widgets can appear in both Shiny and static modes, but // obviously, Shiny widgets can only appear in Shiny apps/documents. var shinyMode = window.HTMLWidgets.shinyMode = typeof(window.Shiny) !== “undefined” && !!window.Shiny.outputBindings; // We can’t count on jQuery being available, so we implement our own // version if necessary. function querySelectorAll(scope, selector) { if (typeof(jQuery) !== “undefined” && scope instanceof jQuery) { return scope.find(selector); } if (scope.querySelectorAll) { return scope.querySelectorAll(selector); } } function asArray(value) { if (value === null) return []; if ($.isArray(value)) return value; return [value]; } // Implement jQuery’s extend function extend(target /*, … */) { if (arguments.length == 1) { return target; } for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var prop in source) { if (source.hasOwnProperty(prop)) { target[prop] = source[prop]; } } } return target; } // IE8 doesn’t support Array.forEach. function forEach(values, callback, thisArg) { if (values.forEach) { values.forEach(callback, thisArg); } else { for (var i = 0; i < values.length; i++) { callback.call(thisArg, values[i], i, values); } } } // Replaces the specified method with the return value of funcSource. // // Note that funcSource should not BE the new method, it should be a function // that RETURNS the new method. funcSource receives a single argument that is // the overridden method, it can be called from the new method. The overridden // method can be called like a regular function, it has the target permanently // bound to it so “this” will work correctly. function overrideMethod(target, methodName, funcSource) { var superFunc = target[methodName] || function() {}; var superFuncBound = function() { return superFunc.apply(target, arguments); }; target[methodName] = funcSource(superFuncBound); } // Add a method to delegator that, when invoked, calls // delegatee.methodName. If there is no such method on // the delegatee, but there was one on delegator before // delegateMethod was called, then the original version // is invoked instead. // For example: // // var a = { // method1: function() { console.log(‘a1’); } // method2: function() { console.log(‘a2’); } // }; // var b = { // method1: function() { console.log(‘b1’); } // }; // delegateMethod(a, b, “method1”); // delegateMethod(a, b, “method2”); // a.method1(); // a.method2(); // // The output would be “b1”, “a2”. function delegateMethod(delegator, delegatee, methodName) { var inherited = delegator[methodName]; delegator[methodName] = function() { var target = delegatee; var method = delegatee[methodName]; // The method doesn’t exist on the delegatee. Instead, // call the method on the delegator, if it exists. if (!method) { target = delegator; method = inherited; } if (method) { return method.apply(target, arguments); } }; } // Implement a vague facsimilie of jQuery’s data method function elementData(el, name, value) { if (arguments.length == 2) { return el[“htmlwidget_data_” + name]; } else if (arguments.length == 3) { el[“htmlwidget_data_” + name] = value; return el; } else { throw new Error(“Wrong number of arguments for elementData: ” + arguments.length); } } // http://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex function escapeRegExp(str) { return str.replace(/[-[]/{}()*+?.\^$|]/g, “\$&”); } function hasClass(el, className) { var re = new RegExp(“\b” + escapeRegExp(className) + “\b”); return re.test(el.className); } // elements – array (or array-like object) of HTML elements // className – class name to test for // include – if true, only return elements with given className; // if false, only return elements *without* given className function filterByClass(elements, className, include) { var results = []; for (var i = 0; i < elements.length; i++) { if (hasClass(elements[i], className) == include) results.push(elements[i]); } return results; } function on(obj, eventName, func) { if (obj.addEventListener) { obj.addEventListener(eventName, func, false); } else if (obj.attachEvent) { obj.attachEvent(eventName, func); } } function off(obj, eventName, func) { if (obj.removeEventListener) obj.removeEventListener(eventName, func, false); else if (obj.detachEvent) { obj.detachEvent(eventName, func); } } // Translate array of values to top/right/bottom/left, as usual with // the “padding” CSS property // https://developer.mozilla.org/en-US/docs/Web/CSS/padding function unpackPadding(value) { if (typeof(value) === “number”) value = [value]; if (value.length === 1) { return {top: value[0], right: value[0], bottom: value[0], left: value[0]}; } if (value.length === 2) { return {top: value[0], right: value[1], bottom: value[0], left: value[1]}; } if (value.length === 3) { return {top: value[0], right: value[1], bottom: value[2], left: value[1]}; } if (value.length === 4) { return {top: value[0], right: value[1], bottom: value[2], left: value[3]}; } } // Convert an unpacked padding object to a CSS value function paddingToCss(paddingObj) { return paddingObj.top + “px ” + paddingObj.right + “px ” + paddingObj.bottom + “px ” + paddingObj.left + “px”; } // Makes a number suitable for CSS function px(x) { if (typeof(x) === “number”) return x + “px”; else return x; } // Retrieves runtime widget sizing information for an element. // The return value is either null, or an object with fill, padding, // defaultWidth, defaultHeight fields. function sizingPolicy(el) { var sizingEl = document.querySelector(“script[data-for=”” + el.id + “”][type=”application/htmlwidget-sizing”]”); if (!sizingEl) return null; var sp = JSON.parse(sizingEl.textContent || sizingEl.text || “{}”); if (viewerMode) { return sp.viewer; } else { return sp.browser; } } // @param tasks Array of strings (or falsy value, in which case no-op). // Each element must be a valid JavaScript expression that yields a // function. Or, can be an array of objects with “code” and “data” // properties; in this case, the “code” property should be a string // of JS that’s an expr that yields a function, and “data” should be // an object that will be added as an additional argument when that // function is called. // @param target The object that will be “this” for each function // execution. // @param args Array of arguments to be passed to the functions. (The // same arguments will be passed to all functions.) function evalAndRun(tasks, target, args) { if (tasks) { forEach(tasks, function(task) { var theseArgs = args; if (typeof(task) === “object”) { theseArgs = theseArgs.concat([task.data]); task = task.code; } var taskFunc = tryEval(task); if (typeof(taskFunc) !== “function”) { throw new Error(“Task must be a function! Source:n” + task); } taskFunc.apply(target, theseArgs); }); } } // Attempt eval() both with and without enclosing in parentheses. // Note that enclosing coerces a function declaration into // an expression that eval() can parse // (otherwise, a SyntaxError is thrown) function tryEval(code) { var result = null; try { result = eval(“(” + code + “)”); } catch(error) { if (!(error instanceof SyntaxError)) { throw error; } try { result = eval(code); } catch(e) { if (e instanceof SyntaxError) { throw error; } else { throw e; } } } return result; } function initSizing(el) { var sizing = sizingPolicy(el); if (!sizing) return; var cel = document.getElementById(“htmlwidget_container”); if (!cel) return; if (typeof(sizing.padding) !== “undefined”) { document.body.style.margin = “0”; document.body.style.padding = paddingToCss(unpackPadding(sizing.padding)); } if (sizing.fill) { document.body.style.overflow = “hidden”; document.body.style.width = “100%”; document.body.style.height = “100%”; document.documentElement.style.width = “100%”; document.documentElement.style.height = “100%”; cel.style.position = “absolute”; var pad = unpackPadding(sizing.padding); cel.style.top = pad.top + “px”; cel.style.right = pad.right + “px”; cel.style.bottom = pad.bottom + “px”; cel.style.left = pad.left + “px”; el.style.width = “100%”; el.style.height = “100%”; return { getWidth: function() { return cel.getBoundingClientRect().width; }, getHeight: function() { return cel.getBoundingClientRect().height; } }; } else { el.style.width = px(sizing.width); el.style.height = px(sizing.height); return { getWidth: function() { return cel.getBoundingClientRect().width; }, getHeight: function() { return cel.getBoundingClientRect().height; } }; } } // Default implementations for methods var defaults = { find: function(scope) { return querySelectorAll(scope, “.” + this.name); }, renderError: function(el, err) { var $el = $(el); this.clearError(el); // Add all these error classes, as Shiny does var errClass = “shiny-output-error”; if (err.type !== null) { // use the classes of the error condition as CSS class names errClass = errClass + ” ” + $.map(asArray(err.type), function(type) { return errClass + “-” + type; }).join(” “); } errClass = errClass + ” htmlwidgets-error”; // Is el inline or block? If inline or inline-block, just display:none it // and add an inline error. var display = $el.css(“display”); $el.data(“restore-display-mode”, display); if (display === “inline” || display === “inline-block”) { $el.hide(); if (err.message !== “”) { var errorSpan = $(“<span>”).addClass(errClass); errorSpan.text(err.message); $el.after(errorSpan); } } else if (display === “block”) { // If block, add an error just after the el, set visibility:none on the // el, and position the error to be on top of the el. // Mark it with a unique ID and CSS class so we can remove it later. $el.css(“visibility”, “hidden”); if (err.message !== “”) { var errorDiv = $(“<div>”).addClass(errClass).css(“position”, “absolute”) .css(“top”, el.offsetTop) .css(“left”, el.offsetLeft) // setting width can push out the page size, forcing otherwise // unnecessary scrollbars to appear and making it impossible for // the element to shrink; so use max-width instead .css(“maxWidth”, el.offsetWidth) .css(“height”, el.offsetHeight); errorDiv.text(err.message); $el.after(errorDiv); // Really dumb way to keep the size/position of the error in sync with // the parent element as the window is resized or whatever. var intId = setInterval(function() { if (!errorDiv[0].parentElement) { clearInterval(intId); return; } errorDiv .css(“top”, el.offsetTop) .css(“left”, el.offsetLeft) .css(“maxWidth”, el.offsetWidth) .css(“height”, el.offsetHeight); }, 500); } } }, clearError: function(el) { var $el = $(el); var display = $el.data(“restore-display-mode”); $el.data(“restore-display-mode”, null); if (display === “inline” || display === “inline-block”) { if (display) $el.css(“display”, display); $(el.nextSibling).filter(“.htmlwidgets-error”).remove(); } else if (display === “block”){ $el.css(“visibility”, “inherit”); $(el.nextSibling).filter(“.htmlwidgets-error”).remove(); } }, sizing: {} }; // Called by widget bindings to register a new type of widget. The definition // object can contain the following properties: // – name (required) – A string indicating the binding name, which will be // used by default as the CSS classname to look for. // – initialize (optional) – A function(el) that will be called once per // widget element; if a value is returned, it will be passed as the third // value to renderValue. // – renderValue (required) – A function(el, data, initValue) that will be // called with data. Static contexts will cause this to be called once per // element; Shiny apps will cause this to be called multiple times per // element, as the data changes. window.HTMLWidgets.widget = function(definition) { if (!definition.name) { throw new Error(“Widget must have a name”); } if (!definition.type) { throw new Error(“Widget must have a type”); } // Currently we only support output widgets if (definition.type !== “output”) { throw new Error(“Unrecognized widget type ‘” + definition.type + “‘”); } // TODO: Verify that .name is a valid CSS classname // Support new-style instance-bound definitions. Old-style class-bound // definitions have one widget “object” per widget per type/class of // widget; the renderValue and resize methods on such widget objects // take el and instance arguments, because the widget object can’t //… Más contenido para leer: Nokia amplía las aplicaciones de vanguardia industrial para acelerar la transición a la Industria 4.0
