spiderfw 0.6.38 → 0.6.39

data/apps/core/components/public/js/jquery/jquery-ui-1.9.2/ui/i18n/jquery.ui.datepicker-it-min.js

@@ -0,0 +1,4 @@
+/* Italian initialisation for the jQuery UI date picker plugin. */
+/* Written by Antonello Pasella (antonello.pasella@gmail.com). */
+jQuery(function($){$.datepicker.regional['it']={closeText:'Chiudi',	prevText:'<Prec',nextText:'Succ>',currentText:'Oggi',monthNames:['Gennaio','Febbraio','Marzo','Aprile','Maggio','Giugno','Luglio','Agosto','Settembre','Ottobre','Novembre','Dicembre'],monthNamesShort:['Gen','Feb','Mar','Apr','Mag','Giu','Lug','Ago','Set','Ott','Nov','Dic'],dayNames:['Domenica','Lunedì','Martedì','Mercoledì','Giovedì','Venerdì','Sabato'],dayNamesShort:['Dom','Lun','Mar','Mer','Gio','Ven','Sab'],dayNamesMin:['Do','Lu','Ma','Me','Gi','Ve','Sa'],weekHeader:'Sm',dateFormat:'dd/mm/yy',firstDay:1,isRTL:false,showMonthAfterYear:false,yearSuffix:''};$.datepicker.setDefaults($.datepicker.regional['it']);
+});

data/apps/core/components/public/js/spider.js

@@ -809,6 +809,10 @@ if(!String.prototype.trim) {
   String.prototype.trim=function(){return this.replace(/^\s+|\s+$/g, '');};
 }
 
-
-
-
+/* funzione per alzare il menu laterale se piu' alto di min-height */
+if($("#spider-admin #container #sidebar #menu").length > 0){
+	var h_menu_sidebar_admin = $("#spider-admin #container #sidebar #menu").height();
+	if(h_menu_sidebar_admin > parseInt($("#spider-admin #container").css("min-height"))){
+		$("#spider-admin #container").css("min-height",(h_menu_sidebar_admin+30).toString() +"px");
+	}
+}

data/apps/core/components/public/js/tinymce/classes/AddOnManager.js

