gnuside-aloha-rails 0.23.3

data/vendor/assets/javascripts/aloha/plugins/common/contenthandler/lib/genericcontenthandler.js

@@ -0,0 +1,359 @@
+/* genericcontenthandler.js is part of Aloha Editor project http://aloha-editor.org
+ *
+ * Aloha Editor is a WYSIWYG HTML5 inline editing library and editor.
+ * Copyright (c) 2010-2012 Gentics Software GmbH, Vienna, Austria.
+ * Contributors http://aloha-editor.org/contribution.php
+ *
+ * Aloha Editor is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or any later version.
+ *
+ * Aloha Editor is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * As an additional permission to the GNU GPL version 2, you may distribute
+ * non-source (e.g., minimized or compacted) forms of the Aloha-Editor
+ * source code without the copy of the GNU GPL normally required,
+ * provided you include this license notice and a URL through which
+ * recipients can access the Corresponding Source.
+ */
+define([
+	'jquery',
+	'aloha',
+	'aloha/contenthandlermanager',
+	'contenthandler/contenthandler-utils'
+], function (
+	$,
+	Aloha,
+	Manager,
+	Utils
+) {
+	'use strict';
+
+	/**
+	 * Tags used for semantic formatting
+	 * @type {Array.<String>}
+	 * @see GenericContentHandler#transformFormattings
+	 */
+	var formattingTags = ['strong', 'em', 's', 'u', 'strike'];
+
+	/**
+	 * Checks whether the markup describes a paragraph that is propped by
+	 * a <br> tag but is otherwise empty.
+	 * 
+	 * Will return true for:
+	 *
+	 * <p id="foo"><br class="bar" /></p>
+	 *
+	 * as well as:
+	 *
+	 * <p><br></p>
+	 *
+	 * @param {string} html Markup
+	 * @return {boolean} True if html describes a propped paragraph.
+	 */
+	function isProppedParagraph(html) {
+		var trimmed = $.trim(html);
+		if (!trimmed) {
+			return false;
+		}
+		var node = $('<div>' + trimmed + '</div>')[0];
+		var containsSingleP = node.firstChild === node.lastChild
+		    && 'p' === node.firstChild.nodeName.toLowerCase();
+		if (containsSingleP) {
+			var kids = node.firstChild.children;
+			return (kids && 1 === kids.length &&
+					'br' === kids[0].nodeName.toLowerCase());
+		}
+		return false;
+	}
+
+
+	/**
+	 * Transforms all tables in the given content to make them ready to for
+	 * use with Aloha's table handling.
+	 *
+	 * Cleans tables of their unwanted attributes.
+	 * Normalizes table cells.
+	 *
+	 * @param {jQuery.<HTMLElement>} $content
+	 */
+	function prepareTables($content) {
+		// Because Aloha does not provide a way for the editor to
+		// manipulate borders, cellspacing, cellpadding in tables.
+		// @todo what about width, height?
+		$content.find('table')
+			.removeAttr('cellpadding')
+			.removeAttr('cellspacing')
+			.removeAttr('border')
+			.removeAttr('border-top')
+			.removeAttr('border-bottom')
+			.removeAttr('border-left')
+			.removeAttr('border-right');
+
+		$content.find('td').each(function () {
+			var td = this;
+
+			// Because cells with a single empty <p> are rendered to appear
+			// like empty cells, it simplifies the handeling of cells to
+			// normalize these table cells to contain actual white space
+			// instead.
+			if (isProppedParagraph(td.innerHTML)) {
+				td.innerHTML = '&nbsp;';
+			}
+
+			// Because a single <p> wrapping the contents of a <td> is
+			// initially superfluous and should be stripped out.
+			var $p = $('>p', td);
+			if (1 === $p.length) {
+				$p.contents().unwrap();
+			}
+		});
+
+		// Because Aloha does not provide a means for editors to manipulate
+		// these properties.
+		$content.find('td,tr')
+			.removeAttr('width')
+			.removeAttr('height')
+			.removeAttr('valign');
+
+		// Because Aloha table handling simply does not regard colgroups.
+		// @TODO Use sanitize.js?
+		$content.find('colgroup').remove();
+	}
+	
+	/**
+	 * Return true if the nodeType is allowed in the settings,
+	 * Aloha.settings.contentHandler.allows.elements
+	 * 
+	 * @param {String} nodeType	The tag name of the element to evaluate
+	 * 
+	 * @return {Boolean}
+	 */
+	function isAllowedNodeName(nodeType){
+		return !!(
+			Aloha.settings.contentHandler
+			&& Aloha.settings.contentHandler.allows
+			&& Aloha.settings.contentHandler.allows.elements
+			&& ($.inArray(
+		              nodeType.toLowerCase(), 
+				      Aloha.settings.contentHandler.allows.elements
+				         ) !== -1
+			   )
+		);
+	}
+
+	var GenericContentHandler = Manager.createHandler({
+
+		/**
+		 * Transforms pasted content to make it safe and ready to be used in
+		 * Aloha Editables.
+		 *
+		 * @param {jQuery.<HTMLElement>|string} content
+		 * @return {string} Clean HTML
+		 */
+		handleContent: function (content) {
+			var $content = Utils.wrapContent(content);
+			if (!$content) {
+				return content;
+			}
+
+			// If an aloha-block is found inside the pasted content, no modify
+			// should be made in the pasted content because it can be assumed
+			// this is content deliberately placed by Aloha and should not be
+			// cleaned.
+			if ($content.find('.aloha-block').length) {
+				return $content.html();
+			}
+
+			prepareTables($content);
+
+			this.cleanLists($content);
+			this.removeComments($content);
+			this.unwrapTags($content);
+			this.removeStyles($content);
+			this.removeNamespacedElements($content);
+			//this.transformLinks($content);
+
+			var transformFormatting = true;
+
+			if (Aloha.settings.contentHandler
+				&& Aloha.settings.contentHandler.handler
+				&& Aloha.settings.contentHandler.handler.generic
+				&& typeof Aloha.settings.contentHandler.handler.generic.transformFormattings !== 'undefinded'
+				&& !Aloha.settings.contentHandler.handler.generic.transformFormattings ) {
+				transformFormatting = false;
+			}
+
+			if (transformFormatting) {
+			    this.transformFormattings($content);
+			}
+
+			return $content.html();
+		},
+
+		/**
+		 * Cleans lists.
+		 * The only allowed children of ol or ul elements are li's. Everything
+		 * else will be removed.
+		 *
+		 * See http://validator.w3.org/check with following invalid markup for
+		 * example:
+		 * <!DOCTYPE html><head><title></title></head><ul><li>ok</li><ol></ol></ul>
+		 *
+		 * @param {jQuery.<HTMLElement>} $content
+		 */
+		cleanLists: function ($content) {
+			$content.find('ul,ol').find('>:not(li)').remove();
+		},
+
+		/**
+		 * Transform formattings
+		 * @param content
+		 */
+		transformFormattings: function ( content ) {
+			// find all formattings we will transform
+			// @todo this makes troubles -- don't change semantics! at least in this way...
+
+			var selectors = [],
+				i
+			;
+
+			for (i = 0; i < formattingTags.length; i++) {
+				if (!isAllowedNodeName(formattingTags[i])) {
+					selectors.push(formattingTags[i]);
+				}
+			}
+
+			content.find(selectors.join(',')).each(function () {
+				if (this.nodeName === 'STRONG') {
+					// transform strong to b
+					Aloha.Markup.transformDomObject($(this), 'b');
+				} else if (this.nodeName === 'EM') {
+					// transform em to i
+					Aloha.Markup.transformDomObject($(this), 'i');
+				} else if (this.nodeName === 'S' || this.nodeName == 'STRIKE') {
+					// transform s and strike to del
+					Aloha.Markup.transformDomObject($(this), 'del');
+				} else if (this.nodeName === 'U') {
+					// transform u?
+					$(this).contents().unwrap();
+				}
+			});
+		},
+
+		/**
+		 * Transform links
+		 * @param content
+		 */
+		transformLinks: function ( content ) {
+			// find all links and remove the links without href (will be destination anchors from word table of contents)
+			// aloha is not supporting anchors at the moment -- maybe rewrite anchors in headings to "invisible"
+			// in the test document there are anchors for whole paragraphs --> the whole P appear as link
+			content.find('a').each(function () {
+				if ( typeof $(this).attr('href') === 'undefined' ) {
+					$(this).contents().unwrap();
+				}
+			});
+		},
+
+		/**
+		 * Remove all comments
+		 * @param content
+		 */
+		removeComments: function ( content ) {
+			var that = this;
+
+			// ok, remove all comments
+			content.contents().each(function () {
+				if (this.nodeType === 8) {
+					$(this).remove();
+				} else {
+					// do recursion
+					that.removeComments($(this));
+				}
+			});
+		},
+
+		/**
+		 * Remove some unwanted tags from content pasted
+		 * @param content
+		 */
+		unwrapTags: function ( content ) {
+			var that = this;
+
+			// Note: we exclude all elements (they will be spans) here, that have the class aloha-wai-lang
+			// TODO find a better solution for this (e.g. invent a more generic aloha class for all elements, that are
+			// somehow maintained by aloha, and are therefore allowed)
+			content.find('span,font,div').not('.aloha-wai-lang').each(function () {
+				if (this.nodeName == 'DIV') {
+					// safari and chrome cleanup for plain text paste with working linebreaks
+					if (this.innerHTML === '<br>') {
+						$(this).contents().unwrap();
+					} else {
+						$( Aloha.Markup.transformDomObject($(this), 'p').append('<br>') ).contents().unwrap();
+					}
+				} else {
+					$(this).contents().unwrap();
+				}
+			});
+		},
+
+		/**
+		 * Remove styles
+		 * @param content
+		 */
+		removeStyles: function ( content ) {
+			var that = this;
+
+			// completely remove style tags
+			content.children('style').filter(function () {
+				return this.contentEditable !== 'false';
+			}).remove();
+
+			// remove style attributes and classes
+			content.children().filter(function () {
+				return this.contentEditable !== 'false';
+			}).each(function () {
+				$(this).removeAttr('style').removeClass();
+				that.removeStyles($(this));
+			});
+		},
+
+		/**
+		 * Remove all elements which are in different namespaces
+		 * @param content
+		 */
+		removeNamespacedElements: function ($content) {
+			// get all elements
+			$content.find('*').each(function () {
+				// try to determine the namespace prefix ('prefix' works for W3C
+				// compliant browsers, 'scopeName' for IE)
+
+				var nsPrefix = this.prefix ? this.prefix
+						: (this.scopeName ? this.scopeName : undefined);
+				// when the prefix is set (and different from 'HTML'), we remove the
+				// element
+				if ((nsPrefix && nsPrefix !== 'HTML') || this.nodeName.indexOf(':') >= 0 ) {
+					var $this = $(this), $contents = $this.contents();
+					if ($contents.length) {
+						// the element has contents, so unwrap the contents
+						$contents.unwrap();
+					} else {
+						// the element is empty, so remove it
+						$this.remove();
+					}
+				}
+			});
+		}
+	});
+
+	return GenericContentHandler;
+});

