RubyGems - tinymce_rails - Versions diffs - 3.4.6 - Mend

tinymce_rails 3.4.6

Files changed (261) hide show

data/vendor/assets/javascripts/tiny_mce/plugins/insertdatetime/editor_plugin.js ADDED Viewed

@@ -0,0 +1 @@

data/vendor/assets/javascripts/tiny_mce/plugins/insertdatetime/editor_plugin_src.js ADDED Viewed

@@ -0,0 +1,83 @@
+/**
+ * editor_plugin_src.js
+ *
+ * Copyright 2009, Moxiecode Systems AB
+ * Released under LGPL License.
+ *
+ * License: http://tinymce.moxiecode.com/license
+ * Contributing: http://tinymce.moxiecode.com/contributing
+ */
+(function() {
+	tinymce.create('tinymce.plugins.InsertDateTime', {
+		init : function(ed, url) {
+			var t = this;
+			t.editor = ed;
+			ed.addCommand('mceInsertDate', function() {
+				var str = t._getDateTime(new Date(), ed.getParam("plugin_insertdate_dateFormat", ed.getLang('insertdatetime.date_fmt')));
+				ed.execCommand('mceInsertContent', false, str);
+			});
+			ed.addCommand('mceInsertTime', function() {
+				var str = t._getDateTime(new Date(), ed.getParam("plugin_insertdate_timeFormat", ed.getLang('insertdatetime.time_fmt')));
+				ed.execCommand('mceInsertContent', false, str);
+			});
+			ed.addButton('insertdate', {title : 'insertdatetime.insertdate_desc', cmd : 'mceInsertDate'});
+			ed.addButton('inserttime', {title : 'insertdatetime.inserttime_desc', cmd : 'mceInsertTime'});
+		},
+		getInfo : function() {
+			return {
+				longname : 'Insert date/time',
+				author : 'Moxiecode Systems AB',
+				authorurl : 'http://tinymce.moxiecode.com',
+				infourl : 'http://wiki.moxiecode.com/index.php/TinyMCE:Plugins/insertdatetime',
+				version : tinymce.majorVersion + "." + tinymce.minorVersion
+			};
+		},
+		// Private methods
+		_getDateTime : function(d, fmt) {
+			var ed = this.editor;
+			function addZeros(value, len) {
+				value = "" + value;
+				if (value.length < len) {
+					for (var i=0; i<(len-value.length); i++)
+						value = "0" + value;
+				}
+				return value;
+			};
+			fmt = fmt.replace("%D", "%m/%d/%y");
+			fmt = fmt.replace("%r", "%I:%M:%S %p");
+			fmt = fmt.replace("%Y", "" + d.getFullYear());
+			fmt = fmt.replace("%y", "" + d.getYear());
+			fmt = fmt.replace("%m", addZeros(d.getMonth()+1, 2));
+			fmt = fmt.replace("%d", addZeros(d.getDate(), 2));
+			fmt = fmt.replace("%H", "" + addZeros(d.getHours(), 2));
+			fmt = fmt.replace("%M", "" + addZeros(d.getMinutes(), 2));
+			fmt = fmt.replace("%S", "" + addZeros(d.getSeconds(), 2));
+			fmt = fmt.replace("%I", "" + ((d.getHours() + 11) % 12 + 1));
+			fmt = fmt.replace("%p", "" + (d.getHours() < 12 ? "AM" : "PM"));
+			fmt = fmt.replace("%B", "" + ed.getLang("insertdatetime.months_long").split(',')[d.getMonth()]);
+			fmt = fmt.replace("%b", "" + ed.getLang("insertdatetime.months_short").split(',')[d.getMonth()]);
+			fmt = fmt.replace("%A", "" + ed.getLang("insertdatetime.day_long").split(',')[d.getDay()]);
+			fmt = fmt.replace("%a", "" + ed.getLang("insertdatetime.day_short").split(',')[d.getDay()]);
+			fmt = fmt.replace("%%", "%");
+			return fmt;
+		}
+	});
+	// Register plugin
+	tinymce.PluginManager.add('insertdatetime', tinymce.plugins.InsertDateTime);
+})();

data/vendor/assets/javascripts/tiny_mce/plugins/layer/editor_plugin.js ADDED Viewed

@@ -0,0 +1 @@

data/vendor/assets/javascripts/tiny_mce/plugins/layer/editor_plugin_src.js ADDED Viewed

