locomotive-aloha-rails 0.20.1

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

@@ -0,0 +1,136 @@
+/*!
+* Aloha Editor
+* Author & Copyright (c) 2010 Gentics Software GmbH
+* aloha-sales@gentics.com
+* Licensed unter the terms of http://www.aloha-editor.com/license.html
+*/
+define(
+[ 'aloha/core', 'aloha/jquery', 'aloha/contenthandlermanager', 'aloha/console', 'vendor/sanitize' ],
+function( Aloha, jQuery, ContentHandlerManager, console ) {
+	
+	
+	var sanitize;
+	
+	// needed minimum sanitize configuration for Aloha itselft
+	/*Aloha.defaults.supports = jQuery.merge(Aloha.defaults.supports, {
+			elements: [ 'br', 'div', 'p', 'span' ]
+	});*/
+	
+	// predefined set of sanitize options if no dynamic or custom config is used
+	if( !Aloha.defaults.sanitize ) {
+		Aloha.defaults.sanitize = {}
+	}
+
+	// very restricted sanitize config
+	Aloha.defaults.sanitize.restricted = {
+		elements: [ 'b', 'em', 'i', 'strong', 'u', 'p', 'span', 'div', 'br' ]
+	}
+
+	// sanitize  config allowing a bit more (no tables)
+	Aloha.defaults.sanitize.basic = {
+		elements: [
+			'a', 'abbr', 'b', 'blockquote', 'br', 'cite', 'code', 'dd', 'dl', 'dt', 'em',
+			'i', 'li', 'ol', 'p', 'pre', 'q', 'small', 'strike', 'strong', 'sub',
+			'sup', 'u', 'ul' ],
+
+		attributes: {
+			'a' : ['href'],
+			'blockquote' : ['cite'],
+			'q' : ['cite'],
+			'abbr': ['title']
+		},
+
+		//add_attributes: {
+			//  'a': {'rel': 'nofollow'}
+		//},
+
+		protocols: {
+			'a' : {'href': ['ftp', 'http', 'https', 'mailto', '__relative__']},
+			'blockquote' : {'cite': ['http', 'https', '__relative__']},
+			'q' : {'cite': ['http', 'https', '__relative__']}
+		}
+	}
+
+	// relaxed sanitize config allows also tables
+	Aloha.defaults.sanitize.relaxed = {
+		elements: [
+			'a', 'abbr', 'b', 'blockquote', 'br', 'caption', 'cite', 'code', 'col',
+			'colgroup', 'dd', 'dl', 'dt', 'em', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+			'i', 'img', 'li', 'ol', 'p', 'pre', 'q', 'small', 'strike', 'strong',
+			'sub', 'sup', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'tr', 'u',
+			'ul', 'span', 'hr', 'object', 'div'
+		],
+
+		attributes: {
+			'a': ['href', 'title', 'id', 'data-gentics-aloha-repository', 'data-gentics-aloha-object-id'],
+			'div': [ 'id', 'class'],
+			'abbr': ['title'],
+			'blockquote': ['cite'],
+			'br': ['class'],
+			'col': ['span', 'width'],
+			'colgroup': ['span', 'width'],
+			'img': ['align', 'alt', 'height', 'src', 'title', 'width', 'class'],
+			'ol': ['start', 'type'],
+			'q': ['cite'],
+			'table': ['summary', 'width'],
+			'td': ['abbr', 'axis', 'colspan', 'rowspan', 'width'],
+			'th': ['abbr', 'axis', 'colspan', 'rowspan', 'scope', 'width'],
+			'ul': ['type']
+		},
+
+		protocols: {
+			'a': {'href': ['ftp', 'http', 'https', 'mailto', '__relative__']},
+			'blockquote': {'cite': ['http', 'https', '__relative__']},
+			'img': {'src' : ['http', 'https', '__relative__']},
+			'q': {'cite': ['http', 'https', '__relative__']}
+		}
+	}
+
+	function initSanitize () {
+		var 
+			filter = [ 'restricted', 'basic', 'relaxed' ],
+			config = Aloha.defaults.supports; // @TODO: needs to be implemented into all plugins
+		
+		// @TODO think about Aloha.settings.contentHandler.sanitize name/options
+		if ( Aloha.settings.contentHandler.sanitize && jQuery.inArray(Aloha.settings.contentHandler.sanitize, filter) > -1 ) {
+			config = eval('Aloha.defaults.sanitize.' + Aloha.settings.contentHandler.sanitize);
+		} else {
+			// use relaxed filter by default
+			config = Aloha.defaults.sanitize.relaxed;
+		}
+		
+		// @TODO move to Aloha.settings.contentHandler.sanitize.allows ?
+		if ( Aloha.settings.contentHandler.allows ) {
+			config = Aloha.settings.contentHandler.allows;
+		}
+
+		// add a filter to stop cleaning elements with contentEditable "false"
+		config.filters = [function( elem ) {
+			return elem.contentEditable != "false";
+		}];
+
+		sanitize = new Sanitize( config );
+	}
+
+	var SanitizeContentHandler = ContentHandlerManager.createHandler({
+		/**
+		 * Handle the content from eg. paste action and sanitize the html
+		 * @param content
+		 */
+		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();
+		}
+	});
+	
+	return SanitizeContentHandler;
+});

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