@@ -0,0 +1,265 @@
+/**
+ * AddOnManager.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class handles the loading of themes/plugins or other add-ons and their language packs.
+ *
+ * @class tinymce.AddOnManager
+ */
+define("tinymce/AddOnManager", [
+	"tinymce/dom/ScriptLoader",
+	"tinymce/util/Tools"
+], function(ScriptLoader, Tools) {
+	var each = Tools.each;
+
+	function AddOnManager() {
+		var self = this;
+
+		self.items = [];
+		self.urls = {};
+		self.lookup = {};
+	}
+
+	AddOnManager.prototype = {
+		/**
+		 * Returns the specified add on by the short name.
+		 *
+		 * @method get
+		 * @param {String} name Add-on to look for.
+		 * @return {tinymce.Theme/tinymce.Plugin} Theme or plugin add-on instance or undefined.
+		 */
+		get: function(name) {
+			if (this.lookup[name]) {
+				return this.lookup[name].instance;
+			}
+
+			return undefined;
+		},
+
+		dependencies: function(name) {
+			var result;
+
+			if (this.lookup[name]) {
+				result = this.lookup[name].dependencies;
+			}
+
+			return result || [];
+		},
+
+		/**
+		 * Loads a language pack for the specified add-on.
+		 *
+		 * @method requireLangPack
+		 * @param {String} name Short name of the add-on.
+		 * @param {String} languages Optional comma or space separated list of languages to check if it matches the name.
+		 */
+		requireLangPack: function(name, languages) {
+			var language = AddOnManager.language;
+
+			if (language && AddOnManager.languageLoad !== false) {
+				if (languages) {
+					languages = ',' + languages + ',';
+
+					// Load short form sv.js or long form sv_SE.js
+					if (languages.indexOf(',' + language.substr(0, 2) + ',') != -1) {
+						language = language.substr(0, 2);
+					} else if (languages.indexOf(',' + language + ',') == -1) {
+						return;
+					}
+				}
+
+				ScriptLoader.ScriptLoader.add(this.urls[name] + '/langs/' + language + '.js');
+			}
+		},
+
+		/**
+		 * Adds a instance of the add-on by it's short name.
+		 *
+		 * @method add
+		 * @param {String} id Short name/id for the add-on.
+		 * @param {tinymce.Theme/tinymce.Plugin} addOn Theme or plugin to add.
+		 * @return {tinymce.Theme/tinymce.Plugin} The same theme or plugin instance that got passed in.
+		 * @example
+		 * // Create a simple plugin
+		 * tinymce.create('tinymce.plugins.TestPlugin', {
+		 *   TestPlugin: function(ed, url) {
+		 *   ed.on('click', function(e) {
+		 *      ed.windowManager.alert('Hello World!');
+		 *   });
+		 *   }
+		 * });
+		 *
+		 * // Register plugin using the add method
+		 * tinymce.PluginManager.add('test', tinymce.plugins.TestPlugin);
+		 *
+		 * // Initialize TinyMCE
+		 * tinymce.init({
+		 *  ...
+		 *  plugins: '-test' // Init the plugin but don't try to load it
+		 * });
+		 */
+		add: function(id, addOn, dependencies) {
+			this.items.push(addOn);
+			this.lookup[id] = {instance: addOn, dependencies: dependencies};
+
+			return addOn;
+		},
+
+		createUrl: function(baseUrl, dep) {
+			if (typeof dep === "object") {
+				return dep;
+			}
+
+			return {prefix: baseUrl.prefix, resource: dep, suffix: baseUrl.suffix};
+		},
+
+		/**
+		 * Add a set of components that will make up the add-on. Using the url of the add-on name as the base url.
+		 * This should be used in development mode.  A new compressor/javascript munger process will ensure that the
+		 * components are put together into the plugin.js file and compressed correctly.
+		 *
+		 * @method addComponents
+		 * @param {String} pluginName name of the plugin to load scripts from (will be used to get the base url for the plugins).
+		 * @param {Array} scripts Array containing the names of the scripts to load.
+		 */
+		addComponents: function(pluginName, scripts) {
+			var pluginUrl = this.urls[pluginName];
+
+			each(scripts, function(script) {
+				ScriptLoader.ScriptLoader.add(pluginUrl + "/" + script);
+			});
+		},
+
+		/**
+		 * Loads an add-on from a specific url.
+		 *
+		 * @method load
+		 * @param {String} name Short name of the add-on that gets loaded.
+		 * @param {String} addOnUrl URL to the add-on that will get loaded.
+		 * @param {function} callback Optional callback to execute ones the add-on is loaded.
+		 * @param {Object} scope Optional scope to execute the callback in.
+		 * @example
+		 * // Loads a plugin from an external URL
+		 * tinymce.PluginManager.load('myplugin', '/some/dir/someplugin/plugin.js');
+		 *
+		 * // Initialize TinyMCE
+		 * tinymce.init({
+		 *  ...
+		 *  plugins: '-myplugin' // Don't try to load it again
+		 * });
+		 */
+		load: function(name, addOnUrl, callback, scope) {
+			var self = this, url = addOnUrl;
+
+			function loadDependencies() {
+				var dependencies = self.dependencies(name);
+
+				each(dependencies, function(dep) {
+					var newUrl = self.createUrl(addOnUrl, dep);
+
+					self.load(newUrl.resource, newUrl, undefined, undefined);
+				});
+
+				if (callback) {
+					if (scope) {
+						callback.call(scope);
+					} else {
+						callback.call(ScriptLoader);
+					}
+				}
+			}
+
+			if (self.urls[name]) {
+				return;
+			}
+
+			if (typeof addOnUrl === "object") {
+				url = addOnUrl.prefix + addOnUrl.resource + addOnUrl.suffix;
+			}
+
+			if (url.indexOf('/') !== 0 && url.indexOf('://') == -1) {
+				url = AddOnManager.baseURL + '/' + url;
+			}
+
+			self.urls[name] = url.substring(0, url.lastIndexOf('/'));
+
+			if (self.lookup[name]) {
+				loadDependencies();
+			} else {
+				ScriptLoader.ScriptLoader.add(url, loadDependencies, scope);
+			}
+		}
+	};
+
+	AddOnManager.PluginManager = new AddOnManager();
+	AddOnManager.ThemeManager = new AddOnManager();
+
+	return AddOnManager;
+});
+
+/**
+ * TinyMCE theme class.
+ *
+ * @class tinymce.Theme
+ */
+
+/**
+ * This method is responsible for rendering/generating the overall user interface with toolbars, buttons, iframe containers etc.
+ *
+ * @method renderUI
+ * @param {Object} obj Object parameter containing the targetNode DOM node that will be replaced visually with an editor instance.
+ * @return {Object} an object with items like iframeContainer, editorContainer, sizeContainer, deltaWidth, deltaHeight.
+ */
+
+/**
+ * Plugin base class, this is a pseudo class that describes how a plugin is to be created for TinyMCE. The methods below are all optional.
+ *
+ * @class tinymce.Plugin
+ * @example
+ * tinymce.PluginManager.add('example', function(editor, url) {
+ *     // Add a button that opens a window
+ *     editor.addButton('example', {
+ *         text: 'My button',
+ *         icon: false,
+ *         onclick: function() {
+ *             // Open window
+ *             editor.windowManager.open({
+ *                 title: 'Example plugin',
+ *                 body: [
+ *                     {type: 'textbox', name: 'title', label: 'Title'}
+ *                 ],
+ *                 onsubmit: function(e) {
+ *                     // Insert content when the window form is submitted
+ *                     editor.insertContent('Title: ' + e.data.title);
+ *                 }
+ *             });
+ *         }
+ *     });
+ *
+ *     // Adds a menu item to the tools menu
+ *     editor.addMenuItem('example', {
+ *         text: 'Example plugin',
+ *         context: 'tools',
+ *         onclick: function() {
+ *             // Open window with a specific url
+ *             editor.windowManager.open({
+ *                 title: 'TinyMCE site',
+ *                 url: 'http://www.tinymce.com',
+ *                 width: 800,
+ *                 height: 600,
+ *                 buttons: [{
+ *                     text: 'Close',
+ *                     onclick: 'close'
+ *                 }]
+ *             });
+ *         }
+ *     });
+ * });
+ */