@@ -0,0 +1,212 @@
+/**
+ * editor_plugin_src.js
+ *
+ * Copyright 2009, Moxiecode Systems AB
+ * Released under LGPL License.
+ *
+ * License: http://tinymce.moxiecode.com/license
+ * Contributing: http://tinymce.moxiecode.com/contributing
+ */
+(function() {
+	tinymce.create('tinymce.plugins.Layer', {
+		init : function(ed, url) {
+			var t = this;
+			t.editor = ed;
+			// Register commands
+			ed.addCommand('mceInsertLayer', t._insertLayer, t);
+			ed.addCommand('mceMoveForward', function() {
+				t._move(1);
+			});
+			ed.addCommand('mceMoveBackward', function() {
+				t._move(-1);
+			});
+			ed.addCommand('mceMakeAbsolute', function() {
+				t._toggleAbsolute();
+			});
+			// Register buttons
+			ed.addButton('moveforward', {title : 'layer.forward_desc', cmd : 'mceMoveForward'});
+			ed.addButton('movebackward', {title : 'layer.backward_desc', cmd : 'mceMoveBackward'});
+			ed.addButton('absolute', {title : 'layer.absolute_desc', cmd : 'mceMakeAbsolute'});
+			ed.addButton('insertlayer', {title : 'layer.insertlayer_desc', cmd : 'mceInsertLayer'});
+			ed.onInit.add(function() {
+				if (tinymce.isIE)
+					ed.getDoc().execCommand('2D-Position', false, true);
+			});
+			ed.onNodeChange.add(t._nodeChange, t);
+			ed.onVisualAid.add(t._visualAid, t);
+		},
+		getInfo : function() {
+			return {
+				longname : 'Layer',
+				author : 'Moxiecode Systems AB',
+				authorurl : 'http://tinymce.moxiecode.com',
+				infourl : 'http://wiki.moxiecode.com/index.php/TinyMCE:Plugins/layer',
+				version : tinymce.majorVersion + "." + tinymce.minorVersion
+			};
+		},
+		// Private methods
+		_nodeChange : function(ed, cm, n) {
+			var le, p;
+			le = this._getParentLayer(n);
+			p = ed.dom.getParent(n, 'DIV,P,IMG');
+			if (!p) {
+				cm.setDisabled('absolute', 1);
+				cm.setDisabled('moveforward', 1);
+				cm.setDisabled('movebackward', 1);
+			} else {
+				cm.setDisabled('absolute', 0);
+				cm.setDisabled('moveforward', !le);
+				cm.setDisabled('movebackward', !le);
+				cm.setActive('absolute', le && le.style.position.toLowerCase() == "absolute");
+			}
+		},
+		// Private methods
+		_visualAid : function(ed, e, s) {
+			var dom = ed.dom;
+			tinymce.each(dom.select('div,p', e), function(e) {
+				if (/^(absolute|relative|static)$/i.test(e.style.position)) {
+					if (s)
+						dom.addClass(e, 'mceItemVisualAid');
+					else
+						dom.removeClass(e, 'mceItemVisualAid');
+				}
+			});
+		},
+		_move : function(d) {
+			var ed = this.editor, i, z = [], le = this._getParentLayer(ed.selection.getNode()), ci = -1, fi = -1, nl;
+			nl = [];
+			tinymce.walk(ed.getBody(), function(n) {
+				if (n.nodeType == 1 && /^(absolute|relative|static)$/i.test(n.style.position))
+					nl.push(n);
+			}, 'childNodes');
+			// Find z-indexes
+			for (i=0; i<nl.length; i++) {
+				z[i] = nl[i].style.zIndex ? parseInt(nl[i].style.zIndex) : 0;
+				if (ci < 0 && nl[i] == le)
+					ci = i;
+			}
+			if (d < 0) {
+				// Move back
+				// Try find a lower one
+				for (i=0; i<z.length; i++) {
+					if (z[i] < z[ci]) {
+						fi = i;
+						break;
+					}
+				}
+				if (fi > -1) {
+					nl[ci].style.zIndex = z[fi];
+					nl[fi].style.zIndex = z[ci];
+				} else {
+					if (z[ci] > 0)
+						nl[ci].style.zIndex = z[ci] - 1;
+				}
+			} else {
+				// Move forward
+				// Try find a higher one
+				for (i=0; i<z.length; i++) {
+					if (z[i] > z[ci]) {
+						fi = i;
+						break;
+					}
+				}
+				if (fi > -1) {
+					nl[ci].style.zIndex = z[fi];
+					nl[fi].style.zIndex = z[ci];
+				} else
+					nl[ci].style.zIndex = z[ci] + 1;
+			}
+			ed.execCommand('mceRepaint');
+		},
+		_getParentLayer : function(n) {
+			return this.editor.dom.getParent(n, function(n) {
+				return n.nodeType == 1 && /^(absolute|relative|static)$/i.test(n.style.position);
+			});
+		},
+		_insertLayer : function() {
+			var ed = this.editor, p = ed.dom.getPos(ed.dom.getParent(ed.selection.getNode(), '*'));
+			ed.dom.add(ed.getBody(), 'div', {
+				style : {
+					position : 'absolute',
+					left : p.x,
+					top : (p.y > 20 ? p.y : 20),
+					width : 100,
+					height : 100
+				},
+				'class' : 'mceItemVisualAid'
+			}, ed.selection.getContent() || ed.getLang('layer.content'));
+		},
+		_toggleAbsolute : function() {
+			var ed = this.editor, le = this._getParentLayer(ed.selection.getNode());
+			if (!le)
+				le = ed.dom.getParent(ed.selection.getNode(), 'DIV,P,IMG');
+			if (le) {
+				if (le.style.position.toLowerCase() == "absolute") {
+					ed.dom.setStyles(le, {
+						position : '',
+						left : '',
+						top : '',
+						width : '',
+						height : ''
+					});
+					ed.dom.removeClass(le, 'mceItemVisualAid');
+				} else {
+					if (le.style.left == "")
+						le.style.left = 20 + 'px';
+					if (le.style.top == "")
+						le.style.top = 20 + 'px';
+					if (le.style.width == "")
+						le.style.width = le.width ? (le.width + 'px') : '100px';
+					if (le.style.height == "")
+						le.style.height = le.height ? (le.height + 'px') : '100px';
+					le.style.position = "absolute";
+					ed.addVisual(ed.getBody());
+				}
+				ed.execCommand('mceRepaint');
+				ed.nodeChanged();
+			}
+		}
+	});
+	// Register plugin
+	tinymce.PluginManager.add('layer', tinymce.plugins.Layer);
+})();