@@ -0,0 +1,279 @@
+/*!
+* Aloha Editor
+* Author & Copyright (c) 2010 Gentics Software GmbH
+* aloha-sales@gentics.com
+* Licensed unter the terms of http://www.aloha-editor.com/license.html
+*/
+define(
+['aloha', 'aloha/jquery', 'aloha/contenthandlermanager'],
+function( Aloha, jQuery, ContentHandlerManager ) {
+	
+
+	var WordContentHandler = 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>' );
+			} else if ( content instanceof jQuery ) {
+				content = jQuery( '<div>' ).append(content);
+			}
+
+			if (this.detectWordContent(content)) {
+				this.transformWordContent(content);
+			}
+
+			return 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
+		 */
+		detectWordContent: function (content) {
+			var wordDetected = false;
+			// check every element which was pasted.
+
+			content.find('*').each(function() {
+				// get the element style
+				var style = jQuery(this).attr('style'),
+					clazz;
+
+				if (style) {
+					// if 'mso' is found somewhere in the style, we found word content
+					if (style.toLowerCase().indexOf('mso') >= 0) {
+						wordDetected = true;
+						return false;
+					}
+				}
+				// get the element class
+				clazz = jQuery(this).attr('class');
+				if (clazz) {
+					// if 'mso' is found somewhere in the class, we found word content
+					if (clazz.toLowerCase().indexOf('mso') >= 0) {
+						wordDetected = true;
+						return false;
+					}
+				}
+			});
+			// return the result
+			return wordDetected;
+		},
+
+		/**
+		 * Check whether the given list span (first span in a paragraph which shall be a list item) belongs to an ordered list
+		 * @param listSpan
+		 * @return true for ordered lists, false for unordered
+		 */
+		isOrderedList: function(listSpan) {
+			// when the span has fontFamily "Wingdings" it is an unordered list
+			if (listSpan.css('fontFamily') == 'Wingdings' || listSpan.css('fontFamily') == 'Symbol') {
+				return false;
+			}
+			// otherwise check for a number, letter or '(' as first character
+			return listSpan.text().match(/^([0-9]{1,3}\.)|([0-9]{1,3}\)|([a-zA-Z]{1,5}\.)|([a-zA-Z]{1,5}\)))$/) ? true : false;
+		},
+
+		/**
+		 * Transform lists pasted from word
+		 * @param content
+		 */
+		transformListsFromWord: function (content) {
+			var that = this,
+				negateDetectionFilter, detectionFilter, spans,
+				paragraphs, bulletClass, listElementClass;
+
+			// this will be the class to mark paragraphs that will be transformed to lists
+			listElementClass = 'aloha-list-element';
+			bulletClass = 'aloha-list-bullet';
+
+			// first step is to find all paragraphs which will be converted into list elements and mark them by adding the class 'aloha-list-element'
+			detectionFilter = 'p.MsoListParagraphCxSpFirst,p.MsoListParagraph,p span';
+			paragraphs = content.find(detectionFilter);
+			paragraphs.each(function() {
+				var jqElem = jQuery(this),
+					fontFamily = jqElem.css('font-family') || '',
+					msoList = jqElem.css('mso-list') || '',
+					style = jqElem.attr('style') || '';
+
+				// detect special classes
+				if (jqElem.hasClass('MsoListParagraphCxSpFirst') || jqElem.hasClass('MsoListParagraph')) {
+					jqElem.addClass(listElementClass);
+				} else if (fontFamily.indexOf('Symbol') >= 0) {
+					jqElem.closest('p').addClass(listElementClass);
+				} else if (fontFamily.indexOf('Wingdings') >= 0) {
+					jqElem.closest('p').addClass(listElementClass);
+				} else if (msoList !== '') {
+					jqElem.closest('p').addClass(listElementClass);
+				} else if (style.indexOf('mso-list') >= 0) {
+					jqElem.closest('p').addClass(listElementClass);
+				}
+			});
+
+			// now we search for paragraphs with three levels of nested spans, where the innermost span contains nothing but &nbsp;
+			detectionFilter = 'p span span span';
+			spans = content.find(detectionFilter);
+			spans.each(function() {
+				var jqElem = jQuery(this),
+					innerText = jqElem.text().trim().replace(/&nbsp;/g, ''),
+					outerText;
+
+				if (innerText.length === 0) {
+					// check whether the outermost of the three spans contains nothing more than numbering
+					outerText = jqElem.parent().parent().text().trim().replace(/&nbsp;/g, '');
+
+					// patterns for list numbering
+					// 1.
+					// 1)
+					// (1)
+					// a.
+					// a)
+					// I.
+					// i.
+					// o § (or any other single character)
+					if (outerText.match(/^([0-9]{1,3}\.)|([0-9]{1,3}\))|([a-zA-Z]{1,5}\.)|([a-zA-Z]{1,5}\))|(.)$/)) {
+						jqElem.closest('p').addClass(listElementClass);
+						jqElem.parent().parent().addClass(bulletClass);
+					}
+				}
+			});
+
+			// no detect all marked paragraphs and transform into lists
+			detectionFilter = 'p.' + listElementClass;
+			negateDetectionFilter = ':not('+detectionFilter+')';
+			paragraphs = content.find(detectionFilter);
+
+			if (paragraphs.length > 0) {
+				paragraphs.each(function() {
+					var jqElem = jQuery(this),
+						jqNewLi, jqList, ordered, firstSpan, following, lists, margin, nestLevel;
+
+					jqElem.removeClass(listElementClass);
+					// first remove all font tags
+					jqElem.find('font').each(function() {
+						jQuery(this).contents().unwrap();
+					});
+
+					// initialize the nestlevel and the margin (we will try to detect nested
+					// lists by comparing the left margin)
+					nestLevel = [];
+					margin = parseFloat(jqElem.css('marginLeft'));
+					// this array will hold all ul/ol elements
+					lists = [];
+					// get all following list elements
+					following = jqElem.nextUntil(negateDetectionFilter);
+
+					// get the first span in the element
+					firstSpan = jQuery(jqElem.find('span.' + bulletClass));
+					if (firstSpan.length === 0) {
+						firstSpan = jqElem.find('span').eq(0);
+					}
+					// use the span to detect whether the list shall be ordered or unordered
+					ordered = that.isOrderedList(firstSpan);
+					// finally remove the span (numbers, bullets are rendered by the browser)
+					firstSpan.remove();
+
+					// create the list element
+					jqList = jQuery(ordered ? '<ol></ol>' : '<ul></ul>');
+					lists.push(jqList);
+
+					// add a new list item
+					jqNewLi = jQuery('<li></li>');
+					// add the li into the list
+					jqList.append(jqNewLi);
+					// append the contents of the old dom element to the li
+					jqElem.contents().appendTo(jqNewLi);
+					// replace the old dom element with the new list
+					jqElem.replaceWith(jqList);
+
+					// now proceed all following list elements
+					following.each(function() {
+						var jqElem = jQuery(this),
+							newMargin, jqNewList;
+
+						// remove all font tags
+						jqElem.find('font').each(function() {
+							jQuery(this).contents().unwrap();
+						});
+						// check the new margin
+						newMargin = parseFloat(jqElem.css('marginLeft'));
+
+						// get the first span
+						firstSpan = jQuery(jqElem.find('span.' + bulletClass));
+						if (firstSpan.length === 0) {
+							firstSpan = jqElem.find('span').eq(0);
+						}
+						// ... and use it to detect ordered/unordered list elements (this
+						// information will only be used at the start of a new list anyway)
+						ordered = that.isOrderedList(firstSpan);
+						// remove the span
+						firstSpan.remove();
+
+						// check for nested lists by comparing the margins
+						if (newMargin > margin) {
+							// create a new list
+							jqNewList = jQuery(ordered ? '<ol></ol>' : '<ul></ul>');
+							// append the new list to the last list item of the prior list
+							jqList.children(':last').append(jqNewList);
+
+							// store the list and increase the nest level
+							jqList = jqNewList;
+							lists.push(jqList);
+							nestLevel.push(newMargin);
+							margin = newMargin;
+						} else if (newMargin < margin && nestLevel.length > 0) {
+							while(nestLevel.length > 0 && nestLevel[nestLevel.length - 1] > newMargin) {
+								nestLevel.pop();
+								lists.pop();
+							}
+							// end nested list and append element to outer list
+							jqList = lists[lists.length - 1];
+							margin = newMargin;
+						}
+
+						// create a list item
+						jqNewLi = jQuery('<li></li>');
+						// add the li into the list
+						jqList.append(jqNewLi);
+						// append the contents of the old dom element to the li
+						jqElem.contents().appendTo(jqNewLi);
+						// remove the old dom element
+						jqElem.remove();
+					});
+				});
+			}
+		},
+
+		/**
+		 * Transform Title and Subtitle pasted from word
+		 * @param content
+		 */
+		transformTitles: function(content) {
+			content.find('p.MsoTitle').each(function() {
+				// titles will be transformed to h1
+				Aloha.Markup.transformDomObject(jQuery(this), 'h1');
+			});
+			content.find('p.MsoSubtitle').each(function() {
+				// titles will be transformed to h1
+				Aloha.Markup.transformDomObject(jQuery(this), 'h2');
+			});
+		},
+
+		/**
+		 * This is the main transformation method
+		 * @param content
+		 */
+		transformWordContent: function (content) {
+			// transform lists
+			this.transformListsFromWord(content);
+
+			// transform titles
+			this.transformTitles(content);
+		}
+	});
+	
+	return WordContentHandler;
+});