data/apps/core/components/public/js/tinymce/classes/Compat.js

@@ -0,0 +1,90 @@
+/**
+ * Compat.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * TinyMCE core class.
+ *
+ * @static
+ * @class tinymce
+ * @borrow-members tinymce.EditorManager
+ * @borrow-members tinymce.util.Tools
+ */
+define("tinymce/Compat", [
+	"tinymce/dom/DOMUtils",
+	"tinymce/dom/EventUtils",
+	"tinymce/dom/ScriptLoader",
+	"tinymce/AddOnManager",
+	"tinymce/util/Tools",
+	"tinymce/Env"
+], function(DOMUtils, EventUtils, ScriptLoader, AddOnManager, Tools, Env) {
+	var tinymce = window.tinymce;
+
+	/**
+	 * @property {tinymce.dom.DOMUtils} DOM Global DOM instance.
+	 * @property {tinymce.dom.ScriptLoader} ScriptLoader Global ScriptLoader instance.
+	 * @property {tinymce.AddOnManager} PluginManager Global PluginManager instance.
+	 * @property {tinymce.AddOnManager} ThemeManager Global ThemeManager instance.
+	 */
+	tinymce.DOM = DOMUtils.DOM;
+	tinymce.ScriptLoader = ScriptLoader.ScriptLoader;
+	tinymce.PluginManager = AddOnManager.PluginManager;
+	tinymce.ThemeManager = AddOnManager.ThemeManager;
+
+	tinymce.dom = tinymce.dom || {};
+	tinymce.dom.Event = EventUtils.Event;
+
+	Tools.each(Tools, function(func, key) {
+		tinymce[key] = func;
+	});
+
+	Tools.each('isOpera isWebKit isIE isGecko isMac'.split(' '), function(name) {
+		tinymce[name] = Env[name.substr(2).toLowerCase()];
+	});
+
+	return {};
+});
+
+// Describe the different namespaces
+
+/**
+ * Root level namespace this contains classes directly related to the TinyMCE editor.
+ *
+ * @namespace tinymce
+ */
+
+/**
+ * Contains classes for handling the browsers DOM.
+ *
+ * @namespace tinymce.dom
+ */
+
+/**
+ * Contains html parser and serializer logic.
+ *
+ * @namespace tinymce.html
+ */
+
+/**
+ * Contains the different UI types such as buttons, listboxes etc.
+ *
+ * @namespace tinymce.ui
+ */
+
+/**
+ * Contains various utility classes such as json parser, cookies etc.
+ *
+ * @namespace tinymce.util
+ */
+
+/**
+ * Contains modules to handle data binding.
+ *
+ * @namespace tinymce.data
+ */