data/vendor/assets/javascripts/aloha/plugins/common/contenthandler/lib/oembedcontenthandler.js

@@ -0,0 +1,461 @@
+/* oembedcontenthandler.js is part of Aloha Editor project http://aloha-editor.org
+ *
+ * Aloha Editor is a WYSIWYG HTML5 inline editing library and editor. 
+ * Copyright (c) 2010-2012 Gentics Software GmbH, Vienna, Austria.
+ * Contributors http://aloha-editor.org/contribution.php 
+ * 
+ * Aloha Editor is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or any later version.
+ *
+ * Aloha Editor is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * 
+ * As an additional permission to the GNU GPL version 2, you may distribute
+ * non-source (e.g., minimized or compacted) forms of the Aloha-Editor
+ * source code without the copy of the GNU GPL normally required,
+ * provided you include this license notice and a URL through which
+ * recipients can access the Corresponding Source.
+ */
+define(
+['aloha', 'jquery', 'aloha/contenthandlermanager'],
+function(Aloha, jQuery, ContentHandlerManager) {
+	"use strict";
+
+	var
+		GENTICS = window.GENTICS,
+		escape = window.escape,
+		providers, getOEmbedProvider, getNormalizedParams, OEmbedProvider;
+
+	    jQuery.fn.oembed = function (url, options, embedAction) {
+
+	        settings = jQuery.extend(true, jQuery.fn.oembed.defaults, options);
+
+	        initializeProviders();
+
+	        return this.each(function () {
+
+	            var container = jQuery(this),
+					resourceURL = (url != null) ? url : container.attr("href"),
+					provider;
+
+	            if (embedAction) {
+	                settings.onEmbed = embedAction;
+	            } else {
+	                settings.onEmbed = function (oembedData) {
+	                    jQuery.fn.oembed.insertCode(this, settings.embedMethod, oembedData);
+	                    // return jQuery.fn.oembed.getInsertCode(this, settings.embedMethod, oembedData);
+	                };
+	            }
+
+	            if (resourceURL != null) {
+	                provider = jQuery.fn.oembed.getOEmbedProvider(resourceURL);
+
+	                if (provider != null) {
+	                    provider.params = getNormalizedParams(settings[provider.name]) || {};
+	                    provider.maxWidth = settings.maxWidth;
+	                    provider.maxHeight = settings.maxHeight;
+	                    embedCode(container, resourceURL, provider);
+	                } else {
+	                    settings.onProviderNotFound.call(container, resourceURL);
+	                }
+	            }
+
+	            return container;
+	        });
+
+
+	    };
+
+	    var settings, activeProviders = [];
+
+	    // Plugin defaults
+	    jQuery.fn.oembed.defaults = {
+	        maxWidth: null,
+	        maxHeight: null,
+	        embedMethod: "replace",  	// "auto", "append", "fill"		
+	        defaultOEmbedProvider: "oohembed", 	// "oohembed", "embed.ly", "none"
+	        allowedProviders: null,
+	        disallowedProviders: null,
+	        customProviders: null, // [ new jQuery.fn.oembed.OEmbedProvider("customprovider", null, ["customprovider\\.com/watch.+v=[\\w-]+&?"]) ]	
+	        defaultProvider: null,
+	        greedy: true,
+	        onProviderNotFound: function () { },
+	        beforeEmbed: function () { },
+	        afterEmbed: function () { },
+	        onEmbed: function () { },
+			onError: function() {},
+			ajaxOptions: {}
+	    };
+	
+		jQuery.fn.oembed.embedCode = false;
+
+	    /* Private functions */
+	    function getRequestUrl(provider, externalUrl) {
+
+	        var url = provider.apiendpoint, qs = "", callbackparameter = provider.callbackparameter || "callback", i;
+
+	        if (url.indexOf("?") <= 0)
+	            url = url + "?";
+	        else
+	            url = url + "&";
+
+	        if (provider.maxWidth != null && provider.params["maxwidth"] == null)
+	            provider.params["maxwidth"] = provider.maxWidth;
+
+	        if (provider.maxHeight != null && provider.params["maxheight"] == null)
+	            provider.params["maxheight"] = provider.maxHeight;
+
+	        for (i in provider.params) {
+	            // We don't want them to jack everything up by changing the callback parameter
+	            if (i == provider.callbackparameter)
+	                continue;
+
+	            // allows the options to be set to null, don't send null values to the server as parameters
+	            if (provider.params[i] != null)
+	                qs += "&" + escape(i) + "=" + provider.params[i];
+	        }
+
+	        url += "format=json&url=" + escape(externalUrl) +
+						qs +
+						"&" + callbackparameter + "=?";
+
+	        return url;
+	    };
+
+	    function embedCode(container, externalUrl, embedProvider) {
+
+	        var requestUrl = getRequestUrl(embedProvider, externalUrl), 		
+				ajaxopts = jQuery.extend({
+					url: requestUrl,
+					type: 'get',
+					dataType: 'json',
+					// error: jsonp request doesnt' support error handling
+					success:  function (data) {
+						var oembedData = jQuery.extend({}, data);
+						switch (oembedData.type) {
+							case "photo":
+								oembedData.code = jQuery.fn.oembed.getPhotoCode(externalUrl, oembedData);
+								break;
+							case "video":
+								oembedData.code = jQuery.fn.oembed.getVideoCode(externalUrl, oembedData);
+								break;
+							case "rich":
+								oembedData.code = jQuery.fn.oembed.getRichCode(externalUrl, oembedData);
+								break;
+							default:
+								oembedData.code = jQuery.fn.oembed.getGenericCode(externalUrl, oembedData);
+								break;
+						}
+						settings.beforeEmbed.call(container, oembedData);
+						settings.onEmbed.call(container, oembedData);
+						settings.afterEmbed.call(container, oembedData);
+					},
+					error: settings.onError.call(container, externalUrl, embedProvider)
+				}, settings.ajaxOptions || { } );
+
+			jQuery.ajax( ajaxopts );        
+	    };
+
+	    function initializeProviders() {
+
+	        activeProviders = [];
+
+	        var defaultProvider, restrictedProviders = [], i, provider;
+
+	        if (!isNullOrEmpty(settings.allowedProviders)) {
+	            for (i = 0; i < jQuery.fn.oembed.providers.length; i++) {
+	                if (jQuery.inArray(jQuery.fn.oembed.providers[i].name, settings.allowedProviders) >= 0)
+	                    activeProviders.push(jQuery.fn.oembed.providers[i]);
+	            }
+	            // If there are allowed providers, jquery-oembed cannot be greedy
+	            settings.greedy = false;
+
+	        } else {
+	            activeProviders = jQuery.fn.oembed.providers;
+	        }
+
+	        if (!isNullOrEmpty(settings.disallowedProviders)) {
+	            for (i = 0; i < activeProviders.length; i++) {
+	                if (jQuery.inArray(activeProviders[i].name, settings.disallowedProviders) < 0)
+	                    restrictedProviders.push(activeProviders[i]);
+	            }
+	            activeProviders = restrictedProviders;
+	            // If there are allowed providers, jquery-oembed cannot be greedy
+	            settings.greedy = false;
+	        }
+
+	        if (!isNullOrEmpty(settings.customProviders)) {
+	            jQuery.each(settings.customProviders, function (n, customProvider) {
+	                if (customProvider instanceof jQuery.fn.oembed.OEmbedProvider) {
+	                    activeProviders.push(provider);
+	                } else {
+	                    provider = new jQuery.fn.oembed.OEmbedProvider();
+	                    if (provider.fromJSON(customProvider))
+	                        activeProviders.push(provider);
+	                }
+	            });
+	        }
+
+	        // If in greedy mode, we add the default provider
+	        defaultProvider = getDefaultOEmbedProvider(settings.defaultOEmbedProvider);
+	        if (settings.greedy == true) {
+	            activeProviders.push(defaultProvider);
+			}
+	        // If any provider has no apiendpoint, we use the default provider endpoint
+	        for (i = 0; i < activeProviders.length; i++) {
+	            if (activeProviders[i].apiendpoint == null)
+	                activeProviders[i].apiendpoint = defaultProvider.apiendpoint;
+	        }
+	    }
+
+	    function getDefaultOEmbedProvider(defaultOEmbedProvider) {
+	        var url = "http://oohembed.com/oohembed/";
+	        if (defaultOEmbedProvider == "embed.ly")
+	            url = "http://api.embed.ly/v1/api/oembed?";
+	        return new jQuery.fn.oembed.OEmbedProvider(defaultOEmbedProvider, null, null, url, "callback");
+	    }
+
+	    function getNormalizedParams(params) {
+	        if (params == null)
+	            return null;
+	        var key, normalizedParams = {};
+	        for (key in params) {
+	            if (key != null)
+	                normalizedParams[key.toLowerCase()] = params[key];
+	        }
+	        return normalizedParams;
+	    }
+
+	    function isNullOrEmpty(object) {
+	        if (typeof object == "undefined")
+	            return true;
+	        if (object == null)
+	            return true;
+	        if (jQuery.isArray(object) && object.length == 0)
+	            return true;
+	        return false;
+	    }
+
+	    /* Public functions */
+	    jQuery.fn.oembed.insertCode = function (container, embedMethod, oembedData) {
+	        if (oembedData == null)
+	            return;
+
+			// little hack
+			jQuery.fn.oembed.embedCode = oembedData.code;
+
+	        switch (embedMethod) {
+	            case "auto":
+	                if (container.attr("href") != null) {
+	                    jQuery.fn.oembed.insertCode(container, "append", oembedData);
+	                }
+	                else {
+	                    jQuery.fn.oembed.insertCode(container, "replace", oembedData);
+	                };
+	                break;
+	            case "replace":
+	                container.replaceWith(oembedData.code);
+	                break;
+	            case "fill":
+	                container.html(oembedData.code);
+	                break;
+	            case "append":
+	                var oembedContainer = container.next();
+	                if (oembedContainer == null || !oembedContainer.hasClass("oembed-container")) {
+	                    oembedContainer = container
+							.after('<div class="oembed-container"></div>')
+							.next(".oembed-container");
+	                    if (oembedData != null && oembedData.provider_name != null)
+	                        oembedContainer.toggleClass("oembed-container-" + oembedData.provider_name);
+	                }
+	                oembedContainer.html(oembedData.code);
+	                break;
+	        }
+	    };
+
+	    jQuery.fn.oembed.getInsertCode = function (container, embedMethod, oembedData) {
+	        if (oembedData == null)
+	            return;
+
+	        return oembedData.code;
+	    };
+
+	    jQuery.fn.oembed.getPhotoCode = function (url, oembedData) {
+	        var code, alt = oembedData.title ? oembedData.title : '';
+	        alt += oembedData.author_name ? ' - ' + oembedData.author_name : '';
+	        alt += oembedData.provider_name ? ' - ' + oembedData.provider_name : '';
+	        code = '<div><a href="' + url + '" target=\'_blank\'><img src="' + oembedData.url + '" alt="' + alt + '"/></a></div>';
+	        if (oembedData.html)
+	            code += "<div>" + oembedData.html + "</div>";
+	        return code;
+	    };
+
+	    jQuery.fn.oembed.getVideoCode = function (url, oembedData) {
+	        var code = oembedData.html;
+
+	        return code;
+	    };
+
+	    jQuery.fn.oembed.getRichCode = function (url, oembedData) {
+	        var code = oembedData.html;
+	        return code;
+	    };
+
+	    jQuery.fn.oembed.getGenericCode = function (url, oembedData) {
+	        var title = (oembedData.title != null) ? oembedData.title : url,
+				code = '<a href="' + url + '">' + title + '</a>';
+	        if (oembedData.html)
+	            code += "<div>" + oembedData.html + "</div>";
+	        return code;
+	    };
+
+	    jQuery.fn.oembed.isProviderAvailable = function (url) {
+	        var provider = getOEmbedProvider(url);
+	        return (provider != null);
+	    };
+
+	    jQuery.fn.oembed.getOEmbedProvider = function (url) {
+	        for (var i = 0; i < activeProviders.length; i++) {
+	            if (activeProviders[i].matches(url))
+	                return activeProviders[i];
+	        }
+	        return null;
+	    };
+
+	    jQuery.fn.oembed.OEmbedProvider = function (name, type, urlschemesarray, apiendpoint, callbackparameter) {
+	        this.name = name;
+	        this.type = type; // "photo", "video", "link", "rich", null
+	        this.urlschemes = getUrlSchemes(urlschemesarray);
+	        this.apiendpoint = apiendpoint;
+	        this.callbackparameter = callbackparameter;
+	        this.maxWidth = 500;
+	        this.maxHeight = 400;
+	        var i, property, regExp;
+
+	        this.matches = function (externalUrl) {
+	            for (i = 0; i < this.urlschemes.length; i++) {
+	                regExp = new RegExp(this.urlschemes[i], "i");
+	                if (externalUrl.match(regExp) != null)
+	                    return true;
+	            }
+	            return false;
+	        };
+
+	        this.fromJSON = function (json) {
+	            for (property in json) {
+	                if (property != "urlschemes")
+	                    this[property] = json[property];
+	                else
+	                    this[property] = getUrlSchemes(json[property]);
+	            }
+	            return true;
+	        };
+
+	        function getUrlSchemes(urls) {
+	            if (isNullOrEmpty(urls))
+	                return ["."];
+	            if (jQuery.isArray(urls))
+	                return urls;
+	            return urls.split(";");
+	        }
+	    };
+
+	    /* Native & common providers */
+	    jQuery.fn.oembed.providers = [
+			new jQuery.fn.oembed.OEmbedProvider("youtube", "video", ["youtube\\.com/watch.+v=[\\w-]+&?"]), // "http://www.youtube.com/oembed"	(no jsonp)
+			new jQuery.fn.oembed.OEmbedProvider("flickr", "photo", ["flickr\\.com/photos/[-.\\w@]+/\\d+/?"], "http://flickr.com/services/oembed", "jsoncallback"),
+			new jQuery.fn.oembed.OEmbedProvider("viddler", "video", ["viddler\.com"]), // "http://lab.viddler.com/services/oembed/" (no jsonp)
+			new jQuery.fn.oembed.OEmbedProvider("blip", "video", ["blip\\.tv/.+"], "http://blip.tv/oembed/"),
+			new jQuery.fn.oembed.OEmbedProvider("hulu", "video", ["hulu\\.com/watch/.*"], "http://www.hulu.com/api/oembed.json"),
+			new jQuery.fn.oembed.OEmbedProvider("vimeo", "video", ["http:\/\/www\.vimeo\.com\/groups\/.*\/videos\/.*", "http:\/\/www\.vimeo\.com\/.*", "http:\/\/vimeo\.com\/groups\/.*\/videos\/.*", "http:\/\/vimeo\.com\/.*"], "http://vimeo.com/api/oembed.json"),
+			new jQuery.fn.oembed.OEmbedProvider("dailymotion", "video", ["dailymotion\\.com/.+"]), // "http://www.dailymotion.com/api/oembed/" (callback parameter does not return jsonp)
+			new jQuery.fn.oembed.OEmbedProvider("scribd", "rich", ["scribd\\.com/.+"]), // ", "http://www.scribd.com/services/oembed"" (no jsonp)		
+			new jQuery.fn.oembed.OEmbedProvider("slideshare", "rich", ["slideshare\.net"], "http://www.slideshare.net/api/oembed/1"),
+			new jQuery.fn.oembed.OEmbedProvider("photobucket", "photo", ["photobucket\\.com/(albums|groups)/.*"], "http://photobucket.com/oembed/")
+			// new jQuery.fn.oembed.OEmbedProvider("vids.myspace.com", "video", ["vids\.myspace\.com"]), // "http://vids.myspace.com/index.cfm?fuseaction=oembed" (not working)
+			// new jQuery.fn.oembed.OEmbedProvider("screenr", "rich", ["screenr\.com"], "http://screenr.com/api/oembed.json") (error)		
+			// new jQuery.fn.oembed.OEmbedProvider("qik", "video", ["qik\\.com/\\w+"], "http://qik.com/api/oembed.json"),		
+			// new jQuery.fn.oembed.OEmbedProvider("revision3", "video", ["revision3\.com"], "http://revision3.com/api/oembed/")
+		];
+
+	/**
+	 * Register the word paste handler
+	 */
+	var OEmbedContentHandler = ContentHandlerManager.createHandler({
+		/**
+		 * Handle the pasting. Try to detect content pasted from word and transform to clean html
+		 * @param content
+		 */
+		handleContent: function( content ) {
+			
+			if ( typeof content === 'string' ){
+				content = jQuery( '<div>' + content + '</div>' ).get(0);
+			} else if ( content instanceof jQuery ) {
+				content = jQuery( '<div>' ).append(content).get(0);
+			}
+			
+			//console.log('content in ', content);
+			//console.log('content url ', jQuery(content).text());
+			content = jQuery( content ).oembed(jQuery(content).text(), {embedMethod: "replace"});
+			//console.log('content embed ', content);
+			
+			var returnval = setTimeout(function() {
+				content = jQuery.fn.oembed.embedCode;
+				//console.log('content code ', content);
+				return jQuery('<div>').append( content ).html();
+			}, 500);
+			//return returnval;
+		},
+
+		/*handleContent: function( content )  {
+			if ( typeof sanitize === 'undefined' ) {
+			   initSanitize();
+			}
+
+			if ( typeof content === 'string' ){
+				content = jQuery( '<div>' + content + '</div>' ).get(0);
+			} else if ( content instanceof jQuery ) {
+				content = jQuery( '<div>' ).append(content).get(0);
+			}
+
+			return jQuery('<div>').append(sanitize.clean_node(content)).html();
+		}*/
+
+		/**
+		 * Check whether the content of the given jQuery object is assumed to be pasted from word.
+		 * @param content
+		 * @return true for content pasted from word, false for other content
+		 */
+		replaceoEmbedContent: function( content ) {
+			
+			//console.log('container text ', jQuery(content).text());
+			//return jQuery.fn.oembed.insertCode(content, options.embedMethod, oembed);
+			//return jQuery(content).oembed( jQuery(content).text() );
+			
+			// check every element which was pasted.
+			/*jQuery(content).each(function() {
+				var container = jQuery(this);
+				console.log('container ', container);
+				
+				container.oembed( container.text() );
+			});*/
+		}
+		/*replaceoEmbedContent: function( content ) {
+			// check every element which was pasted.
+			content.contents().each(function() {
+				var container = jQuery(this);
+				container.oembed( container.text() );
+			});
+		}*/
+	});
+	
+	return OEmbedContentHandler;
+});