data/vendor/assets/javascripts/aloha/plugins/common/contenthandler/package.json

@@ -0,0 +1 @@
+{}

data/vendor/assets/javascripts/aloha/plugins/common/format/css/format.css

@@ -0,0 +1,8 @@
+/*!
+* Aloha Editor
+* Author & Copyright (c) 2010 Gentics Software GmbH
+* aloha-sales@gentics.com
+* Licensed unter the terms of http://www.aloha-editor.com/license.html
+*/
+button.aloha-button-strong{ background: url(../img/strong.png) no-repeat 0px 0px !important; }
+button.aloha-button-em{ background: url(../img/em.png) no-repeat 0px 0px !important; }

data/vendor/assets/javascripts/aloha/plugins/common/format/lib/format-plugin.js

@@ -0,0 +1,303 @@
+/*!
+* Aloha Editor
+* Author & Copyright (c) 2010 Gentics Software GmbH
+* aloha-sales@gentics.com
+* Licensed unter the terms of http://www.aloha-editor.com/license.html
+*/
+
+define(
+['aloha', 'aloha/plugin', 'aloha/jquery', 'aloha/floatingmenu', 'i18n!format/nls/i18n', 'i18n!aloha/nls/i18n', 'aloha/console',
+ 		'css!format/css/format.css'],
+function(Aloha, Plugin, jQuery, FloatingMenu, i18n, i18nCore) {
+	
+	var
+		GENTICS = window.GENTICS;
+
+	/**
+	 * register the plugin with unique name
+	 */
+	return Plugin.create('format', {
+		/**
+		 * Configure the available languages
+		 */
+		languages: ['en', 'de', 'fr', 'eo', 'fi', 'ru', 'it', 'pl'],
+
+		/**
+		 * default button configuration
+		 */
+		config: [ 'strong', 'em', 'b', 'i','del','sub','sup', 'p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'pre', 'removeFormat'],
+
+		/**
+		 * Initialize the plugin and set initialize flag on true
+		 */
+		init: function () {
+			// Prepare
+			var me = this;
+
+			this.initButtons();
+
+			// apply specific configuration if an editable has been activated
+			Aloha.bind('aloha-editable-activated',function (e, params) {
+				//debugger;
+				me.applyButtonConfig(params.editable.obj);
+			});
+
+			/*
+			Aloha.defaults.supports = jQuery.merge(Aloha.defaults.supports, {
+					elements: [ 'strong', 'em', 'b', 'i','del','sub','sup', 'p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'pre' ]
+			});
+			*/
+
+		},
+
+		/**
+		 * applys a configuration specific for an editable
+		 * buttons not available in this configuration are hidden
+		 * @param {Object} id of the activated editable
+		 * @return void
+		 */
+		applyButtonConfig: function (obj) {
+
+			var config = this.getEditableConfig(obj),
+				button, i, len;
+
+			// now iterate all buttons and show/hide them according to the config
+			for ( button in this.buttons) {
+				if (jQuery.inArray(button, config) != -1) {
+					this.buttons[button].button.show();
+				} else {
+					this.buttons[button].button.hide();
+				}
+			}
+
+			// and the same for multisplit items
+			len = this.multiSplitItems.length;
+			for (i = 0; i < len; i++) {
+				if (jQuery.inArray(this.multiSplitItems[i].name, config) != -1) {
+					this.multiSplitButton.showItem(this.multiSplitItems[i].name);
+				} else {
+					this.multiSplitButton.hideItem(this.multiSplitItems[i].name);
+				}
+			}
+		},
+
+		/**
+		 * initialize the buttons and register them on floating menu
+		 * @param event event object
+		 * @param editable current editable object
+		 */
+		initButtons: function () {
+			var
+				scope = 'Aloha.continuoustext',
+				that = this;
+
+			// reset
+			this.buttons = {};
+
+			// collect the multisplit items here
+			this.multiSplitItems = [];
+			//this.multiSplitButton;
+
+			//iterate configuration array an push buttons to buttons array
+			jQuery.each(this.config, function(j, button) {
+				switch( button ) {
+					// text level semantics:
+					case 'em':
+					case 'strong':
+					case 'b':
+					case 'i':
+					case 'cite':
+					case 'q':
+					case 'code':
+					case 'abbr':
+					case 'del':
+					case 'sub':
+					case 'sup':
+						that.buttons[button] = {'button' : new Aloha.ui.Button({
+							'name' : button,
+							'iconClass' : 'aloha-button aloha-button-' + button,
+							'size' : 'small',
+							'onclick' : function () {
+								var
+									markup = jQuery('<'+button+'></'+button+'>'),
+									rangeObject = Aloha.Selection.rangeObject,
+									foundMarkup;
+
+								// check whether the markup is found in the range (at the start of the range)
+								foundMarkup = rangeObject.findMarkup(function() {
+									return this.nodeName.toLowerCase() == markup.get(0).nodeName.toLowerCase();
+								}, Aloha.activeEditable.obj);
+
+								if (foundMarkup) {
+									// remove the markup
+									if (rangeObject.isCollapsed()) {
+										// when the range is collapsed, we remove exactly the one DOM element
+										GENTICS.Utils.Dom.removeFromDOM(foundMarkup, rangeObject, true);
+									} else {
+										// the range is not collapsed, so we remove the markup from the range
+										GENTICS.Utils.Dom.removeMarkup(rangeObject, markup, Aloha.activeEditable.obj);
+									}
+								} else {
+									// when the range is collapsed, extend it to a word
+									if (rangeObject.isCollapsed()) {
+										GENTICS.Utils.Dom.extendToWord(rangeObject);
+									}
+
+									// add the markup
+									GENTICS.Utils.Dom.addMarkup(rangeObject, markup);
+								}
+								// select the modified range
+								rangeObject.select();
+								return false;
+							},
+							'tooltip' : i18n.t('button.' + button + '.tooltip'),
+							'toggle' : true
+						}), 'markup' : jQuery('<'+button+'></'+button+'>')};
+
+						FloatingMenu.addButton(
+							scope,
+							that.buttons[button].button,
+							i18nCore.t('floatingmenu.tab.format'),
+							1
+						);
+						break;
+
+					case 'p':
+					case 'h1':
+					case 'h2':
+					case 'h3':
+					case 'h4':
+					case 'h5':
+					case 'h6':
+					case 'pre':
+						that.multiSplitItems.push({
+							'name' : button,
+							'tooltip' : i18n.t('button.' + button + '.tooltip'),
+							'iconClass' : 'aloha-button ' + i18n.t('aloha-button-' + button),
+							'markup' : jQuery('<'+button+'></'+button+'>'),
+							'click' : function() {
+								Aloha.Selection.changeMarkupOnSelection(jQuery('<' + button + '></' + button + '>'));
+							}
+						});
+						break;
+
+					// wide multisplit buttons
+					case 'removeFormat':
+						that.multiSplitItems.push({
+							'name' : button,
+							'text' : i18n.t('button.' + button + '.text'),
+							'tooltip' : i18n.t('button.' + button + '.tooltip'),
+							'iconClass' : 'aloha-button aloha-button-' + button,
+							'wide' : true,
+							'click' : function() {
+								that.removeFormat();
+							}
+						});
+						break;
+					//no button defined
+					default:
+						Aloha.log('warn', this, 'Button "' + button + '" is not defined');
+						break;
+				}
+			});
+
+			if (this.multiSplitItems.length > 0) {
+				this.multiSplitButton = new Aloha.ui.MultiSplitButton({
+					'name' : 'phrasing',
+					'items' : this.multiSplitItems
+				});
+				FloatingMenu.addButton(
+					scope,
+					this.multiSplitButton,
+					i18nCore.t('floatingmenu.tab.format'),
+					3
+				);
+			}
+
+			// add the event handler for selection change
+			Aloha.bind('aloha-selection-changed',function(event,rangeObject){
+				// iterate over all buttons
+				var
+					statusWasSet = false, effectiveMarkup,
+					foundMultiSplit, i, j, multiSplitItem;
+
+				jQuery.each(that.buttons, function(index, button) {
+					statusWasSet = false;
+					for ( i = 0; i < rangeObject.markupEffectiveAtStart.length; i++) {
+						effectiveMarkup = rangeObject.markupEffectiveAtStart[ i ];
+						if (Aloha.Selection.standardTextLevelSemanticsComparator(effectiveMarkup, button.markup)) {
+							button.button.setPressed(true);
+							statusWasSet = true;
+						}
+					}
+					if (!statusWasSet) {
+						button.button.setPressed(false);
+					}
+				});
+
+				if (that.multiSplitItems.length > 0) {
+					foundMultiSplit = false;
+
+					// iterate over the markup elements
+					for ( i = 0; i < rangeObject.markupEffectiveAtStart.length && !foundMultiSplit; i++) {
+						effectiveMarkup = rangeObject.markupEffectiveAtStart[ i ];
+
+						for ( j = 0; j < that.multiSplitItems.length && !foundMultiSplit; j++) {
+							multiSplitItem = that.multiSplitItems[j];
+
+							if (!multiSplitItem.markup) {
+								continue;
+							}
+
+							// now check whether one of the multiSplitItems fits to the effective markup
+							if (Aloha.Selection.standardTextLevelSemanticsComparator(effectiveMarkup, multiSplitItem.markup)) {
+								that.multiSplitButton.setActiveItem(multiSplitItem.name);
+								foundMultiSplit = true;
+							}
+						}
+					}
+
+					if (!foundMultiSplit) {
+						that.multiSplitButton.setActiveItem(null);
+					}
+				}
+			});
+
+		},
+
+		/**
+		 * Removes all formatting from the current selection.
+		 */
+		removeFormat: function() {
+			var formats = [ 'strong', 'em', 'b', 'i', 'cite', 'q', 'code', 'abbr', 'del', 'sub', 'sup'],
+				rangeObject = Aloha.Selection.rangeObject,
+				i;
+			
+			// formats to be removed by the removeFormat button may now be configured using Aloha.settings.plugins.format.removeFormats = ['b', 'strong', ...]
+			if (this.settings.removeFormats) {
+				formats = this.settings.removeFormats;
+			}
+
+			if (rangeObject.isCollapsed()) {
+				return;
+			}
+
+			for (i = 0; i < formats.length; i++) {
+				GENTICS.Utils.Dom.removeMarkup(rangeObject, jQuery('<' + formats[i] + '></' + formats[i] + '>'), Aloha.activeEditable.obj);
+			}
+
+			// select the modified range
+			rangeObject.select();
+			// TODO: trigger event - removed Format
+
+		},
+
+		/**
+		* toString method
+		* @return string
+		*/
+		toString: function () {
+			return 'format';
+		}
+	});
+});