data/apps/core/components/public/js/tinymce/classes/DragDropOverrides.js

@@ -0,0 +1,224 @@
+/**
+ * DragDropOverrides.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This module contains logic overriding the drag/drop logic of the editor.
+ *
+ * @private
+ * @class tinymce.DragDropOverrides
+ */
+define("tinymce/DragDropOverrides", [
+	"tinymce/dom/NodeType",
+	"tinymce/util/Arr",
+	"tinymce/util/Fun"
+], function(
+	NodeType,
+	Arr,
+	Fun
+) {
+	var isContentEditableFalse = NodeType.isContentEditableFalse,
+		isContentEditableTrue = NodeType.isContentEditableTrue;
+
+	function init(editor) {
+		var $ = editor.$, rootDocument = document,
+			editableDoc = editor.getDoc(),
+			dom = editor.dom, state = {};
+
+		function isDraggable(elm) {
+			return isContentEditableFalse(elm);
+		}
+
+		function setBodyCursor(cursor) {
+			$(editor.getBody()).css('cursor', cursor);
+		}
+
+		function isValidDropTarget(elm) {
+			if (elm == state.element || editor.dom.isChildOf(elm, state.element)) {
+				return false;
+			}
+
+			if (isContentEditableFalse(elm)) {
+				return false;
+			}
+
+			return true;
+		}
+
+		function move(e) {
+			var deltaX, deltaY, pos, viewPort,
+				overflowX = 0, overflowY = 0, movement,
+				clientX, clientY, rootClientRect;
+
+			if (e.button !== 0) {
+				return;
+			}
+
+			deltaX = e.screenX - state.screenX;
+			deltaY = e.screenY - state.screenY;
+			movement = Math.max(Math.abs(deltaX), Math.abs(deltaY));
+
+			if (!state.dragging && movement > 10) {
+				state.dragging = true;
+				setBodyCursor('default');
+
+				state.clone = state.element.cloneNode(true);
+
+				pos = dom.getPos(state.element);
+				state.relX = state.clientX - pos.x;
+				state.relY = state.clientY - pos.y;
+				state.width = state.element.offsetWidth;
+				state.height = state.element.offsetHeight;
+
+				$(state.clone).css({
+					width: state.width,
+					height: state.height
+				}).removeAttr('data-mce-selected');
+
+				state.ghost = $('<div>').css({
+					position: 'absolute',
+					opacity: 0.5,
+					overflow: 'hidden',
+					width: state.width,
+					height: state.height
+				}).attr({
+					'data-mce-bogus': 'all',
+					unselectable: 'on',
+					contenteditable: 'false'
+				}).addClass('mce-drag-container mce-reset').
+					append(state.clone).
+					appendTo(editor.getBody())[0];
+
+				viewPort = editor.dom.getViewPort(editor.getWin());
+				state.maxX = viewPort.w;
+				state.maxY = viewPort.h;
+			}
+
+			if (state.dragging) {
+				editor.selection.placeCaretAt(e.clientX, e.clientY);
+
+				clientX = state.clientX + deltaX - state.relX;
+				clientY = state.clientY + deltaY + 5;
+
+				if (clientX + state.width > state.maxX) {
+					overflowX = (clientX + state.width) - state.maxX;
+				}
+
+				if (clientY + state.height > state.maxY) {
+					overflowY = (clientY + state.height) - state.maxY;
+				}
+
+				if (editor.getBody().nodeName != 'BODY') {
+					rootClientRect = editor.getBody().getBoundingClientRect();
+				} else {
+					rootClientRect = {left: 0, top: 0};
+				}
+
+				$(state.ghost).css({
+					left: clientX - rootClientRect.left,
+					top: clientY - rootClientRect.top,
+					width: state.width - overflowX,
+					height: state.height - overflowY
+				});
+			}
+		}
+
+		function drop() {
+			var evt;
+
+			if (state.dragging) {
+				// Hack for IE since it doesn't sync W3C Range with IE Specific range
+				editor.selection.setRng(editor.selection.getSel().getRangeAt(0));
+
+				if (isValidDropTarget(editor.selection.getNode())) {
+					var targetClone = state.element;
+
+					evt = editor.fire('drop', {targetClone: targetClone});
+					if (evt.isDefaultPrevented()) {
+						return;
+					}
+
+					targetClone = evt.targetClone;
+
+					editor.undoManager.transact(function() {
+						editor.insertContent(dom.getOuterHTML(targetClone));
+						$(state.element).remove();
+					});
+				}
+			}
+
+			stop();
+		}
+
+		function start(e) {
+			var ceElm, evt;
+
+			stop();
+
+			if (e.button !== 0) {
+				return;
+			}
+
+			ceElm = Arr.find(editor.dom.getParents(e.target), Fun.or(isContentEditableFalse, isContentEditableTrue));
+
+			if (isDraggable(ceElm)) {
+				evt = editor.fire('dragstart', {target: ceElm});
+				if (evt.isDefaultPrevented()) {
+					return;
+				}
+
+				editor.on('mousemove', move);
+				editor.on('mouseup', drop);
+
+				if (rootDocument != editableDoc) {
+					dom.bind(rootDocument, 'mousemove', move);
+					dom.bind(rootDocument, 'mouseup', drop);
+				}
+
+				state = {
+					screenX: e.screenX,
+					screenY: e.screenY,
+					clientX: e.clientX,
+					clientY: e.clientY,
+					element: ceElm
+				};
+			}
+		}
+
+		function stop() {
+			$(state.ghost).remove();
+			setBodyCursor(null);
+
+			editor.off('mousemove', move);
+			editor.off('mouseup', stop);
+
+			if (rootDocument != editableDoc) {
+				dom.unbind(rootDocument, 'mousemove', move);
+				dom.unbind(rootDocument, 'mouseup', stop);
+			}
+
+			state = {};
+		}
+
+		editor.on('mousedown', start);
+
+		// Blocks drop inside cE=false on IE
+		editor.on('drop', function(e) {
+			var realTarget = editor.getDoc().elementFromPoint(e.clientX, e.clientY);
+
+			if (isContentEditableFalse(realTarget) || isContentEditableFalse(editor.dom.getContentEditableParent(realTarget))) {
+				e.preventDefault();
+			}
+		});
+	}
+
+	return {
+		init: init
+	};
+});