data/vendor/assets/javascripts/tiny_mce/plugins/legacyoutput/editor_plugin.js ADDED Viewed

@@ -0,0 +1 @@

data/vendor/assets/javascripts/tiny_mce/plugins/legacyoutput/editor_plugin_src.js ADDED Viewed

@@ -0,0 +1,136 @@
+/**
+ * editor_plugin_src.js
+ *
+ * Copyright 2009, Moxiecode Systems AB
+ * Released under LGPL License.
+ *
+ * License: http://tinymce.moxiecode.com/license
+ * Contributing: http://tinymce.moxiecode.com/contributing
+ *
+ * This plugin will force TinyMCE to produce deprecated legacy output such as font elements, u elements, align
+ * attributes and so forth. There are a few cases where these old items might be needed for example in email applications or with Flash
+ *
+ * However you should NOT use this plugin if you are building some system that produces web contents such as a CMS. All these elements are
+ * not apart of the newer specifications for HTML and XHTML.
+ */
+(function(tinymce) {
+	// Override inline_styles setting to force TinyMCE to produce deprecated contents
+	tinymce.onAddEditor.addToTop(function(tinymce, editor) {
+		editor.settings.inline_styles = false;
+	});
+	// Create the legacy ouput plugin
+	tinymce.create('tinymce.plugins.LegacyOutput', {
+		init : function(editor) {
+			editor.onInit.add(function() {
+				var alignElements = 'p,h1,h2,h3,h4,h5,h6,td,th,div,ul,ol,li,table,img',
+					fontSizes = tinymce.explode(editor.settings.font_size_style_values),
+					serializer = editor.serializer;
+				// Override some internal formats to produce legacy elements and attributes
+				editor.formatter.register({
+					// Change alignment formats to use the deprecated align attribute
+					alignleft : {selector : alignElements, attributes : {align : 'left'}},
+					aligncenter : {selector : alignElements, attributes : {align : 'center'}},
+					alignright : {selector : alignElements, attributes : {align : 'right'}},
+					alignfull : {selector : alignElements, attributes : {align : 'full'}},
+					// Change the basic formatting elements to use deprecated element types
+					bold : {inline : 'b'},
+					italic : {inline : 'i'},
+					underline : {inline : 'u'},
+					strikethrough : {inline : 'strike'},
+					// Change font size and font family to use the deprecated font element
+					fontname : {inline : 'font', attributes : {face : '%value'}},
+					fontsize : {
+						inline : 'font',
+						attributes : {
+							size : function(vars) {
+								return tinymce.inArray(fontSizes, vars.value) + 1;
+							}
+						}
+					},
+					// Setup font elements for colors as well
+					forecolor : {inline : 'font', styles : {color : '%value'}},
+					hilitecolor : {inline : 'font', styles : {backgroundColor : '%value'}}
+				});
+				// Force parsing of the serializer rules
+				serializer._setup();
+				// Check that deprecated elements are allowed if not add them
+				tinymce.each('b,i,u,strike'.split(','), function(name) {
+					var rule = serializer.rules[name];
+					if (!rule)
+						serializer.addRules(name);
+				});
+				// Add font element if it's missing
+				if (!serializer.rules["font"])
+					serializer.addRules("font[face|size|color|style]");
+				// Add the missing and depreacted align attribute for the serialization engine
+				tinymce.each(alignElements.split(','), function(name) {
+					var rule = serializer.rules[name], found;
+					if (rule) {
+						tinymce.each(rule.attribs, function(name, attr) {
+							if (attr.name == 'align') {
+								found = true;
+								return false;
+							}
+						});
+						if (!found)
+							rule.attribs.push({name : 'align'});
+					}
+				});
+				// Listen for the onNodeChange event so that we can do special logic for the font size and font name drop boxes
+				editor.onNodeChange.add(function(editor, control_manager) {
+					var control, fontElm, fontName, fontSize;
+					// Find font element get it's name and size
+					fontElm = editor.dom.getParent(editor.selection.getNode(), 'font');
+					if (fontElm) {
+						fontName = fontElm.face;
+						fontSize = fontElm.size;
+					}
+					// Select/unselect the font name in droplist
+					if (control = control_manager.get('fontselect')) {
+						control.select(function(value) {
+							return value == fontName;
+						});
+					}
+					// Select/unselect the font size in droplist
+					if (control = control_manager.get('fontsizeselect')) {
+						control.select(function(value) {
+							var index = tinymce.inArray(fontSizes, value.fontSize);
+							return index + 1 == fontSize;
+						});
+					}
+				});
+			});
+		},
+		getInfo : function() {
+			return {
+				longname : 'LegacyOutput',
+				author : 'Moxiecode Systems AB',
+				authorurl : 'http://tinymce.moxiecode.com',
+				infourl : 'http://wiki.moxiecode.com/index.php/TinyMCE:Plugins/legacyoutput',
+				version : tinymce.majorVersion + "." + tinymce.minorVersion
+			};
+		}
+	});
+	// Register plugin
+	tinymce.PluginManager.add('legacyoutput', tinymce.plugins.LegacyOutput);
+})(tinymce);

data/vendor/assets/javascripts/tiny_mce/plugins/lists/editor_plugin.js ADDED Viewed

@@ -0,0 +1 @@

data/vendor/assets/javascripts/tiny_mce/plugins/lists/editor_plugin_src.js ADDED Viewed

@@ -0,0 +1,617 @@
+/**
+ * editor_plugin_src.js
+ *
+ * Copyright 2011, Moxiecode Systems AB
+ * Released under LGPL License.
+ *
+ * License: http://tinymce.moxiecode.com/license
+ * Contributing: http://tinymce.moxiecode.com/contributing
+ */
+(function() {
+	var each = tinymce.each, Event = tinymce.dom.Event, bookmark;
+	// Skips text nodes that only contain whitespace since they aren't semantically important.
+	function skipWhitespaceNodes(e, next) {
+		while (e && (e.nodeType === 8 || (e.nodeType === 3 && /^[ \t\n\r]*$/.test(e.nodeValue)))) {
+			e = next(e);
+		}
+		return e;
+	}
+	function skipWhitespaceNodesBackwards(e) {
+		return skipWhitespaceNodes(e, function(e) { return e.previousSibling; });
+	}
+	function skipWhitespaceNodesForwards(e) {
+		return skipWhitespaceNodes(e, function(e) { return e.nextSibling; });
+	}
+	function hasParentInList(ed, e, list) {
+		return ed.dom.getParent(e, function(p) {
+			return tinymce.inArray(list, p) !== -1;
+		});
+	}
+	function isList(e) {
+		return e && (e.tagName === 'OL' || e.tagName === 'UL');
+	}
+	function splitNestedLists(element, dom) {
+		var tmp, nested, wrapItem;
+		tmp = skipWhitespaceNodesBackwards(element.lastChild);
+		while (isList(tmp)) {
+			nested = tmp;
+			tmp = skipWhitespaceNodesBackwards(nested.previousSibling);
+		}
+		if (nested) {
+			wrapItem = dom.create('li', { style: 'list-style-type: none;'});
+			dom.split(element, nested);
+			dom.insertAfter(wrapItem, nested);
+			wrapItem.appendChild(nested);
+			wrapItem.appendChild(nested);
+			element = wrapItem.previousSibling;
+		}
+		return element;
+	}
+	function attemptMergeWithAdjacent(e, allowDifferentListStyles, mergeParagraphs) {
+		e = attemptMergeWithPrevious(e, allowDifferentListStyles, mergeParagraphs);
+		return attemptMergeWithNext(e, allowDifferentListStyles, mergeParagraphs);
+	}
+	function attemptMergeWithPrevious(e, allowDifferentListStyles, mergeParagraphs) {
+		var prev = skipWhitespaceNodesBackwards(e.previousSibling);
+		if (prev) {
+			return attemptMerge(prev, e, allowDifferentListStyles ? prev : false, mergeParagraphs);
+		} else {
+			return e;
+		}
+	}
+	function attemptMergeWithNext(e, allowDifferentListStyles, mergeParagraphs) {
+		var next = skipWhitespaceNodesForwards(e.nextSibling);
+		if (next) {
+			return attemptMerge(e, next, allowDifferentListStyles ? next : false, mergeParagraphs);
+		} else {
+			return e;
+		}
+	}
+	function attemptMerge(e1, e2, differentStylesMasterElement, mergeParagraphs) {
+		if (canMerge(e1, e2, !!differentStylesMasterElement, mergeParagraphs)) {
+			return merge(e1, e2, differentStylesMasterElement);
+		} else if (e1 && e1.tagName === 'LI' && isList(e2)) {
+			// Fix invalidly nested lists.
+			e1.appendChild(e2);
+		}
+		return e2;
+	}
+	function canMerge(e1, e2, allowDifferentListStyles, mergeParagraphs) {
+		if (!e1 || !e2) {
+			return false;
+		} else if (e1.tagName === 'LI' && e2.tagName === 'LI') {
+			return e2.style.listStyleType === 'none' || containsOnlyAList(e2);
+		} else if (isList(e1)) {
+			return (e1.tagName === e2.tagName && (allowDifferentListStyles || e1.style.listStyleType === e2.style.listStyleType)) || isListForIndent(e2);
+		} else if (mergeParagraphs && e1.tagName === 'P' && e2.tagName === 'P') {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	function isListForIndent(e) {
+		var firstLI = skipWhitespaceNodesForwards(e.firstChild), lastLI = skipWhitespaceNodesBackwards(e.lastChild);
+		return firstLI && lastLI && isList(e) && firstLI === lastLI && (isList(firstLI) || firstLI.style.listStyleType === 'none'  || containsOnlyAList(firstLI));
+	}
+	function containsOnlyAList(e) {
+		var firstChild = skipWhitespaceNodesForwards(e.firstChild), lastChild = skipWhitespaceNodesBackwards(e.lastChild);
+		return firstChild && lastChild && firstChild === lastChild && isList(firstChild);
+	}
+	function merge(e1, e2, masterElement) {
+		var lastOriginal = skipWhitespaceNodesBackwards(e1.lastChild), firstNew = skipWhitespaceNodesForwards(e2.firstChild);
+		if (e1.tagName === 'P') {
+			e1.appendChild(e1.ownerDocument.createElement('br'));
+		}
+		while (e2.firstChild) {
+			e1.appendChild(e2.firstChild);
+		}
+		if (masterElement) {
+			e1.style.listStyleType = masterElement.style.listStyleType;
+		}
+		e2.parentNode.removeChild(e2);
+		attemptMerge(lastOriginal, firstNew, false);
+		return e1;
+	}
+	function findItemToOperateOn(e, dom) {
+		var item;
+		if (!dom.is(e, 'li,ol,ul')) {
+			item = dom.getParent(e, 'li');
+			if (item) {
+				e = item;
+			}
+		}
+		return e;
+	}
+	tinymce.create('tinymce.plugins.Lists', {
+		init: function(ed, url) {
+			var enterDownInEmptyList = false;
+			function isTriggerKey(e) {
+				return e.keyCode === 9 && (ed.queryCommandState('InsertUnorderedList') || ed.queryCommandState('InsertOrderedList'));
+			}
+			function isEnterInEmptyListItem(ed, e) {
+				var sel = ed.selection, n;
+				if (e.keyCode === 13) {
+					n = sel.getStart();
+					enterDownInEmptyList = sel.isCollapsed() && n && n.tagName === 'LI' && n.childNodes.length === 0;
+					return enterDownInEmptyList;
+				}
+			}
+			function cancelKeys(ed, e) {
+				if (isTriggerKey(e) || isEnterInEmptyListItem(ed, e)) {
+					return Event.cancel(e);
+				}
+			}
+			this.ed = ed;
+			ed.addCommand('Indent', this.indent, this);
+			ed.addCommand('Outdent', this.outdent, this);
+			ed.addCommand('InsertUnorderedList', function() {
+				this.applyList('UL', 'OL');
+			}, this);
+			ed.addCommand('InsertOrderedList', function() {
+				this.applyList('OL', 'UL');
+			}, this);
+			ed.onInit.add(function() {
+				ed.editorCommands.addCommands({
+					'outdent': function() {
+						var sel = ed.selection, dom = ed.dom;
+						function hasStyleIndent(n) {
+							n = dom.getParent(n, dom.isBlock);
+							return n && (parseInt(ed.dom.getStyle(n, 'margin-left') || 0, 10) + parseInt(ed.dom.getStyle(n, 'padding-left') || 0, 10)) > 0;
+						}
+						return hasStyleIndent(sel.getStart()) || hasStyleIndent(sel.getEnd()) || ed.queryCommandState('InsertOrderedList') || ed.queryCommandState('InsertUnorderedList');
+					}
+				}, 'state');
+			});
+			ed.onKeyUp.add(function(ed, e) {
+				var n, rng;
+				if (isTriggerKey(e)) {
+					ed.execCommand(e.shiftKey ? 'Outdent' : 'Indent', true, null);
+					return Event.cancel(e);
+				} else if (enterDownInEmptyList && isEnterInEmptyListItem(ed, e)) {
+					if (ed.queryCommandState('InsertOrderedList')) {
+						ed.execCommand('InsertOrderedList');
+					} else {
+						ed.execCommand('InsertUnorderedList');
+					}
+					n = ed.selection.getStart();
+					if (n && n.tagName === 'LI') {
+						// Fix the caret position on IE since it jumps back up to the previous list item.
+						n = ed.dom.getParent(n, 'ol,ul').nextSibling;
+						if (n && n.tagName === 'P') {
+							if (!n.firstChild) {
+								n.appendChild(ed.getDoc().createTextNode(''));
+							}
+							rng = ed.dom.createRng();
+							rng.setStart(n.firstChild, 1);
+							rng.setEnd(n.firstChild, 1);
+							ed.selection.setRng(rng);
+						}
+					}
+					return Event.cancel(e);
+				}
+			});
+			ed.onKeyPress.add(cancelKeys);
+			ed.onKeyDown.add(cancelKeys);
+		},
+		applyList: function(targetListType, oppositeListType) {
+			var t = this, ed = t.ed, dom = ed.dom, applied = [], hasSameType = false, hasOppositeType = false, hasNonList = false, actions,
+				selectedBlocks = ed.selection.getSelectedBlocks();
+			function cleanupBr(e) {
+				if (e && e.tagName === 'BR') {
+					dom.remove(e);
+				}
+			}
+			function makeList(element) {
+				var list = dom.create(targetListType), li;
+				function adjustIndentForNewList(element) {
+					// If there's a margin-left, outdent one level to account for the extra list margin.
+					if (element.style.marginLeft || element.style.paddingLeft) {
+						t.adjustPaddingFunction(false)(element);
+					}
+				}
+				if (element.tagName === 'LI') {
+					// No change required.
+				} else if (element.tagName === 'P' || element.tagName === 'DIV' || element.tagName === 'BODY') {
+					processBrs(element, function(startSection, br, previousBR) {
+						doWrapList(startSection, br, element.tagName === 'BODY' ? null : startSection.parentNode);
+						li = startSection.parentNode;
+						adjustIndentForNewList(li);
+						cleanupBr(br);
+					});
+					if (element.tagName === 'P' || selectedBlocks.length > 1) {
+						dom.split(li.parentNode.parentNode, li.parentNode);
+					}
+					attemptMergeWithAdjacent(li.parentNode, true);
+					return;
+				} else {
+					// Put the list around the element.
+					li = dom.create('li');
+					dom.insertAfter(li, element);
+					li.appendChild(element);
+					adjustIndentForNewList(element);
+					element = li;
+				}
+				dom.insertAfter(list, element);
+				list.appendChild(element);
+				attemptMergeWithAdjacent(list, true);
+				applied.push(element);
+			}
+			function doWrapList(start, end, template) {
+				var li, n = start, tmp, i;
+				while (!dom.isBlock(start.parentNode) && start.parentNode !== dom.getRoot()) {
+					start = dom.split(start.parentNode, start.previousSibling);
+					start = start.nextSibling;
+					n = start;
+				}
+				if (template) {
+					li = template.cloneNode(true);
+					start.parentNode.insertBefore(li, start);
+					while (li.firstChild) dom.remove(li.firstChild);
+					li = dom.rename(li, 'li');
+				} else {
+					li = dom.create('li');
+					start.parentNode.insertBefore(li, start);
+				}
+				while (n && n != end) {
+					tmp = n.nextSibling;
+					li.appendChild(n);
+					n = tmp;
+				}
+				if (li.childNodes.length === 0) {
+					li.innerHTML = '<br _mce_bogus="1" />';
+				}
+				makeList(li);
+			}
+			function processBrs(element, callback) {
+				var startSection, previousBR, END_TO_START = 3, START_TO_END = 1,
+					breakElements = 'br,ul,ol,p,div,h1,h2,h3,h4,h5,h6,table,blockquote,address,pre,form,center,dl';
+				function isAnyPartSelected(start, end) {
+					var r = dom.createRng(), sel;
+					bookmark.keep = true;
+					ed.selection.moveToBookmark(bookmark);
+					bookmark.keep = false;
+					sel = ed.selection.getRng(true);
+					if (!end) {
+						end = start.parentNode.lastChild;
+					}
+					r.setStartBefore(start);
+					r.setEndAfter(end);
+					return !(r.compareBoundaryPoints(END_TO_START, sel) > 0 || r.compareBoundaryPoints(START_TO_END, sel) <= 0);
+				}
+				function nextLeaf(br) {
+					if (br.nextSibling)
+						return br.nextSibling;
+					if (!dom.isBlock(br.parentNode) && br.parentNode !== dom.getRoot())
+						return nextLeaf(br.parentNode);
+				}
+				// Split on BRs within the range and process those.
+				startSection = element.firstChild;
+				// First mark the BRs that have any part of the previous section selected.
+				var trailingContentSelected = false;
+				each(dom.select(breakElements, element), function(br) {
+					var b;
+					if (br.hasAttribute && br.hasAttribute('_mce_bogus')) {
+						return true; // Skip the bogus Brs that are put in to appease Firefox and Safari.
+					}
+					if (isAnyPartSelected(startSection, br)) {
+						dom.addClass(br, '_mce_tagged_br');
+						startSection = nextLeaf(br);
+					}
+				});
+				trailingContentSelected = (startSection && isAnyPartSelected(startSection, undefined));
+				startSection = element.firstChild;
+				each(dom.select(breakElements, element), function(br) {
+					// Got a section from start to br.
+					var tmp = nextLeaf(br);
+					if (br.hasAttribute && br.hasAttribute('_mce_bogus')) {
+						return true; // Skip the bogus Brs that are put in to appease Firefox and Safari.
+					}
+					if (dom.hasClass(br, '_mce_tagged_br')) {
+						callback(startSection, br, previousBR);
+						previousBR = null;
+					} else {
+						previousBR = br;
+					}
+					startSection = tmp;
+				});
+				if (trailingContentSelected) {
+					callback(startSection, undefined, previousBR);
+				}
+			}
+			function wrapList(element) {
+				processBrs(element, function(startSection, br, previousBR) {
+					// Need to indent this part
+					doWrapList(startSection, br);
+					cleanupBr(br);
+					cleanupBr(previousBR);
+				});
+			}
+			function changeList(element) {
+				if (tinymce.inArray(applied, element) !== -1) {
+					return;
+				}
+				if (element.parentNode.tagName === oppositeListType) {
+					dom.split(element.parentNode, element);
+					makeList(element);
+					attemptMergeWithNext(element.parentNode, false);
+				}
+				applied.push(element);
+			}
+			function convertListItemToParagraph(element) {
+				var child, nextChild, mergedElement, splitLast;
+				if (tinymce.inArray(applied, element) !== -1) {
+					return;
+				}
+				element = splitNestedLists(element, dom);
+				while (dom.is(element.parentNode, 'ol,ul,li')) {
+					dom.split(element.parentNode, element);
+				}
+				// Push the original element we have from the selection, not the renamed one.
+				applied.push(element);
+				element = dom.rename(element, 'p');
+				mergedElement = attemptMergeWithAdjacent(element, false, ed.settings.force_br_newlines);
+				if (mergedElement === element) {
+					// Now split out any block elements that can't be contained within a P.
+					// Manually iterate to ensure we handle modifications correctly (doesn't work with tinymce.each)
+					child = element.firstChild;
+					while (child) {
+						if (dom.isBlock(child)) {
+							child = dom.split(child.parentNode, child);
+							splitLast = true;
+							nextChild = child.nextSibling && child.nextSibling.firstChild;
+						} else {
+							nextChild = child.nextSibling;
+							if (splitLast && child.tagName === 'BR') {
+								dom.remove(child);
+							}
+							splitLast = false;
+						}
+						child = nextChild;
+					}
+				}
+			}
+			each(selectedBlocks, function(e) {
+				e = findItemToOperateOn(e, dom);
+				if (e.tagName === oppositeListType || (e.tagName === 'LI' && e.parentNode.tagName === oppositeListType)) {
+					hasOppositeType = true;
+				} else if (e.tagName === targetListType || (e.tagName === 'LI' && e.parentNode.tagName === targetListType)) {
+					hasSameType = true;
+				} else {
+					hasNonList = true;
+				}
+			});
+			if (hasNonList || hasOppositeType || selectedBlocks.length === 0) {
+				actions = {
+					'LI': changeList,
+					'H1': makeList,
+					'H2': makeList,
+					'H3': makeList,
+					'H4': makeList,
+					'H5': makeList,
+					'H6': makeList,
+					'P': makeList,
+					'BODY': makeList,
+					'DIV': selectedBlocks.length > 1 ? makeList : wrapList,
+					defaultAction: wrapList
+				};
+			} else {
+				actions = {
+					defaultAction: convertListItemToParagraph
+				};
+			}
+			this.process(actions);
+		},
+		indent: function() {
+			var ed = this.ed, dom = ed.dom, indented = [];
+			function createWrapItem(element) {
+				var wrapItem = dom.create('li', { style: 'list-style-type: none;'});
+				dom.insertAfter(wrapItem, element);
+				return wrapItem;
+			}
+			function createWrapList(element) {
+				var wrapItem = createWrapItem(element),
+					list = dom.getParent(element, 'ol,ul'),
+					listType = list.tagName,
+					listStyle = dom.getStyle(list, 'list-style-type'),
+					attrs = {},
+					wrapList;
+				if (listStyle !== '') {
+					attrs.style = 'list-style-type: ' + listStyle + ';';
+				}
+				wrapList = dom.create(listType, attrs);
+				wrapItem.appendChild(wrapList);
+				return wrapList;
+			}
+			function indentLI(element) {
+				if (!hasParentInList(ed, element, indented)) {
+					element = splitNestedLists(element, dom);
+					var wrapList = createWrapList(element);
+					wrapList.appendChild(element);
+					attemptMergeWithAdjacent(wrapList.parentNode, false);
+					attemptMergeWithAdjacent(wrapList, false);
+					indented.push(element);
+				}
+			}
+			this.process({
+				'LI': indentLI,
+				defaultAction: this.adjustPaddingFunction(true)
+			});
+		},
+		outdent: function() {
+			var t = this, ed = t.ed, dom = ed.dom, outdented = [];
+			function outdentLI(element) {
+				var listElement, targetParent, align;
+				if (!hasParentInList(ed, element, outdented)) {
+					if (dom.getStyle(element, 'margin-left') !== '' || dom.getStyle(element, 'padding-left') !== '') {
+						return t.adjustPaddingFunction(false)(element);
+					}
+					align = dom.getStyle(element, 'text-align', true);
+					if (align === 'center' || align === 'right') {
+						dom.setStyle(element, 'text-align', 'left');
+						return;
+					}
+					element = splitNestedLists(element, dom);
+					listElement = element.parentNode;
+					targetParent = element.parentNode.parentNode;
+					if (targetParent.tagName === 'P') {
+						dom.split(targetParent, element.parentNode);
+					} else {
+						dom.split(listElement, element);
+						if (targetParent.tagName === 'LI') {
+							// Nested list, need to split the LI and go back out to the OL/UL element.
+							dom.split(targetParent, element);
+						} else if (!dom.is(targetParent, 'ol,ul')) {
+							dom.rename(element, 'p');
+						}
+					}
+					outdented.push(element);
+				}
+			}
+			this.process({
+				'LI': outdentLI,
+				defaultAction: this.adjustPaddingFunction(false)
+			});
+			each(outdented, attemptMergeWithAdjacent);
+		},
+		process: function(actions) {
+			var t = this, sel = t.ed.selection, dom = t.ed.dom, selectedBlocks, r;
+			function processElement(element) {
+				dom.removeClass(element, '_mce_act_on');
+				if (!element || element.nodeType !== 1) {
+					return;
+				}
+				element = findItemToOperateOn(element, dom);
+				var action = actions[element.tagName];
+				if (!action) {
+					action = actions.defaultAction;
+				}
+				action(element);
+			}
+			function recurse(element) {
+				t.splitSafeEach(element.childNodes, processElement);
+			}
+			function brAtEdgeOfSelection(container, offset) {
+				return offset >= 0 && container.hasChildNodes() && offset < container.childNodes.length &&
+						container.childNodes[offset].tagName === 'BR';
+			}
+			selectedBlocks = sel.getSelectedBlocks();
+			if (selectedBlocks.length === 0) {
+				selectedBlocks = [ dom.getRoot() ];
+			}
+			r = sel.getRng(true);
+			if (!r.collapsed) {
+				if (brAtEdgeOfSelection(r.endContainer, r.endOffset - 1)) {
+					r.setEnd(r.endContainer, r.endOffset - 1);
+					sel.setRng(r);
+				}
+				if (brAtEdgeOfSelection(r.startContainer, r.startOffset)) {
+					r.setStart(r.startContainer, r.startOffset + 1);
+					sel.setRng(r);
+				}
+			}
+			bookmark = sel.getBookmark();
+			actions.OL = actions.UL = recurse;
+			t.splitSafeEach(selectedBlocks, processElement);
+			sel.moveToBookmark(bookmark);
+			bookmark = null;
+			// Avoids table or image handles being left behind in Firefox.
+			t.ed.execCommand('mceRepaint');
+		},
+		splitSafeEach: function(elements, f) {
+			if (tinymce.isGecko && (/Firefox\/[12]\.[0-9]/.test(navigator.userAgent) ||
+					/Firefox\/3\.[0-4]/.test(navigator.userAgent))) {
+				this.classBasedEach(elements, f);
+			} else {
+				each(elements, f);
+			}
+		},
+		classBasedEach: function(elements, f) {
+			var dom = this.ed.dom, nodes, element;
+			// Mark nodes
+			each(elements, function(element) {
+				dom.addClass(element, '_mce_act_on');
+			});
+			nodes = dom.select('._mce_act_on');
+			while (nodes.length > 0) {
+				element = nodes.shift();
+				dom.removeClass(element, '_mce_act_on');
+				f(element);
+				nodes = dom.select('._mce_act_on');
+			}
+		},
+		adjustPaddingFunction: function(isIndent) {
+			var indentAmount, indentUnits, ed = this.ed;
+			indentAmount = ed.settings.indentation;
+			indentUnits = /[a-z%]+/i.exec(indentAmount);
+			indentAmount = parseInt(indentAmount, 10);
+			return function(element) {
+				var currentIndent, newIndentAmount;
+				currentIndent = parseInt(ed.dom.getStyle(element, 'margin-left') || 0, 10) + parseInt(ed.dom.getStyle(element, 'padding-left') || 0, 10);
+				if (isIndent) {
+					newIndentAmount = currentIndent + indentAmount;
+				} else {
+					newIndentAmount = currentIndent - indentAmount;
+				}
+				ed.dom.setStyle(element, 'padding-left', '');
+				ed.dom.setStyle(element, 'margin-left', newIndentAmount > 0 ? newIndentAmount + indentUnits : '');
+			};
+		},
+		getInfo: function() {
+			return {
+				longname : 'Lists',
+				author : 'Moxiecode Systems AB',
+				authorurl : 'http://tinymce.moxiecode.com',
+				infourl : 'http://wiki.moxiecode.com/index.php/TinyMCE:Plugins/lists',
+				version : tinymce.majorVersion + "." + tinymce.minorVersion
+			};
+		}
+	});
+	tinymce.PluginManager.add("lists", tinymce.plugins.Lists);
+}());