scrivito_sdk 1.0.0 → 1.1.0.rc1

data/lib/assets/javascripts/scrivito_ui.js

@@ -11170,6 +11170,1316 @@ $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
 
 return $.widget;
 
+}));
+/*! jQuery UI - v1.11.4 - 2015-08-21
+* http://jqueryui.com
+* Includes: effect.js
+* Copyright 2015 jQuery Foundation and other contributors; Licensed MIT */
+
+
+(function( factory ) {
+	if ( typeof define === "function" && define.amd ) {
+
+		// AMD. Register as an anonymous module.
+		define([ "jquery" ], factory );
+	} else {
+
+		// Browser globals
+		factory( jQuery );
+	}
+}(function( $ ) {
+/*!
+ * jQuery UI Effects 1.11.4
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * http://api.jqueryui.com/category/effects-core/
+ */
+
+
+var dataSpace = "ui-effects-",
+
+	// Create a local jQuery because jQuery Color relies on it and the
+	// global may not exist with AMD and a custom build (#10199)
+	jQuery = $;
+
+$.effects = {
+	effect: {}
+};
+
+/*!
+ * jQuery Color Animations v2.1.2
+ * https://github.com/jquery/jquery-color
+ *
+ * Copyright 2014 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * Date: Wed Jan 16 08:47:09 2013 -0600
+ */
+(function( jQuery, undefined ) {
+
+	var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
+
+	// plusequals test for += 100 -= 100
+	rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
+	// a set of RE's that can match strings and generate color tuples.
+	stringParsers = [ {
+			re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
+			parse: function( execResult ) {
+				return [
+					execResult[ 1 ],
+					execResult[ 2 ],
+					execResult[ 3 ],
+					execResult[ 4 ]
+				];
+			}
+		}, {
+			re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
+			parse: function( execResult ) {
+				return [
+					execResult[ 1 ] * 2.55,
+					execResult[ 2 ] * 2.55,
+					execResult[ 3 ] * 2.55,
+					execResult[ 4 ]
+				];
+			}
+		}, {
+			// this regex ignores A-F because it's compared against an already lowercased string
+			re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
+			parse: function( execResult ) {
+				return [
+					parseInt( execResult[ 1 ], 16 ),
+					parseInt( execResult[ 2 ], 16 ),
+					parseInt( execResult[ 3 ], 16 )
+				];
+			}
+		}, {
+			// this regex ignores A-F because it's compared against an already lowercased string
+			re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
+			parse: function( execResult ) {
+				return [
+					parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
+					parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
+					parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
+				];
+			}
+		}, {
+			re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
+			space: "hsla",
+			parse: function( execResult ) {
+				return [
+					execResult[ 1 ],
+					execResult[ 2 ] / 100,
+					execResult[ 3 ] / 100,
+					execResult[ 4 ]
+				];
+			}
+		} ],
+
+	// jQuery.Color( )
+	color = jQuery.Color = function( color, green, blue, alpha ) {
+		return new jQuery.Color.fn.parse( color, green, blue, alpha );
+	},
+	spaces = {
+		rgba: {
+			props: {
+				red: {
+					idx: 0,
+					type: "byte"
+				},
+				green: {
+					idx: 1,
+					type: "byte"
+				},
+				blue: {
+					idx: 2,
+					type: "byte"
+				}
+			}
+		},
+
+		hsla: {
+			props: {
+				hue: {
+					idx: 0,
+					type: "degrees"
+				},
+				saturation: {
+					idx: 1,
+					type: "percent"
+				},
+				lightness: {
+					idx: 2,
+					type: "percent"
+				}
+			}
+		}
+	},
+	propTypes = {
+		"byte": {
+			floor: true,
+			max: 255
+		},
+		"percent": {
+			max: 1
+		},
+		"degrees": {
+			mod: 360,
+			floor: true
+		}
+	},
+	support = color.support = {},
+
+	// element for support tests
+	supportElem = jQuery( "<p>" )[ 0 ],
+
+	// colors = jQuery.Color.names
+	colors,
+
+	// local aliases of functions called often
+	each = jQuery.each;
+
+// determine rgba support immediately
+supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
+support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
+
+// define cache name and alpha properties
+// for rgba and hsla spaces
+each( spaces, function( spaceName, space ) {
+	space.cache = "_" + spaceName;
+	space.props.alpha = {
+		idx: 3,
+		type: "percent",
+		def: 1
+	};
+});
+
+function clamp( value, prop, allowEmpty ) {
+	var type = propTypes[ prop.type ] || {};
+
+	if ( value == null ) {
+		return (allowEmpty || !prop.def) ? null : prop.def;
+	}
+
+	// ~~ is an short way of doing floor for positive numbers
+	value = type.floor ? ~~value : parseFloat( value );
+
+	// IE will pass in empty strings as value for alpha,
+	// which will hit this case
+	if ( isNaN( value ) ) {
+		return prop.def;
+	}
+
+	if ( type.mod ) {
+		// we add mod before modding to make sure that negatives values
+		// get converted properly: -10 -> 350
+		return (value + type.mod) % type.mod;
+	}
+
+	// for now all property types without mod have min and max
+	return 0 > value ? 0 : type.max < value ? type.max : value;
+}
+
+function stringParse( string ) {
+	var inst = color(),
+		rgba = inst._rgba = [];
+
+	string = string.toLowerCase();
+
+	each( stringParsers, function( i, parser ) {
+		var parsed,
+			match = parser.re.exec( string ),
+			values = match && parser.parse( match ),
+			spaceName = parser.space || "rgba";
+
+		if ( values ) {
+			parsed = inst[ spaceName ]( values );
+
+			// if this was an rgba parse the assignment might happen twice
+			// oh well....
+			inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
+			rgba = inst._rgba = parsed._rgba;
+
+			// exit each( stringParsers ) here because we matched
+			return false;
+		}
+	});
+
+	// Found a stringParser that handled it
+	if ( rgba.length ) {
+
+		// if this came from a parsed string, force "transparent" when alpha is 0
+		// chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
+		if ( rgba.join() === "0,0,0,0" ) {
+			jQuery.extend( rgba, colors.transparent );
+		}
+		return inst;
+	}
+
+	// named colors
+	return colors[ string ];
+}
+
+color.fn = jQuery.extend( color.prototype, {
+	parse: function( red, green, blue, alpha ) {
+		if ( red === undefined ) {
+			this._rgba = [ null, null, null, null ];
+			return this;
+		}
+		if ( red.jquery || red.nodeType ) {
+			red = jQuery( red ).css( green );
+			green = undefined;
+		}
+
+		var inst = this,
+			type = jQuery.type( red ),
+			rgba = this._rgba = [];
+
+		// more than 1 argument specified - assume ( red, green, blue, alpha )
+		if ( green !== undefined ) {
+			red = [ red, green, blue, alpha ];
+			type = "array";
+		}
+
+		if ( type === "string" ) {
+			return this.parse( stringParse( red ) || colors._default );
+		}
+
+		if ( type === "array" ) {
+			each( spaces.rgba.props, function( key, prop ) {
+				rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
+			});
+			return this;
+		}
+
+		if ( type === "object" ) {
+			if ( red instanceof color ) {
+				each( spaces, function( spaceName, space ) {
+					if ( red[ space.cache ] ) {
+						inst[ space.cache ] = red[ space.cache ].slice();
+					}
+				});
+			} else {
+				each( spaces, function( spaceName, space ) {
+					var cache = space.cache;
+					each( space.props, function( key, prop ) {
+
+						// if the cache doesn't exist, and we know how to convert
+						if ( !inst[ cache ] && space.to ) {
+
+							// if the value was null, we don't need to copy it
+							// if the key was alpha, we don't need to copy it either
+							if ( key === "alpha" || red[ key ] == null ) {
+								return;
+							}
+							inst[ cache ] = space.to( inst._rgba );
+						}
+
+						// this is the only case where we allow nulls for ALL properties.
+						// call clamp with alwaysAllowEmpty
+						inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
+					});
+
+					// everything defined but alpha?
+					if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
+						// use the default of 1
+						inst[ cache ][ 3 ] = 1;
+						if ( space.from ) {
+							inst._rgba = space.from( inst[ cache ] );
+						}
+					}
+				});
+			}
+			return this;
+		}
+	},
+	is: function( compare ) {
+		var is = color( compare ),
+			same = true,
+			inst = this;
+
+		each( spaces, function( _, space ) {
+			var localCache,
+				isCache = is[ space.cache ];
+			if (isCache) {
+				localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
+				each( space.props, function( _, prop ) {
+					if ( isCache[ prop.idx ] != null ) {
+						same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
+						return same;
+					}
+				});
+			}
+			return same;
+		});
+		return same;
+	},
+	_space: function() {
+		var used = [],
+			inst = this;
+		each( spaces, function( spaceName, space ) {
+			if ( inst[ space.cache ] ) {
+				used.push( spaceName );
+			}
+		});
+		return used.pop();
+	},
+	transition: function( other, distance ) {
+		var end = color( other ),
+			spaceName = end._space(),
+			space = spaces[ spaceName ],
+			startColor = this.alpha() === 0 ? color( "transparent" ) : this,
+			start = startColor[ space.cache ] || space.to( startColor._rgba ),
+			result = start.slice();
+
+		end = end[ space.cache ];
+		each( space.props, function( key, prop ) {
+			var index = prop.idx,
+				startValue = start[ index ],
+				endValue = end[ index ],
+				type = propTypes[ prop.type ] || {};
+
+			// if null, don't override start value
+			if ( endValue === null ) {
+				return;
+			}
+			// if null - use end
+			if ( startValue === null ) {
+				result[ index ] = endValue;
+			} else {
+				if ( type.mod ) {
+					if ( endValue - startValue > type.mod / 2 ) {
+						startValue += type.mod;
+					} else if ( startValue - endValue > type.mod / 2 ) {
+						startValue -= type.mod;
+					}
+				}
+				result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
+			}
+		});
+		return this[ spaceName ]( result );
+	},
+	blend: function( opaque ) {
+		// if we are already opaque - return ourself
+		if ( this._rgba[ 3 ] === 1 ) {
+			return this;
+		}
+
+		var rgb = this._rgba.slice(),
+			a = rgb.pop(),
+			blend = color( opaque )._rgba;
+
+		return color( jQuery.map( rgb, function( v, i ) {
+			return ( 1 - a ) * blend[ i ] + a * v;
+		}));
+	},
+	toRgbaString: function() {
+		var prefix = "rgba(",
+			rgba = jQuery.map( this._rgba, function( v, i ) {
+				return v == null ? ( i > 2 ? 1 : 0 ) : v;
+			});
+
+		if ( rgba[ 3 ] === 1 ) {
+			rgba.pop();
+			prefix = "rgb(";
+		}
+
+		return prefix + rgba.join() + ")";
+	},
+	toHslaString: function() {
+		var prefix = "hsla(",
+			hsla = jQuery.map( this.hsla(), function( v, i ) {
+				if ( v == null ) {
+					v = i > 2 ? 1 : 0;
+				}
+
+				// catch 1 and 2
+				if ( i && i < 3 ) {
+					v = Math.round( v * 100 ) + "%";
+				}
+				return v;
+			});
+
+		if ( hsla[ 3 ] === 1 ) {
+			hsla.pop();
+			prefix = "hsl(";
+		}
+		return prefix + hsla.join() + ")";
+	},
+	toHexString: function( includeAlpha ) {
+		var rgba = this._rgba.slice(),
+			alpha = rgba.pop();
+
+		if ( includeAlpha ) {
+			rgba.push( ~~( alpha * 255 ) );
+		}
+
+		return "#" + jQuery.map( rgba, function( v ) {
+
+			// default to 0 when nulls exist
+			v = ( v || 0 ).toString( 16 );
+			return v.length === 1 ? "0" + v : v;
+		}).join("");
+	},
+	toString: function() {
+		return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
+	}
+});
+color.fn.parse.prototype = color.fn;
+
+// hsla conversions adapted from:
+// https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
+
+function hue2rgb( p, q, h ) {
+	h = ( h + 1 ) % 1;
+	if ( h * 6 < 1 ) {
+		return p + ( q - p ) * h * 6;
+	}
+	if ( h * 2 < 1) {
+		return q;
+	}
+	if ( h * 3 < 2 ) {
+		return p + ( q - p ) * ( ( 2 / 3 ) - h ) * 6;
+	}
+	return p;
+}
+
+spaces.hsla.to = function( rgba ) {
+	if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
+		return [ null, null, null, rgba[ 3 ] ];
+	}
+	var r = rgba[ 0 ] / 255,
+		g = rgba[ 1 ] / 255,
+		b = rgba[ 2 ] / 255,
+		a = rgba[ 3 ],
+		max = Math.max( r, g, b ),
+		min = Math.min( r, g, b ),
+		diff = max - min,
+		add = max + min,
+		l = add * 0.5,
+		h, s;
+
+	if ( min === max ) {
+		h = 0;
+	} else if ( r === max ) {
+		h = ( 60 * ( g - b ) / diff ) + 360;
+	} else if ( g === max ) {
+		h = ( 60 * ( b - r ) / diff ) + 120;
+	} else {
+		h = ( 60 * ( r - g ) / diff ) + 240;
+	}
+
+	// chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
+	// otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
+	if ( diff === 0 ) {
+		s = 0;
+	} else if ( l <= 0.5 ) {
+		s = diff / add;
+	} else {
+		s = diff / ( 2 - add );
+	}
+	return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
+};
+
+spaces.hsla.from = function( hsla ) {
+	if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
+		return [ null, null, null, hsla[ 3 ] ];
+	}
+	var h = hsla[ 0 ] / 360,
+		s = hsla[ 1 ],
+		l = hsla[ 2 ],
+		a = hsla[ 3 ],
+		q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
+		p = 2 * l - q;
+
+	return [
+		Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
+		Math.round( hue2rgb( p, q, h ) * 255 ),
+		Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
+		a
+	];
+};
+
+each( spaces, function( spaceName, space ) {
+	var props = space.props,
+		cache = space.cache,
+		to = space.to,
+		from = space.from;
+
+	// makes rgba() and hsla()
+	color.fn[ spaceName ] = function( value ) {
+
+		// generate a cache for this space if it doesn't exist
+		if ( to && !this[ cache ] ) {
+			this[ cache ] = to( this._rgba );
+		}
+		if ( value === undefined ) {
+			return this[ cache ].slice();
+		}
+
+		var ret,
+			type = jQuery.type( value ),
+			arr = ( type === "array" || type === "object" ) ? value : arguments,
+			local = this[ cache ].slice();
+
+		each( props, function( key, prop ) {
+			var val = arr[ type === "object" ? key : prop.idx ];
+			if ( val == null ) {
+				val = local[ prop.idx ];
+			}
+			local[ prop.idx ] = clamp( val, prop );
+		});
+
+		if ( from ) {
+			ret = color( from( local ) );
+			ret[ cache ] = local;
+			return ret;
+		} else {
+			return color( local );
+		}
+	};
+
+	// makes red() green() blue() alpha() hue() saturation() lightness()
+	each( props, function( key, prop ) {
+		// alpha is included in more than one space
+		if ( color.fn[ key ] ) {
+			return;
+		}
+		color.fn[ key ] = function( value ) {
+			var vtype = jQuery.type( value ),
+				fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
+				local = this[ fn ](),
+				cur = local[ prop.idx ],
+				match;
+
+			if ( vtype === "undefined" ) {
+				return cur;
+			}
+
+			if ( vtype === "function" ) {
+				value = value.call( this, cur );
+				vtype = jQuery.type( value );
+			}
+			if ( value == null && prop.empty ) {
+				return this;
+			}
+			if ( vtype === "string" ) {
+				match = rplusequals.exec( value );
+				if ( match ) {
+					value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
+				}
+			}
+			local[ prop.idx ] = value;
+			return this[ fn ]( local );
+		};
+	});
+});
+
+// add cssHook and .fx.step function for each named hook.
+// accept a space separated string of properties
+color.hook = function( hook ) {
+	var hooks = hook.split( " " );
+	each( hooks, function( i, hook ) {
+		jQuery.cssHooks[ hook ] = {
+			set: function( elem, value ) {
+				var parsed, curElem,
+					backgroundColor = "";
+
+				if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
+					value = color( parsed || value );
+					if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
+						curElem = hook === "backgroundColor" ? elem.parentNode : elem;
+						while (
+							(backgroundColor === "" || backgroundColor === "transparent") &&
+							curElem && curElem.style
+						) {
+							try {
+								backgroundColor = jQuery.css( curElem, "backgroundColor" );
+								curElem = curElem.parentNode;
+							} catch ( e ) {
+							}
+						}
+
+						value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
+							backgroundColor :
+							"_default" );
+					}
+
+					value = value.toRgbaString();
+				}
+				try {
+					elem.style[ hook ] = value;
+				} catch ( e ) {
+					// wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
+				}
+			}
+		};
+		jQuery.fx.step[ hook ] = function( fx ) {
+			if ( !fx.colorInit ) {
+				fx.start = color( fx.elem, hook );
+				fx.end = color( fx.end );
+				fx.colorInit = true;
+			}
+			jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
+		};
+	});
+
+};
+
+color.hook( stepHooks );
+
+jQuery.cssHooks.borderColor = {
+	expand: function( value ) {
+		var expanded = {};
+
+		each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
+			expanded[ "border" + part + "Color" ] = value;
+		});
+		return expanded;
+	}
+};
+
+// Basic color names only.
+// Usage of any of the other color names requires adding yourself or including
+// jquery.color.svg-names.js.
+colors = jQuery.Color.names = {
+	// 4.1. Basic color keywords
+	aqua: "#00ffff",
+	black: "#000000",
+	blue: "#0000ff",
+	fuchsia: "#ff00ff",
+	gray: "#808080",
+	green: "#008000",
+	lime: "#00ff00",
+	maroon: "#800000",
+	navy: "#000080",
+	olive: "#808000",
+	purple: "#800080",
+	red: "#ff0000",
+	silver: "#c0c0c0",
+	teal: "#008080",
+	white: "#ffffff",
+	yellow: "#ffff00",
+
+	// 4.2.3. "transparent" color keyword
+	transparent: [ null, null, null, 0 ],
+
+	_default: "#ffffff"
+};
+
+})( jQuery );
+
+/******************************************************************************/
+/****************************** CLASS ANIMATIONS ******************************/
+/******************************************************************************/
+(function() {
+
+var classAnimationActions = [ "add", "remove", "toggle" ],
+	shorthandStyles = {
+		border: 1,
+		borderBottom: 1,
+		borderColor: 1,
+		borderLeft: 1,
+		borderRight: 1,
+		borderTop: 1,
+		borderWidth: 1,
+		margin: 1,
+		padding: 1
+	};
+
+$.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
+	$.fx.step[ prop ] = function( fx ) {
+		if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
+			jQuery.style( fx.elem, prop, fx.end );
+			fx.setAttr = true;
+		}
+	};
+});
+
+function getElementStyles( elem ) {
+	var key, len,
+		style = elem.ownerDocument.defaultView ?
+			elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
+			elem.currentStyle,
+		styles = {};
+
+	if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
+		len = style.length;
+		while ( len-- ) {
+			key = style[ len ];
+			if ( typeof style[ key ] === "string" ) {
+				styles[ $.camelCase( key ) ] = style[ key ];
+			}
+		}
+	// support: Opera, IE <9
+	} else {
+		for ( key in style ) {
+			if ( typeof style[ key ] === "string" ) {
+				styles[ key ] = style[ key ];
+			}
+		}
+	}
+
+	return styles;
+}
+
+function styleDifference( oldStyle, newStyle ) {
+	var diff = {},
+		name, value;
+
+	for ( name in newStyle ) {
+		value = newStyle[ name ];
+		if ( oldStyle[ name ] !== value ) {
+			if ( !shorthandStyles[ name ] ) {
+				if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
+					diff[ name ] = value;
+				}
+			}
+		}
+	}
+
+	return diff;
+}
+
+// support: jQuery <1.8
+if ( !$.fn.addBack ) {
+	$.fn.addBack = function( selector ) {
+		return this.add( selector == null ?
+			this.prevObject : this.prevObject.filter( selector )
+		);
+	};
+}
+
+$.effects.animateClass = function( value, duration, easing, callback ) {
+	var o = $.speed( duration, easing, callback );
+
+	return this.queue( function() {
+		var animated = $( this ),
+			baseClass = animated.attr( "class" ) || "",
+			applyClassChange,
+			allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
+
+		// map the animated objects to store the original styles.
+		allAnimations = allAnimations.map(function() {
+			var el = $( this );
+			return {
+				el: el,
+				start: getElementStyles( this )
+			};
+		});
+
+		// apply class change
+		applyClassChange = function() {
+			$.each( classAnimationActions, function(i, action) {
+				if ( value[ action ] ) {
+					animated[ action + "Class" ]( value[ action ] );
+				}
+			});
+		};
+		applyClassChange();
+
+		// map all animated objects again - calculate new styles and diff
+		allAnimations = allAnimations.map(function() {
+			this.end = getElementStyles( this.el[ 0 ] );
+			this.diff = styleDifference( this.start, this.end );
+			return this;
+		});
+
+		// apply original class
+		animated.attr( "class", baseClass );
+
+		// map all animated objects again - this time collecting a promise
+		allAnimations = allAnimations.map(function() {
+			var styleInfo = this,
+				dfd = $.Deferred(),
+				opts = $.extend({}, o, {
+					queue: false,
+					complete: function() {
+						dfd.resolve( styleInfo );
+					}
+				});
+
+			this.el.animate( this.diff, opts );
+			return dfd.promise();
+		});
+
+		// once all animations have completed:
+		$.when.apply( $, allAnimations.get() ).done(function() {
+
+			// set the final class
+			applyClassChange();
+
+			// for each animated element,
+			// clear all css properties that were animated
+			$.each( arguments, function() {
+				var el = this.el;
+				$.each( this.diff, function(key) {
+					el.css( key, "" );
+				});
+			});
+
+			// this is guarnteed to be there if you use jQuery.speed()
+			// it also handles dequeuing the next anim...
+			o.complete.call( animated[ 0 ] );
+		});
+	});
+};
+
+$.fn.extend({
+	addClass: (function( orig ) {
+		return function( classNames, speed, easing, callback ) {
+			return speed ?
+				$.effects.animateClass.call( this,
+					{ add: classNames }, speed, easing, callback ) :
+				orig.apply( this, arguments );
+		};
+	})( $.fn.addClass ),
+
+	removeClass: (function( orig ) {
+		return function( classNames, speed, easing, callback ) {
+			return arguments.length > 1 ?
+				$.effects.animateClass.call( this,
+					{ remove: classNames }, speed, easing, callback ) :
+				orig.apply( this, arguments );
+		};
+	})( $.fn.removeClass ),
+
+	toggleClass: (function( orig ) {
+		return function( classNames, force, speed, easing, callback ) {
+			if ( typeof force === "boolean" || force === undefined ) {
+				if ( !speed ) {
+					// without speed parameter
+					return orig.apply( this, arguments );
+				} else {
+					return $.effects.animateClass.call( this,
+						(force ? { add: classNames } : { remove: classNames }),
+						speed, easing, callback );
+				}
+			} else {
+				// without force parameter
+				return $.effects.animateClass.call( this,
+					{ toggle: classNames }, force, speed, easing );
+			}
+		};
+	})( $.fn.toggleClass ),
+
+	switchClass: function( remove, add, speed, easing, callback) {
+		return $.effects.animateClass.call( this, {
+			add: add,
+			remove: remove
+		}, speed, easing, callback );
+	}
+});
+
+})();
+
+/******************************************************************************/
+/*********************************** EFFECTS **********************************/
+/******************************************************************************/
+
+(function() {
+
+$.extend( $.effects, {
+	version: "1.11.4",
+
+	// Saves a set of properties in a data storage
+	save: function( element, set ) {
+		for ( var i = 0; i < set.length; i++ ) {
+			if ( set[ i ] !== null ) {
+				element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
+			}
+		}
+	},
+
+	// Restores a set of previously saved properties from a data storage
+	restore: function( element, set ) {
+		var val, i;
+		for ( i = 0; i < set.length; i++ ) {
+			if ( set[ i ] !== null ) {
+				val = element.data( dataSpace + set[ i ] );
+				// support: jQuery 1.6.2
+				// http://bugs.jquery.com/ticket/9917
+				// jQuery 1.6.2 incorrectly returns undefined for any falsy value.
+				// We can't differentiate between "" and 0 here, so we just assume
+				// empty string since it's likely to be a more common value...
+				if ( val === undefined ) {
+					val = "";
+				}
+				element.css( set[ i ], val );
+			}
+		}
+	},
+
+	setMode: function( el, mode ) {
+		if (mode === "toggle") {
+			mode = el.is( ":hidden" ) ? "show" : "hide";
+		}
+		return mode;
+	},
+
+	// Translates a [top,left] array into a baseline value
+	// this should be a little more flexible in the future to handle a string & hash
+	getBaseline: function( origin, original ) {
+		var y, x;
+		switch ( origin[ 0 ] ) {
+			case "top": y = 0; break;
+			case "middle": y = 0.5; break;
+			case "bottom": y = 1; break;
+			default: y = origin[ 0 ] / original.height;
+		}
+		switch ( origin[ 1 ] ) {
+			case "left": x = 0; break;
+			case "center": x = 0.5; break;
+			case "right": x = 1; break;
+			default: x = origin[ 1 ] / original.width;
+		}
+		return {
+			x: x,
+			y: y
+		};
+	},
+
+	// Wraps the element around a wrapper that copies position properties
+	createWrapper: function( element ) {
+
+		// if the element is already wrapped, return it
+		if ( element.parent().is( ".ui-effects-wrapper" )) {
+			return element.parent();
+		}
+
+		// wrap the element
+		var props = {
+				width: element.outerWidth(true),
+				height: element.outerHeight(true),
+				"float": element.css( "float" )
+			},
+			wrapper = $( "<div></div>" )
+				.addClass( "ui-effects-wrapper" )
+				.css({
+					fontSize: "100%",
+					background: "transparent",
+					border: "none",
+					margin: 0,
+					padding: 0
+				}),
+			// Store the size in case width/height are defined in % - Fixes #5245
+			size = {
+				width: element.width(),
+				height: element.height()
+			},
+			active = document.activeElement;
+
+		// support: Firefox
+		// Firefox incorrectly exposes anonymous content
+		// https://bugzilla.mozilla.org/show_bug.cgi?id=561664
+		try {
+			active.id;
+		} catch ( e ) {
+			active = document.body;
+		}
+
+		element.wrap( wrapper );
+
+		// Fixes #7595 - Elements lose focus when wrapped.
+		if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
+			$( active ).focus();
+		}
+
+		wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
+
+		// transfer positioning properties to the wrapper
+		if ( element.css( "position" ) === "static" ) {
+			wrapper.css({ position: "relative" });
+			element.css({ position: "relative" });
+		} else {
+			$.extend( props, {
+				position: element.css( "position" ),
+				zIndex: element.css( "z-index" )
+			});
+			$.each([ "top", "left", "bottom", "right" ], function(i, pos) {
+				props[ pos ] = element.css( pos );
+				if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
+					props[ pos ] = "auto";
+				}
+			});
+			element.css({
+				position: "relative",
+				top: 0,
+				left: 0,
+				right: "auto",
+				bottom: "auto"
+			});
+		}
+		element.css(size);
+
+		return wrapper.css( props ).show();
+	},
+
+	removeWrapper: function( element ) {
+		var active = document.activeElement;
+
+		if ( element.parent().is( ".ui-effects-wrapper" ) ) {
+			element.parent().replaceWith( element );
+
+			// Fixes #7595 - Elements lose focus when wrapped.
+			if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
+				$( active ).focus();
+			}
+		}
+
+		return element;
+	},
+
+	setTransition: function( element, list, factor, value ) {
+		value = value || {};
+		$.each( list, function( i, x ) {
+			var unit = element.cssUnit( x );
+			if ( unit[ 0 ] > 0 ) {
+				value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
+			}
+		});
+		return value;
+	}
+});
+
+// return an effect options object for the given parameters:
+function _normalizeArguments( effect, options, speed, callback ) {
+
+	// allow passing all options as the first parameter
+	if ( $.isPlainObject( effect ) ) {
+		options = effect;
+		effect = effect.effect;
+	}
+
+	// convert to an object
+	effect = { effect: effect };
+
+	// catch (effect, null, ...)
+	if ( options == null ) {
+		options = {};
+	}
+
+	// catch (effect, callback)
+	if ( $.isFunction( options ) ) {
+		callback = options;
+		speed = null;
+		options = {};
+	}
+
+	// catch (effect, speed, ?)
+	if ( typeof options === "number" || $.fx.speeds[ options ] ) {
+		callback = speed;
+		speed = options;
+		options = {};
+	}
+
+	// catch (effect, options, callback)
+	if ( $.isFunction( speed ) ) {
+		callback = speed;
+		speed = null;
+	}
+
+	// add options to effect
+	if ( options ) {
+		$.extend( effect, options );
+	}
+
+	speed = speed || options.duration;
+	effect.duration = $.fx.off ? 0 :
+		typeof speed === "number" ? speed :
+		speed in $.fx.speeds ? $.fx.speeds[ speed ] :
+		$.fx.speeds._default;
+
+	effect.complete = callback || options.complete;
+
+	return effect;
+}
+
+function standardAnimationOption( option ) {
+	// Valid standard speeds (nothing, number, named speed)
+	if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
+		return true;
+	}
+
+	// Invalid strings - treat as "normal" speed
+	if ( typeof option === "string" && !$.effects.effect[ option ] ) {
+		return true;
+	}
+
+	// Complete callback
+	if ( $.isFunction( option ) ) {
+		return true;
+	}
+
+	// Options hash (but not naming an effect)
+	if ( typeof option === "object" && !option.effect ) {
+		return true;
+	}
+
+	// Didn't match any standard API
+	return false;
+}
+
+$.fn.extend({
+	effect: function( /* effect, options, speed, callback */ ) {
+		var args = _normalizeArguments.apply( this, arguments ),
+			mode = args.mode,
+			queue = args.queue,
+			effectMethod = $.effects.effect[ args.effect ];
+
+		if ( $.fx.off || !effectMethod ) {
+			// delegate to the original method (e.g., .show()) if possible
+			if ( mode ) {
+				return this[ mode ]( args.duration, args.complete );
+			} else {
+				return this.each( function() {
+					if ( args.complete ) {
+						args.complete.call( this );
+					}
+				});
+			}
+		}
+
+		function run( next ) {
+			var elem = $( this ),
+				complete = args.complete,
+				mode = args.mode;
+
+			function done() {
+				if ( $.isFunction( complete ) ) {
+					complete.call( elem[0] );
+				}
+				if ( $.isFunction( next ) ) {
+					next();
+				}
+			}
+
+			// If the element already has the correct final state, delegate to
+			// the core methods so the internal tracking of "olddisplay" works.
+			if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
+				elem[ mode ]();
+				done();
+			} else {
+				effectMethod.call( elem[0], args, done );
+			}
+		}
+
+		return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
+	},
+
+	show: (function( orig ) {
+		return function( option ) {
+			if ( standardAnimationOption( option ) ) {
+				return orig.apply( this, arguments );
+			} else {
+				var args = _normalizeArguments.apply( this, arguments );
+				args.mode = "show";
+				return this.effect.call( this, args );
+			}
+		};
+	})( $.fn.show ),
+
+	hide: (function( orig ) {
+		return function( option ) {
+			if ( standardAnimationOption( option ) ) {
+				return orig.apply( this, arguments );
+			} else {
+				var args = _normalizeArguments.apply( this, arguments );
+				args.mode = "hide";
+				return this.effect.call( this, args );
+			}
+		};
+	})( $.fn.hide ),
+
+	toggle: (function( orig ) {
+		return function( option ) {
+			if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
+				return orig.apply( this, arguments );
+			} else {
+				var args = _normalizeArguments.apply( this, arguments );
+				args.mode = "toggle";
+				return this.effect.call( this, args );
+			}
+		};
+	})( $.fn.toggle ),
+
+	// helper functions
+	cssUnit: function(key) {
+		var style = this.css( key ),
+			val = [];
+
+		$.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
+			if ( style.indexOf( unit ) > 0 ) {
+				val = [ parseFloat( style ), unit ];
+			}
+		});
+		return val;
+	}
+});
+
+})();
+
+/******************************************************************************/
+/*********************************** EASING ***********************************/
+/******************************************************************************/
+
+(function() {
+
+// based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
+
+var baseEasings = {};
+
+$.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
+	baseEasings[ name ] = function( p ) {
+		return Math.pow( p, i + 2 );
+	};
+});
+
+$.extend( baseEasings, {
+	Sine: function( p ) {
+		return 1 - Math.cos( p * Math.PI / 2 );
+	},
+	Circ: function( p ) {
+		return 1 - Math.sqrt( 1 - p * p );
+	},
+	Elastic: function( p ) {
+		return p === 0 || p === 1 ? p :
+			-Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
+	},
+	Back: function( p ) {
+		return p * p * ( 3 * p - 2 );
+	},
+	Bounce: function( p ) {
+		var pow2,
+			bounce = 4;
+
+		while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
+		return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
+	}
+});
+
+$.each( baseEasings, function( name, easeIn ) {
+	$.easing[ "easeIn" + name ] = easeIn;
+	$.easing[ "easeOut" + name ] = function( p ) {
+		return 1 - easeIn( 1 - p );
+	};
+	$.easing[ "easeInOut" + name ] = function( p ) {
+		return p < 0.5 ?
+			easeIn( p * 2 ) / 2 :
+			1 - easeIn( p * -2 + 2 ) / 2;
+	};
+});
+
+})();
+
+var effect = $.effects;
+
+
+
 }));
 /*!
  * jQuery UI Mouse 1.11.4
@@ -26722,6 +28032,62 @@ helpers = helpers || Handlebars.helpers; data = data || {};
   });
   return this.ScrivitoHandlebarsTemplates["element_overlay"];
 }).call(this);
+(function() {
+  this.ScrivitoHandlebarsTemplates || (this.ScrivitoHandlebarsTemplates = {});
+  this.ScrivitoHandlebarsTemplates["error_dialog"] = Handlebars.template(function (Handlebars,depth0,helpers,partials,data) {
+  this.compilerInfo = [3,'>= 1.0.0-rc.4'];
+helpers = helpers || Handlebars.helpers; data = data || {};
+  var buffer = "", stack1, options, helperMissing=helpers.helperMissing, escapeExpression=this.escapeExpression, functionType="function", self=this;
+
+function program1(depth0,data) {
+  
+  var buffer = "", stack1, options;
+  buffer += "\n        <a class=\"scrivito_toggle_details\" href=\"#\">";
+  options = {hash:{},data:data};
+  buffer += escapeExpression(((stack1 = helpers.translate),stack1 ? stack1.call(depth0, "error_dialog.toggle_details", options) : helperMissing.call(depth0, "translate", "error_dialog.toggle_details", options)))
+    + "</a>\n      ";
+  return buffer;
+  }
+
+function program3(depth0,data) {
+  
+  var buffer = "", stack1, stack2, options;
+  buffer += "\n    <div class=\"scrivito_modal_body\" style=\"display:none\">\n      <h4>";
+  options = {hash:{},data:data};
+  buffer += escapeExpression(((stack1 = helpers.translate),stack1 ? stack1.call(depth0, "error_dialog.error_details", options) : helperMissing.call(depth0, "translate", "error_dialog.error_details", options)))
+    + ":</h4>\n      ";
+  stack2 = helpers.each.call(depth0, depth0.details, {hash:{},inverse:self.noop,fn:self.program(4, program4, data),data:data});
+  if(stack2 || stack2 === 0) { buffer += stack2; }
+  buffer += "\n    </div>\n  ";
+  return buffer;
+  }
+function program4(depth0,data) {
+  
+  var buffer = "";
+  buffer += "\n        <div>"
+    + escapeExpression((typeof depth0 === functionType ? depth0.apply(depth0) : depth0))
+    + "</div>\n      ";
+  return buffer;
+  }
+
+  buffer += "<div class=\"scrivito_error_dialog scrivito_modal_prompt scrivito_center_dialog scrivito_yellow\">\n  <div class=\"scrivito_modal_header\">\n    <i class=\"scrivito_icon\">&#xf01e;</i>\n    <h3 class=\"scrivito_title\">\n      ";
+  if (stack1 = helpers.message) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0.message; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  buffer += escapeExpression(stack1)
+    + "\n      ";
+  stack1 = helpers['if'].call(depth0, depth0.details, {hash:{},inverse:self.noop,fn:self.program(1, program1, data),data:data});
+  if(stack1 || stack1 === 0) { buffer += stack1; }
+  buffer += "\n    </h3>\n  </div>\n\n  ";
+  stack1 = helpers['if'].call(depth0, depth0.details, {hash:{},inverse:self.noop,fn:self.program(3, program3, data),data:data});
+  if(stack1 || stack1 === 0) { buffer += stack1; }
+  buffer += "\n\n  <div class=\"scrivito_modal_footer\">\n    <a href=\"#\" class=\"scrivito_button scrivito_close\">";
+  options = {hash:{},data:data};
+  buffer += escapeExpression(((stack1 = helpers.translate),stack1 ? stack1.call(depth0, "close", options) : helperMissing.call(depth0, "translate", "close", options)))
+    + "</a>\n  </div>\n</div>\n";
+  return buffer;
+  });
+  return this.ScrivitoHandlebarsTemplates["error_dialog"];
+}).call(this);
 (function() {
   this.ScrivitoHandlebarsTemplates || (this.ScrivitoHandlebarsTemplates = {});
   this.ScrivitoHandlebarsTemplates["iframe_dialog"] = Handlebars.template(function (Handlebars,depth0,helpers,partials,data) {
@@ -27991,6 +29357,9 @@ $.i18n().load({
   'current_page_link_dialog.title': 'Diese Seite teilen',
   'current_page_link_dialog.description': 'Mit dieser URL können Sie die aktuelle Seite als Teil dieser Arbeitskopie teilen. Die Empfänger müssen angemeldet sein und Zugriff auf die Arbeitskopie haben.',
 
+  'error_dialog.toggle_details': 'Technische Details',
+  'error_dialog.error_details': 'Technische Details',
+
   'commands.current_page_link.title': 'Diese Seite teilen',
   'commands.current_page_link.is_deleted': 'Eine gelöschte Seite kann nicht geteilt werden, weil sie in der Vorschau nicht zugänglich ist',
 
@@ -28001,11 +29370,13 @@ $.i18n().load({
   'commands.create_workspace.dialog.placeholder': 'Neuer Titel',
   'commands.create_workspace.dialog.accept': 'Anlegen',
 
+  'commands.rename_workspace.forbidden': 'Die Arbeitskopie kann aufgrund fehlender Benutzerrechte nicht umbenannt werden.',
   'commands.rename_workspace.title': 'Umbenennen',
   'commands.rename_workspace.dialog.title': '"$1" umbenennen',
   'commands.rename_workspace.dialog.description': 'Bitte geben Sie den neuen Titel der Arbeitskopie ein.',
   'commands.rename_workspace.dialog.accept': 'Umbenennen',
 
+  'commands.rebase_workspace.forbidden': 'Die Arbeitskopie kann aufgrund fehlender Benutzerrechte nicht aktualisiert werden.',
   'commands.rebase_workspace.title': 'Aktualisieren',
   'commands.rebase_workspace.tooltip': 'Arbeitskopie "$1" is veraltet. Bitte aktualisieren Sie sie.',
   'commands.rebase_workspace.uptodate': 'Arbeitskopie "$1" muss nicht aktualisiert werden.',
@@ -28013,11 +29384,13 @@ $.i18n().load({
   'commands.rebase_workspace.has_conflicts.description': 'Ihre Arbeitskopie konnte nicht vollständig aktualisiert werden. Einige Inhalte wurden auch in einer anderen Arbeitskopie geändert, die inzwischen veröffentlicht wurde. Bitte entnehmen Sie die Details der Liste der Änderungen.',
   'commands.rebase_workspace.open_changes_dialog': 'Änderungen anzeigen',
 
+  'commands.delete_workspace.forbidden': 'Die Arbeitskopie kann aufgrund fehlender Benutzerrechte nicht gelöscht werden.',
   'commands.delete_workspace.title': 'Löschen',
   'commands.delete_workspace.dialog.title': 'Wirklich "$1" löschen?',
   'commands.delete_workspace.dialog.description': 'Eine gelöschte Arbeitskopie kann nicht wiederhergestellt werden.',
   'commands.delete_workspace.dialog.confirm': 'Löschen',
 
+  'commands.workspace_settings.forbidden': 'Die Einstellungen der Arbeitskopie können aufgrund fehlender Benutzerrechte nicht bearbeitet werden.',
   'commands.workspace_settings.title': 'Einstellungen bearbeiten',
   'commands.workspace_settings.dialog.title': 'Einstellungen von "$1"',
 
@@ -28099,9 +29472,6 @@ $.i18n().load({
   'commands.choose_and_create_widget.disabled': 'Sie können hier keine Widgets einfügen.',
   'commands.create_widget.title': '$1 einfügen',
 
-  'commands.add_content.title': 'Inhalt einfügen',
-  'commands.add_content.not_allowed': 'Es ist nicht erlaubt in dieses Feld beliebige Inhalte einzufügen',
-
   'commands.widget_details.title': 'Widget-Eigenschaften',
   'commands.widget_details.no_details_view': 'Dieses Widget hat keine Eigenschaften',
   'commands.widget_details.dialog.title': 'Eigenschaften von "$1"',
@@ -28138,12 +29508,13 @@ $.i18n().load({
 
   'ajax.error': 'Die Kommunikation mit dem CMS ist aufgrund eines Fehlers fehlgeschlagen: $1',
   'ajax.error.communication': 'Die Kommunikation mit dem CMS ist fehlgeschlagen. Bitte überprüfen Sie Ihre Netzwerkverbindung.',
-  'ajax.error.unknown': 'Die Kommunikation mit dem CMS ist aufgrund eines unbekannten Fehlers fehlgeschlagen.',
-  'ajax.error.production': 'Bei Ihrer letzten Aktion ist ein technischer Fehler aufgetreten. Bitte versuchen Sie es später noch einmal. Falls das Problem bestehen bleibt, wenden Sie sich bitte an Ihren technischen Ansprechpartner für diese Website.',
+  'ajax.error.message_for_editor': 'Bei Ihrer letzten Aktion ist ein technischer Fehler aufgetreten. Bitte versuchen Sie es später noch einmal. Falls das Problem bestehen bleibt, wenden Sie sich bitte an Ihren technischen Ansprechpartner für diese Website und geben Sie bitte die teschnischen Details an.',
 
   'workspace_limit_exceeded.message': 'In Ihrem Tarif sind keine weiteren Arbeitskopien verfügbar. Bitte wechseln Sie den Tarif.',
 
-  'warn_before_unloading': 'Sie haben nicht gespeicherte Änderungen! Sind Sie sicher, dass sie schließen wollen?'
+  'warn_before_unloading': 'Sie haben nicht gespeicherte Änderungen! Sind Sie sicher, dass sie schließen wollen?',
+
+  'widgetlist_field_element.markup_error': 'Scrivito hat festgestellt, dass einer der Widgets invalides Markup aufweist. Bitte laden Sie die Seite neu und versuchen es noch einmal. Falls das Problem bestehen bleibt, wenden Sie sich bitte an Ihren technischen Ansprechpartner für diese Website.'
 }, 'de');
 $.i18n().load({
   'confirm': 'Confirm',
@@ -28280,21 +29651,26 @@ $.i18n().load({
   'current_page_link_dialog.title': 'Share this page',
   'current_page_link_dialog.description': 'Using the URL below, you can share the current page as part of this working copy. The recipients need to be logged in and have access to the working copy.',
 
+  'error_dialog.toggle_details': 'Toggle details',
+  'error_dialog.error_details': 'Error details',
+
   'commands.current_page_link.title': 'Share this page',
   'commands.current_page_link.is_deleted': 'A deleted page cannot be shared because it is inaccessible in preview mode',
 
-  'commands.create_workspace.forbidden': 'You can not create a workspace due to missing user permissions.',
+  'commands.create_workspace.forbidden': 'You cannot create a workspace due to missing user permissions.',
   'commands.create_workspace.title': 'Create working copy',
   'commands.create_workspace.dialog.title': 'Create working copy',
   'commands.create_workspace.dialog.description': 'Please enter the title of the new working copy.',
   'commands.create_workspace.dialog.placeholder': 'new title',
   'commands.create_workspace.dialog.accept': 'Create',
 
+  'commands.rename_workspace.forbidden': 'You cannot rename the workspace due to missing user permissions.',
   'commands.rename_workspace.title': 'Rename',
   'commands.rename_workspace.dialog.title': 'Rename "$1"',
   'commands.rename_workspace.dialog.description': 'Please enter the new title of the working copy.',
   'commands.rename_workspace.dialog.accept': 'Rename',
 
+  'commands.rebase_workspace.forbidden': 'You cannot rebase the workspace due to missing user permissions.',
   'commands.rebase_workspace.title': 'Update',
   'commands.rebase_workspace.tooltip': 'Working copy "$1" is outdated. Please update it.',
   'commands.rebase_workspace.uptodate': 'Working copy "$1" is up to date.',
@@ -28302,11 +29678,13 @@ $.i18n().load({
   'commands.rebase_workspace.has_conflicts.description': 'Your working copy could not be fully updated. Some of its content has also been altered in a different working copy that has been published in the meantime. Please refer to the changes list for details.',
   'commands.rebase_workspace.open_changes_dialog': 'Show changes',
 
+  'commands.delete_workspace.forbidden': 'You cannot delete the workspace due to missing user permissions.',
   'commands.delete_workspace.title': 'Delete',
   'commands.delete_workspace.dialog.title': 'Really delete "$1"?',
   'commands.delete_workspace.dialog.description': 'A deleted working copy cannot be restored.',
   'commands.delete_workspace.dialog.confirm': 'Delete',
 
+  'commands.workspace_settings.forbidden': 'You cannot change the settings of the workspace due to missing user permissions.',
   'commands.workspace_settings.title': 'Edit settings',
   'commands.workspace_settings.dialog.title': 'Settings for "$1"',
 
@@ -28388,9 +29766,6 @@ $.i18n().load({
   'commands.choose_and_create_widget.disabled': 'You cannot insert any widgets here.',
   'commands.create_widget.title': 'Insert $1',
 
-  'commands.add_content.title': 'Insert content',
-  'commands.add_content.not_allowed': 'It is not allowed to insert random content into this field.',
-
   'commands.widget_details.title': 'Widget properties',
   'commands.widget_details.no_details_view': 'This widget has no properties',
   'commands.widget_details.dialog.title': 'Properties of "$1"',
@@ -28427,20 +29802,21 @@ $.i18n().load({
 
   'ajax.error': 'Communication with the CMS failed with error: $1',
   'ajax.error.communication': 'Communication with the CMS failed. Please check your network connectivity.',
-  'ajax.error.unknown': 'Communication with the CMS failed for unknown reasons.',
-  'ajax.error.production': 'During your last action, a technical error occurred. Please try again later. If the problem persists, please contact a technician familiar with this website.',
+  'ajax.error.message_for_editor': 'During your last action, a technical error occurred. Please try again later. If the problem persists, please contact a technician familiar with this website and provide the error details.',
 
   'workspace_limit_exceeded.message': 'You have reached the maximum number of working copies included in your plan. Please consider to have your plan upgraded.',
 
   'warn_before_unloading': 'You have unsaved changes. Are you sure you want to quit?',
 
+  'widgetlist_field_element.markup_error': 'Scrivito found a widget with invalid markup. Please reload the page and try again. If the problem persists, please contact a technician familiar with this website.',
+
   'test.two_arguments': '$1, $2',
   'test.four_arguments': '$1, $2, $3, $4'
 }, 'en');
 /* global alert:false */
 
 
-var scrivito = {};
+var scrivito = {}; // jshint ignore:line
 
 (function() {
   var inited = false;
@@ -28498,10 +29874,24 @@ var scrivito = {};
       }
     },
 
-    log_error: function(message, exception) {
-      if (window.console) {
-        window.console.error(message, exception);
+    log_error: function() {
+      if (window.console) {
+        window.console.error.apply(window.console, arguments);
+      }
+    },
+
+    throw_error: function(message, options) {
+      options = options || {};
+
+      var params = options.params || [];
+      params.unshift(message);
+      scrivito.log_error.apply(null, params);
+
+      if (options.description) {
+        scrivito.alert_dialog(options.description);
       }
+
+      $.error(message);
     },
 
     redirect_to: function(location, target_window) {
@@ -28894,7 +30284,6 @@ var scrivito = {};
       scrivito.external_links.init();
 
       scrivito.widget_reloading.init();
-      scrivito.widget_sorting.init();
 
       scrivito.no_turbolinks.init();
 
@@ -28905,6 +30294,12 @@ var scrivito = {};
 
       scrivito.reloading.init();
 
+      if (window.location.hash === '#__scrivito_enable_drag_n_drool') {
+        scrivito.drag_n_drool.init();
+      } else {
+        scrivito.widget_sorting.init();
+      }
+
       window.onbeforeunload = scrivito.warn_before_unloading;
 
       scrivito.url_update(scrivito.application_window, scrivito.cms_window.from(window));
@@ -29254,16 +30649,16 @@ var scrivito = {};
   };
 }());
 (function() {
+  var permissions;
+
   _.extend(scrivito, {
     user_permissions: {
-      permissions_hash: {},
-
-      init: function(permissions_hash) {
-        scrivito.user_permissions.permissions_hash = permissions_hash;
+      init: function(config) {
+        permissions = config;
       },
 
-      can: function(permission_key) {
-        return !!scrivito.user_permissions.permissions_hash[permission_key];
+      can: function(action) {
+        return permissions && permissions[action];
       }
     }
   });
@@ -29302,23 +30697,12 @@ var scrivito = {};
     }, options || {})).then(
       function(result, text_status, xhr) {
         return $.Deferred().resolve(result);
-      }, function(xhr, text_status, error) {
-        var error_message;
-        var error_code;
+      }, function(xhr, text_status, xhr_error) {
         try {
-          var error_json = JSON.parse(xhr.responseText);
-          error_message = error_json.error;
-          error_code = error_json.code;
-        } catch (SyntaxError) {}
-
-        if (!error_message) {
-          error_message = error;
+          return $.Deferred().reject(JSON.parse(xhr.responseText));
+        } catch (SyntaxError) {
+          return $.Deferred().reject(xhr_error);
         }
-        return $.Deferred().reject({
-          status: xhr.status,
-          message: error_message,
-          code: error_code
-        });
       }
     );
   };
@@ -29356,23 +30740,23 @@ var scrivito = {};
     },
 
     display_ajax_error: function(error) {
-      var ajax_error = error.message;
-      var error_message;
-      if (_.contains(['abort', 'parsererror', 'timeout'], ajax_error)) {
-        error_message = scrivito.t('ajax.error.communication');
-      } else if (ajax_error === 'error') {
-        error_message = scrivito.t('ajax.error.unknown');
-      } else if (ajax_error) {
-        error_message = scrivito.t('ajax.error', ajax_error);
+      var message, message_for_editor;
+
+      if (_.isObject(error)) {
+        message = scrivito.t('ajax.error', error.message);
+        message_for_editor = error.message_for_editor;
+      } else if (_.contains(['abort', 'parsererror', 'timeout'], error)) {
+        message = scrivito.t('ajax.error.communication');
       } else {
-        error_message = scrivito.t('ajax.error.unknown');
+        message = scrivito.t('ajax.error', error);
       }
 
       if (scrivito.is_development_mode) {
-        scrivito.alert_dialog(error_message);
+        scrivito.alert_dialog(message);
       } else {
-        scrivito.log_error(error_message);
-        scrivito.info_dialog(scrivito.t('ajax.error.production'));
+        scrivito.log_error(message);
+        scrivito.error_dialog(message_for_editor || scrivito.t('ajax.error.message_for_editor'),
+          [error.timestamp, message]);
       }
     }
   });
@@ -29570,7 +30954,8 @@ var scrivito = {};
             var menu = cms_element.menu();
             _.find(menu, function(command, index) {
               if (command.id() === id) {
-                return menu[index] = scrivito.command.create_instance(_.extend(params, {id: id}));
+                menu[index] = scrivito.command.create_instance(_.extend(params, {id: id}));
+                return menu[index];
               }
             });
             cms_element.set_menu(menu);
@@ -30462,6 +31847,124 @@ var scrivito = {};
     }
   });
 }());
+(function() {
+  _.extend(scrivito, {
+    path_for_id: function(id) {
+      return '/__scrivito/' + id;
+    },
+
+    id_from_path: function(url) {
+      var match = /__scrivito\/([a-z0-9]{16})/.exec(url);
+
+      if (match) {
+        return match[1];
+      }
+    }
+  });
+})();
+(function() {
+  _.extend(scrivito, {
+    serialize_obj: function(obj_id, attrs) {
+      return serialize_widget_pool(obj_id, attrs._widget_pool).then(function(widget_pool) {
+        return serialize_attrs(obj_id, attrs).then(function(serialized_attrs) {
+          serialized_attrs._widget_pool = widget_pool;
+          return serialized_attrs;
+        });
+      });
+    }
+  });
+
+  var serialize_widget_pool = function(obj_id, widget_pool) {
+    if (widget_pool) {
+      var promises = _.map(widget_pool, function(attrs, widget_id) {
+        return serialize_attrs(obj_id, attrs).then(function(serialized_attrs) {
+          return [widget_id, serialized_attrs];
+        });
+      });
+
+      return $.when.apply(this, promises).then(function() {
+        return _.object(arguments);
+      });
+    } else {
+      return $.Deferred().resolve(widget_pool);
+    }
+  };
+
+  var serialize_attrs = function(obj_id, attrs) {
+    var promises = _.map(attrs, function(attr_value, attr_name) {
+      return serialize_attr(obj_id, attr_name, attr_value);
+    });
+
+    return $.when.apply(this, promises).then(function() {
+      return _.object(arguments);
+    });
+  };
+
+  var serialize_attr = function(obj_id, attr_name, attr_value) {
+    if (is_file(attr_value)) {
+      return serialize_file(obj_id, attr_name, attr_value);
+    }
+
+    if (is_binary(attr_value)) {
+      return serialize_binary(attr_name, attr_value);
+    }
+
+    if (is_copied_binary(attr_value)) {
+      return serialize_copied_binary(attr_name, attr_value);
+    }
+
+    if (is_uploaded_binary(attr_value)) {
+      return serialize_uploaded_binary(obj_id, attr_name, attr_value);
+    }
+
+    return $.Deferred().resolve([attr_name, scrivito.obj.serialize_value(attr_value)]);
+  };
+
+  var is_file = function(object) {
+    return object &&
+      _.isFunction(object.slice) &&
+      _.isDate(object.lastModifiedDate) &&
+      _.isString(object.name);
+  };
+
+  var serialize_file = function(obj_id, attr_name, attr_value) {
+    return scrivito.blob.create(obj_id, {file: attr_value}).then(function(blob) {
+      return [attr_name, blob];
+    });
+  };
+
+  var is_binary = function(object) {
+    return object && object.url && object.filename && _.isFunction(object.copy);
+  };
+
+  var serialize_binary = function(attr_name, attr_value) {
+    return serialize_copied_binary(attr_name, attr_value.copy());
+  };
+
+  var is_copied_binary = function(object) {
+    return object && object.is_copied_binary;
+  };
+
+  var serialize_copied_binary = function(attr_name, attr_value) {
+    return [attr_name, {copy: {
+      obj_id: attr_value.obj_id,
+      widget_id: attr_value.widget_id,
+      attribute_name: attr_value.attr_name,
+      filename: attr_value.filename,
+      content_type: attr_value.content_type
+    }}];
+  };
+
+  var is_uploaded_binary = function(object) {
+    return object && object.is_uploaded_binary;
+  };
+
+  var serialize_uploaded_binary = function(obj_id, attr_name, attr_value) {
+    return scrivito.blob.create(obj_id, attr_value).then(function(blob) {
+      return [attr_name, blob];
+    });
+  };
+}());
 (function() {
   var expando = "scrivito_cms_element";
 
@@ -30702,7 +32205,7 @@ var scrivito = {};
       from: function(dom_element) {
         var element_document;
 
-        if (!dom_element.jquery) { $.error("not a jquery instance"); }
+        if (!dom_element.jquery) { dom_element = $(dom_element); }
         if (dom_element.length === 0) {
           $.error("empty jquery instance given");
         }
@@ -30768,6 +32271,8 @@ var scrivito = {};
 
           suggest_completion: scrivito.suggest_completion,
           description_for_editor: scrivito.description_for_editor, // @api protected
+          path_for_id: scrivito.path_for_id,
+          id_from_path: scrivito.id_from_path,
 
           // @api protected
           dialog: function(content, options) {
@@ -30833,7 +32338,7 @@ var scrivito = {};
 
       // Return offset of given element relative to scrivito window.
       offset: function(dom_element) {
-        var element_offset = dom_element.offset();
+        var element_offset = $(dom_element).offset();
         var iframe_offset = $(that.window().iframe()).offset();
         if (iframe_offset) {
           return {
@@ -31096,9 +32601,30 @@ var scrivito = {};
           if (value && field_type === 'date') {
             var DateClass = scrivito.cms_document.from(that.dom_element()).browser_window().Date;
             return new DateClass(value);
-          } else {
-            return value;
           }
+
+          if (field_type === 'binary') {
+            return _.extend(value, {
+              no_cache_url: function() {
+                var path = 'objs/'+that.obj().id()+'/binary_no_cache?'+
+                  $.param({attribute_name: that.field_name()});
+                return scrivito.ajax('GET', path).then(function(response) {
+                  return response.no_cache_url;
+                });
+              },
+
+              copy: function(params) {
+                return _.extend({
+                  is_copied_binary: true,
+                  obj_id: that.obj().id(),
+                  widget_id: that.widget() && that.widget().id(),
+                  attr_name: that.field_name()
+                }, params || {});
+              }
+            });
+          }
+
+          return value;
         };
 
         return that;
@@ -31299,16 +32825,10 @@ var scrivito = {};
   scrivito.cms_element.definitions.push(scrivito.html_field_element);
 }());
 (function() {
+  var write_promises = {};
+
   _.extend(scrivito, {
     obj: {
-      serialize_value: function(value) {
-        if (_.isDate(value)) {
-          return moment.utc(value).toISOString();
-        } else {
-          return value;
-        }
-      },
-
       create_instance: function(params) {
         var that = {
           id: function() {
@@ -31378,48 +32898,50 @@ var scrivito = {};
           },
 
           save: function(attrs) {
-            return prepare_attrs(that.id(), attrs).then(function(prepared_attrs) {
-              return scrivito.ajax('PUT', 'objs/'+that.id(), {data: {obj: prepared_attrs}});
+            return scrivito.serialize_obj(that.id(), attrs).then(function(serialized_attrs) {
+              return that.enqueue_ajax('PUT', 'objs/'+that.id(), {data: {obj: serialized_attrs}});
             });
           },
 
           destroy: function() {
-            return scrivito.ajax('DELETE', 'objs/' + that.id()).then(function(result) {
+            return that.enqueue_ajax('DELETE', 'objs/'+that.id()).then(function(result) {
               return result.redirect_to;
             });
           },
 
           destroy_widget: function(widget_id) {
-            return scrivito.ajax('PUT',
-                'objs/' + that.id() + '/destroy_widget?widget_id=' + widget_id);
+            return that.enqueue_ajax('PUT',
+              'objs/'+that.id()+'/destroy_widget?widget_id='+widget_id);
           },
 
           revert: function() {
-            return scrivito.ajax('PUT', 'objs/' + that.id() + '/revert');
+            return that.enqueue_ajax('PUT', 'objs/'+that.id()+'/revert');
           },
 
           revert_widget: function(widget_id) {
-            return scrivito.ajax('PUT', 'objs/'+that.id()+'/revert_widget?widget_id='+widget_id);
+            return that.enqueue_ajax('PUT',
+              'objs/'+that.id()+'/revert_widget?widget_id='+widget_id);
           },
 
           conflicting_workspaces: function() {
-            return scrivito.ajax('GET', 'objs/' + that.id() + '/conflicting_workspaces').then(
-                function(workspace_datas) {
-              return scrivito.workspace.from_data_collection(workspace_datas);
-            });
+            return that.enqueue_ajax('GET', 'objs/'+that.id()+'/conflicting_workspaces')
+              .then(function(workspace_datas) {
+                return scrivito.workspace.from_data_collection(workspace_datas);
+              });
           },
 
           is_outdated: function() {
-            return scrivito.ajax('GET', 'objs/' + that.id() + '/is_outdated').then(
-                function(result) { return result.is_outdated; });
+            return that.enqueue_ajax('GET', 'objs/'+that.id()+'/is_outdated')
+              .then(function(result) { return result.is_outdated; });
           },
 
           restore: function() {
-            return scrivito.ajax('PUT', 'objs/' + that.id() + '/restore');
+            return that.enqueue_ajax('PUT', 'objs/'+that.id()+'/restore');
           },
 
           restore_widget: function(widget_id) {
-            return scrivito.ajax('PUT', 'objs/'+that.id()+'/restore_widget?widget_id='+widget_id);
+            return that.enqueue_ajax('PUT',
+              'objs/'+that.id()+'/restore_widget?widget_id='+widget_id);
           },
 
           details_src: function() {
@@ -31428,36 +32950,51 @@ var scrivito = {};
           },
 
           mark_resolved: function() {
-            return scrivito.ajax('PUT', 'objs/' + that.id() + '/mark_resolved');
+            return that.enqueue_ajax('PUT', 'objs/'+that.id()+'/mark_resolved');
           },
 
           copy_to: function(path) {
             var attrs = {data: {parent_path: path}};
-            return scrivito.ajax('POST', 'objs/'+that.id()+'/copy', attrs).then(function(data) {
-              return scrivito.obj.create_instance(data);
-            });
+            return that.enqueue_ajax('POST', 'objs/'+that.id()+'/copy', attrs)
+              .then(function(data) { return scrivito.obj.create_instance(data); });
           },
 
           duplicate: function() {
-            return scrivito.ajax('POST', 'objs/'+that.id()+'/duplicate').then(function(data) {
-              return scrivito.obj.create_instance(data);
-            });
+            return that.enqueue_ajax('POST', 'objs/'+that.id()+'/duplicate')
+              .then(function(data) { return scrivito.obj.create_instance(data); });
           },
 
           transfer_modifications_to: function(workspace_id) {
-            return scrivito.ajax('PUT', 'objs/'+that.id()+'/transfer_modifications',
+            return that.enqueue_ajax('PUT', 'objs/'+that.id()+'/transfer_modifications',
               {data: {workspace_id: workspace_id}});
           },
 
           reload: function() {
-            return scrivito.ajax('GET', 'objs/'+that.id()).then(function(data) {
+            return that.enqueue_ajax('GET', 'objs/'+that.id()).then(function(data) {
               params.has_conflict = data.has_conflict;
               params.modification = data.modification;
             });
           },
 
           reload_widget: function(widget_id) {
-            return scrivito.ajax('GET', 'objs/'+that.id()+'/widget?widget_id='+widget_id);
+            return that.enqueue_ajax('GET', 'objs/'+that.id()+'/widget?widget_id='+widget_id);
+          },
+
+          enqueue_ajax: function() {
+            var args = arguments;
+            var ajax = function() { return scrivito.ajax.apply(null, args); };
+
+            if (args[0] === 'GET') { return ajax(); }
+
+            var promise = $.Deferred();
+            (write_promises[that.id()] || $.Deferred().resolve()).always(function() {
+              ajax().then(
+                function() { promise.resolve.apply(promise, arguments); },
+                function() { promise.reject.apply(promise, arguments); }
+              );
+            });
+            write_promises[that.id()] = promise;
+            return promise;
           }
         };
 
@@ -31483,7 +33020,8 @@ var scrivito = {};
         return scrivito.ajax('GET', path).then(function(selection) {
           var names = _.pluck(selection, 'name');
           var recent = scrivito.obj_class_selection.recent(names);
-          var popular = _.intersection(scrivito.popular_obj_classes, names);
+          var all_popular_valid_obj_classes = _.intersection(scrivito.popular_obj_classes, names);
+          var popular = _.take(all_popular_valid_obj_classes, 5);
           return {
             all: _.sortBy(selection, 'name'),
             recent: _.map(recent, function(name) { return _.findWhere(selection, {name: name}); }),
@@ -31498,10 +33036,11 @@ var scrivito = {};
 
       create: function(attrs) {
         attrs._id = scrivito.random_id();
-        return prepare_attrs(attrs._id, attrs).then(function(prepared_attrs) {
-          return scrivito.ajax('POST', 'objs', {data: {obj: prepared_attrs}}).then(function(data) {
-            scrivito.obj_class_selection.store(prepared_attrs._obj_class);
-            return scrivito.obj.create_instance(data);
+        return scrivito.serialize_obj(attrs._id, attrs).then(function(serialized_attrs) {
+          var params = {data: {obj: serialized_attrs}};
+          return scrivito.ajax('POST', 'objs', params).then(function(obj_data) {
+            scrivito.obj_class_selection.store(serialized_attrs._obj_class);
+            return scrivito.obj.create_instance(obj_data);
           });
         });
       },
@@ -31512,60 +33051,22 @@ var scrivito = {};
             if (result.status !== 'success') { return {obj: obj, reason: result.reason}; }
           });
         })).then(function() { return $.Deferred().resolve(_.compact(arguments)); });
-      }
-    }
-  });
+      },
 
-  var is_file = function(object) {
-    return object &&
-      _.isFunction(object.slice) &&
-      _.isDate(object.lastModifiedDate) &&
-      _.isString(object.name);
-  };
+      serialize_value: function(value) {
+        if (_.isDate(value)) {
+          return moment.utc(value).toISOString();
+        } else {
+          return value;
+        }
+      },
 
-  var convert_attrs = function(obj_id, attrs) {
-    var collected_promises = _.map(attrs, function(value, field_name) {
-      if (is_file(value)) {
-        return scrivito.blob.create(obj_id, {file: value}).then(function(blob) {
-          return [field_name, blob];
-        });
-      } else if (value && value.is_uploaded_binary) {
-        return scrivito.blob.create(obj_id, value).then(function(blob) {
-          return [field_name, blob];
-        });
+      // For test purpose only.
+      clear_write_promises: function() {
+        write_promises = {};
       }
-      return $.Deferred().resolve([field_name, scrivito.obj.serialize_value(value)]);
-    });
-
-    return $.when.apply(this, collected_promises).then(function() {
-      return _.object(arguments);
-    });
-  };
-
-  var convert_widget_pool = function(obj_id, widget_pool) {
-    if (widget_pool) {
-      var conversion_promises = _.map(widget_pool, function(attrs, widget_id) {
-        return convert_attrs(obj_id, attrs).then(function(converted_attrs) {
-          return [widget_id, converted_attrs];
-        });
-      });
-
-      return $.when.apply(this, conversion_promises).then(function() {
-        return _.object(arguments);
-      });
-    } else {
-      return $.Deferred().resolve(widget_pool);
     }
-  };
-
-  var prepare_attrs = function(obj_id, attrs) {
-    return convert_widget_pool(obj_id, attrs._widget_pool).then(function(widget_pool) {
-      return convert_attrs(obj_id, attrs).then(function(converted_attrs) {
-        converted_attrs._widget_pool = widget_pool;
-        return converted_attrs;
-      });
-    });
-  };
+  });
 }());
 (function() {
   _.extend(scrivito, {
@@ -31614,8 +33115,9 @@ var scrivito = {};
 (function() {
   _.extend(scrivito, {
     chainable_search: {
-      create_instance: function(build_query) {
+      create_instance: function(build_query, continuation, fetched_ids) {
         var query = build_query || {predicates: []};
+        fetched_ids = fetched_ids || [];
 
         var add_predicate = function(field, operator, value, boost, negate) {
           var new_query = {
@@ -31637,8 +33139,13 @@ var scrivito = {};
         };
 
         var execute_search = function(query, action) {
-          return scrivito.ajax('GET', 'objs/search?' +
-              $.param({query: JSON.stringify(query), query_action: action}));
+          var get_params = { query: JSON.stringify(query), query_action: action };
+
+          if (continuation) {
+            get_params.continuation = continuation;
+          }
+
+          return scrivito.ajax('GET', 'objs/search?' + $.param(get_params));
         };
 
         var that = {
@@ -31672,18 +33179,23 @@ var scrivito = {};
 
           // @api public
           order: function(order) {
-            query.order = order;
+            if (_.isString(order)) {
+              query.order = [order, 'asc'];
+            } else {
+              query.order = _.first(_.pairs(order));
+            }
+
             return that;
           },
 
           // @api public
           reverse_order: function() {
-            if (query.reverse_order) {
-              delete query.reverse_order;
+            if (query.order) {
+              query.order[1] = query.order[1] === 'asc' ? 'desc' : 'asc';
+              return that;
             } else {
-              query.reverse_order = true;
+              $.error("A search order has to be specified before reverse_order can be applied.");
             }
-            return that;
           },
 
           // @api public
@@ -31720,16 +33232,23 @@ var scrivito = {};
             return execute_search(query).then(function(result) {
               var batch_size = result.hits.length;
               var total_matches = result.total;
+              var next_continuation = result.continuation;
+
+              result = filter_duplicates(result, fetched_ids);
 
-              if (total_matches > (batch_size + offset)) {
-                var next_offset = offset + batch_size;
-                var next_query = _.extend({}, query, {offset: next_offset});
-                next = scrivito.chainable_search.create_instance(next_query);
+              if (next_continuation) {
+                next = scrivito.chainable_search.create_instance(
+                  query,
+                  next_continuation,
+                  result.fetched_ids
+                );
               } else {
+                total_matches = result.fetched_ids.length;
                 next = undefined;
               }
 
-              return $.Deferred().resolve(result, next);
+              var public_result = {total: total_matches, hits: result.hits};
+              return $.Deferred().resolve(public_result, next);
             });
           },
 
@@ -31754,6 +33273,22 @@ var scrivito = {};
 
   });
 
+  var filter_duplicates = function(result, fetched_ids) {
+    var filtered_result = {
+      hits: [],
+      fetched_ids: _.clone(fetched_ids || [])
+    };
+
+    _.each(result.hits, function(hit) {
+      if(!_.contains(filtered_result.fetched_ids, hit.id)) {
+        filtered_result.hits.push(hit.serialized_obj);
+        filtered_result.fetched_ids.push(hit.id);
+      }
+    });
+
+    return filtered_result;
+  };
+
   var serialize_values = function(values) {
     if (!_.isArray(values)) {
       values = [values];
@@ -32063,12 +33598,21 @@ var scrivito = {};
             },
 
             widget_elements: function() {
-              var widget_elements_dom = that.dom_element()
-                  .children('[data-scrivito-private-widget-id]');
-              var widget_elements = _.map(widget_elements_dom, function(widget_element_dom) {
-                return scrivito.cms_element.from_dom_element($(widget_element_dom));
+              return _.map(that.dom_element().children(), function(element) {
+                var dom_element = $(element);
+                if (dom_element.is('[data-scrivito-private-widget-id]')) {
+                  return scrivito.cms_element.from_dom_element(dom_element);
+                } else {
+                  // Remove the "scrivito_skip_widget_markup_validation"-hack after drag_n_drool
+                  // took place of widget_sorting.
+                  if (!dom_element.hasClass('scrivito_skip_widget_markup_validation')) {
+                    scrivito.throw_error('Scrivito found a widget with invalid markup', {
+                      params: [element],
+                      description: scrivito.t('widgetlist_field_element.markup_error')
+                    });
+                  }
+                }
               });
-              return widget_elements;
             },
 
             is_empty: function() {
@@ -32268,12 +33812,14 @@ var scrivito = {};
             });
           },
 
-          update: function(attributes) {
-            return scrivito.ajax('PUT', 'workspaces/' + that.id(), {data: {workspace: attributes}});
+          rename: function(title) {
+            return scrivito.ajax('PUT', 'workspaces/'+that.id()+'/rename',
+              {data: {workspace: {title: title}}});
           },
 
-          rename: function(new_title) {
-            return that.update({title: new_title});
+          update_memberships: function(memberships) {
+            return scrivito.ajax('PUT', 'workspaces/'+that.id()+'/memberships',
+              {data: {workspace: {memberships: memberships}}});
           },
 
           destroy: function() {
@@ -32351,11 +33897,12 @@ var scrivito = {};
         };
 
         var handle_check_and_publish_error = function(error, retry_until_in_ms) {
-          if (error.code === 'precondition_not_verifiable.workspace.publish.content_state_id') {
+          var backend_code = error.backend_code;
+          if (backend_code === 'precondition_not_verifiable.workspace.publish.content_state_id') {
             // Another workspace has been published since last check.
             that.mark_as_outdated();
             return that.check_and_publish();
-          } else if (error.code === 'precondition_not_met.workspace.publish.content_state_id') {
+          } else if (backend_code === 'precondition_not_met.workspace.publish.content_state_id') {
             // The workspace has been changed since last check.
             if (Date.now() > retry_until_in_ms) {
               // retried check_and_publish for too long.
@@ -32414,7 +33961,7 @@ var scrivito = {};
         return scrivito.silent_ajax('POST', 'workspaces', params).then(function(ws_data) {
           return scrivito.workspace.from_data(ws_data);
         }, function(error) {
-          if (error.code === 'precondition_not_met.workspace.create.exceeds_limit') {
+          if (error.backend_code === 'precondition_not_met.workspace.create.exceeds_limit') {
             scrivito.workspace_limit_exceeded();
           } else {
             scrivito.display_ajax_error(error);
@@ -32460,16 +34007,37 @@ var scrivito = {};
   };
 })();
 (function() {
+  var cache = {};
+
   _.extend(scrivito, {
     suggest_completion: function(attribute, prefix) {
-      var param = $.param({attribute: attribute});
-      return scrivito.ajax('GET', 'suggest_completion?' + param).then(function(suggestions) {
+      return fetch_suggestions(attribute).then(function(suggestions) {
         return _.filter(suggestions, function(suggestion) {
           return suggestion.toLowerCase().indexOf(prefix.toLowerCase()) === 0;
         });
       });
     }
   });
+
+  _.extend(scrivito.suggest_completion, {
+    // For test purpose only.
+    clear_cache: function() {
+      cache = {};
+    }
+  });
+
+  var fetch_suggestions = function(attribute) {
+    var suggestions = cache[attribute];
+    if (suggestions) {
+      return $.Deferred().resolve(suggestions);
+    } else {
+      var param = $.param({attribute: attribute});
+      return scrivito.ajax('GET', 'suggest_completion?' + param).then(function(suggestions) {
+        cache[attribute] = suggestions;
+        return suggestions;
+      });
+    }
+  };
 }());
 (function() {
   _.extend(scrivito, {
@@ -32600,6 +34168,7 @@ var scrivito = {};
   });
 }());
 /*global ScrivitoHandlebarsTemplates:false */
+/*global __hbs__:false */
 /*global Handlebars:false */
 
 
@@ -32633,23 +34202,28 @@ var scrivito = {};
 
       render: function(template_path, data) {
         var template;
-        if(typeof ScrivitoHandlebarsTemplates !== 'undefined') {
+        if (window.ScrivitoHandlebarsTemplates) {
           template = ScrivitoHandlebarsTemplates[template_path];
         }
-        if(!template) {
-          if(scrivito.template.load_templates_from_server) {
+
+        if (window.__hbs__ && __hbs__[template_path]) {
+          template = Handlebars.compile(__hbs__[template_path]);
+        }
+
+        if (!template) {
+          if (scrivito.template.load_templates_from_server) {
             template = scrivito.template.template_cache[template_path];
-            if(!template) {
-              var url = "/app/assets/javascripts/templates/" + template_path + ".hbs?" +
-                  Math.random();
-              var source = jQuery.ajax(url, { async: false }).responseText;
+            if (!template) {
+              var url = '/app/assets/javascripts/templates/'+template_path+'.hbs?'+Math.random();
+              var source = jQuery.ajax(url, {async: false}).responseText;
               template = Handlebars.compile(source);
               scrivito.template.template_cache[template_path] = template;
             }
           } else {
-            throw('could not load template' + template_path);
+            $.error('Could not load template: '+template_path);
           }
         }
+
         return template(data);
       }
     }
@@ -32722,14 +34296,8 @@ var scrivito = {};
 
       hide: function() {
         if (view) {
-          scrivito.transition(view, function() {
-            view.removeClass('scrivito_show');
-          }).then(function(e) {
-            // Remove the view only if event is triggered by a "fade-out" transition.
-            if (e && $(e.target).hasClass('scrivito_show')) { return; }
-            if (view) { view.remove(); }
-            view = null;
-          });
+          view.remove();
+          view = null;
         }
       },
 
@@ -32856,6 +34424,37 @@ var scrivito = {};
     }
   });
 }());
+(function() {
+  _.extend(scrivito, {
+    error_dialog: function(message, details) {
+      var promise = $.Deferred();
+
+      var view = $(scrivito.template.render('error_dialog', {message: message, details: details}));
+      view.appendTo($('#scrivito_editing'));
+
+      var close = function() {
+        scrivito.dialog.close_with_transition(view);
+        promise.resolve();
+        return false;
+      };
+
+      view.find('.scrivito_close').on('click', close);
+      view.find('.scrivito_toggle_details').on('click', function() {
+        view.find('.scrivito_modal_body').toggle();
+      });
+
+      scrivito.dialog.open_and_center_with_transition(view);
+      return scrivito.with_dialog_behaviour(view, promise, {enter: close, escape: close});
+    }
+  });
+
+  _.extend(scrivito.error_dialog, {
+    // For test purpose only.
+    remove_all: function() {
+      $('.scrivito_error_dialog').remove();
+    }
+  });
+}());
 (function() {
   _.extend(scrivito, {
     confirmation_dialog: function(options) {
@@ -33013,14 +34612,7 @@ var scrivito = {};
       init: function() {
         scrivito.gui.on('document', function(cms_document) {
           var body = cms_document.dom_element().find('body');
-
           $(body).on('reload.scrivito', function() { cms_document.window().reload(); });
-
-          // TODO: remove this in 1.0.0.
-          cms_document.local_jquery(body).on('scrivito_reload', function() {
-            scrivito.deprecation_warning('$.trigger("scrivito_reload")', '$.scrivito("reload")');
-            cms_document.window().reload();
-          });
         });
       }
     }
@@ -33387,7 +34979,7 @@ var scrivito = {};
           scrivito.restore_obj_command(obj, 'resource_dialog.commands.restore_obj'),
           scrivito.mark_resolved_obj_command(obj, 'resource_dialog.commands.mark_resolved_obj'),
           scrivito.delete_obj_command(obj, 'resource_dialog.commands.delete_obj',
-            return_to || '/'+scrivito.application_document().page().id())
+            return_to || scrivito.path_for_id(scrivito.application_document().page().id()))
         ]);
       }
     }
@@ -33545,56 +35137,6 @@ var scrivito = {};
     }
   });
 }());
-(function() {
-  _.extend(scrivito, {
-    add_content_command: function(cms_element) {
-      var widgetlist_field_element, widget_element;
-      if (cms_element.widget_field) {
-        widget_element = cms_element;
-      } else {
-        widgetlist_field_element = cms_element;
-      }
-
-      return scrivito.command.create_instance({
-        id: 'scrivito.sdk.add_content',
-        title: scrivito.t('commands.add_content.title'),
-        icon: '&#xf082;',
-
-        present: function() {
-          return scrivito.select_content && scrivito.editing_context.is_editing_mode() &&
-            (widget_element || widgetlist_field_element.is_empty());
-        },
-
-        disabled: function() {
-          if (!(widgetlist_field_element || widget_element.widget_field())
-              .is_content_widget_allowed()) {
-            return scrivito.t('commands.add_content.not_allowed');
-          }
-        },
-
-        execute: function() {
-          if (!widgetlist_field_element) {
-            widgetlist_field_element = widget_element.widget_field();
-          }
-
-          scrivito.select_content().then(function(contents) {
-            var content = contents[0];
-            if (content) {
-              var widget_params = {
-                _obj_class: 'Scrivito::ContentWidget',
-                content: content
-              };
-
-              scrivito.with_saving_overlay(
-                widgetlist_field_element.add_widget_via_create(widget_params, widget_element)
-              );
-            }
-          });
-        }
-      });
-    }
-  });
-}());
 (function() {
   _.extend(scrivito, {
     add_subpage_command: function(child_list_element) {
@@ -33611,7 +35153,7 @@ var scrivito = {};
           return choose_obj_class.then(function(obj_class) {
             var add_subpage = child_list_element.create_child(obj_class);
             return scrivito.with_saving_overlay(add_subpage).then(function(obj) {
-              return scrivito.application_window.redirect_to('/' + obj.id());
+              return scrivito.application_window.redirect_to(scrivito.path_for_id(obj.id()));
             });
           });
         }
@@ -33684,7 +35226,7 @@ var scrivito = {};
         execute: function() {
           var copy_page = scrivito.obj_clipboard.obj().copy_to(child_list_element.path());
           return scrivito.with_saving_overlay(copy_page).then(function(obj) {
-            return scrivito.application_window.redirect_to('/' + obj.id());
+            return scrivito.application_window.redirect_to(scrivito.path_for_id(obj.id()));
           });
         }
       });
@@ -33768,7 +35310,7 @@ var scrivito = {};
           return choose_obj_class.then(function(obj_class) {
             var create_page = scrivito.obj.create({_obj_class: obj_class});
             return scrivito.with_saving_overlay(create_page).then(function(page) {
-              return scrivito.application_window.redirect_to('/' + page.id());
+              return scrivito.application_window.redirect_to(scrivito.path_for_id(page.id()));
             });
           });
         }
@@ -33962,6 +35504,12 @@ var scrivito = {};
         title: scrivito.t('commands.delete_workspace.title'),
         icon: '&#xf018;',
 
+        disabled: function() {
+          if (!scrivito.user_permissions.can('delete_workspace')) {
+            return scrivito.t('commands.delete_workspace.forbidden');
+          }
+        },
+
         execute: function() {
           scrivito.confirmation_dialog({
             title: scrivito.t('commands.delete_workspace.dialog.title', workspace.title()),
@@ -34003,7 +35551,7 @@ var scrivito = {};
 
         execute: function() {
           return scrivito.with_saving_overlay(obj.duplicate()).then(function(obj) {
-            return scrivito.application_window.redirect_to('/' + obj.id());
+            return scrivito.application_window.redirect_to(scrivito.path_for_id(obj.id()));
           });
         }
       });
@@ -34104,7 +35652,7 @@ var scrivito = {};
             return scrivito.details_dialog.open(obj.details_src(),
               scrivito.t(title_locale, obj.obj_class()));
           }, function() {
-            scrivito.application_window.redirect_to('/' + obj.id());
+            scrivito.application_window.redirect_to(scrivito.path_for_id(obj.id()));
           });
         }
       });
@@ -34178,6 +35726,10 @@ var scrivito = {};
         tooltip: scrivito.t('commands.rebase_workspace.tooltip', workspace.title()),
 
         disabled: function() {
+          if (!scrivito.user_permissions.can('rebase_workspace')) {
+            return scrivito.t('commands.rebase_workspace.forbidden');
+          }
+
           if (!workspace.is_outdated()) {
             return scrivito.t('commands.rebase_workspace.uptodate', workspace.title());
           }
@@ -34216,6 +35768,12 @@ var scrivito = {};
         title: scrivito.t('commands.rename_workspace.title'),
         icon: '&#xf04f;',
 
+        disabled: function() {
+          if (!scrivito.user_permissions.can('rename_workspace')) {
+            return scrivito.t('commands.rename_workspace.forbidden');
+          }
+        },
+
         execute: function() {
           scrivito.prompt_dialog({
             title: scrivito.t('commands.rename_workspace.dialog.title', workspace.title()),
@@ -34626,12 +36184,18 @@ var scrivito = {};
         title: scrivito.t('commands.workspace_settings.title'),
         icon: '&#xf030;',
 
+        disabled: function() {
+          if (!scrivito.user_permissions.can('invite_to_workspace')) {
+            return scrivito.t('commands.workspace_settings.forbidden');
+          }
+        },
+
         execute: function() {
           var title = scrivito.t('commands.workspace_settings.dialog.title', workspace.title());
           scrivito.workspace_settings_dialog.open(title, workspace.memberships()).then(
             function(memberships) {
               scrivito.with_saving_overlay(
-                workspace.update({memberships: memberships}).then(function() {
+                workspace.update_memberships(memberships).then(function() {
                   return scrivito.reload();
                 })
               );
@@ -34708,10 +36272,6 @@ var scrivito = {};
               widget_element.set_menu([
                 scrivito.create_widget_command(widget_element),
                 scrivito.choose_and_create_widget_command(widget_element),
-                //
-                // FIXME content-widget
-                //
-                // scrivito.add_content_command(widget_element),
                 scrivito.widget_details_command(widget_element),
                 create_command_separator(1),
                 scrivito.save_widget_to_clipboard_command(widget_element),
@@ -34738,10 +36298,6 @@ var scrivito = {};
               widgetlist_field_element.set_menu([
                 scrivito.create_widget_command(widgetlist_field_element),
                 scrivito.choose_and_create_widget_command(widgetlist_field_element),
-                //
-                // FIXME content-widget
-                //
-                // scrivito.add_content_command(widgetlist_field_element),
                 scrivito.copy_widget_from_clipboard_command(widgetlist_field_element)
               ].concat(widgetlist_field_element.menu()));
             });
@@ -34934,13 +36490,6 @@ var scrivito = {};
       activate();
       return false;
     });
-
-    // TODO: remove this in 1.0.0.
-    scrivito.cms_document.local_jquery(jquery_object).on('scrivito_reload', function() {
-      scrivito.deprecation_warning('$.trigger("scrivito_reload")', '$.scrivito("reload")');
-      activate();
-      return false;
-    });
   };
 }());
 (function() {
@@ -35054,7 +36603,7 @@ var scrivito = {};
           dom_element.sortable({
             items: '> [data-scrivito-private-widget-id]',
             handle: '> .scrivito_editing_marker',
-            placeholder: 'scrivito_widget_drop_placeholder',
+            placeholder: 'scrivito_widget_drop_placeholder scrivito_skip_widget_markup_validation',
             connectWith: '*[data-scrivito-field-type="widgetlist"]',
 
             start:  scrivito.widget_sorting.start,
@@ -35511,6 +37060,637 @@ var scrivito = {};
     return data || {};
   };
 })();
+(function() {
+  var focus;
+  var focus_stack = [];
+  var dragging;
+
+  // GEOMETRY UTILS
+
+  // distance between point and rectangle
+  // returns 0 if point is inside rectangle
+  var distance_point_rectangle = function(point, rect) {
+    var clamped_x = Math.max(Math.min(point.x, rect.x + rect.width), rect.x);
+    var clamped_y = Math.max(Math.min(point.y, rect.y + rect.height), rect.y);
+
+    var dist_x = point.x - clamped_x;
+    var dist_y = point.y - clamped_y;
+
+    return Math.sqrt(dist_x * dist_x + dist_y * dist_y);
+  };
+
+  var is_wrap_between = function(column, next_column) {
+    var column_offset = column.offset();
+    var next_column_offset = next_column.offset();
+    var diff_x = next_column_offset.left - column_offset.left;
+    var diff_y = next_column_offset.top - column_offset.top;
+    return diff_y > diff_x;
+  };
+
+  var is_container_wrapping = function(column_container) {
+    return !!_.find(column_container.children(), function(column) {
+      column = $(column);
+      var next_column = column.next();
+      if (next_column.length) {
+        return is_wrap_between(column, next_column);
+      }
+    });
+  };
+
+  // given a dom element, return it's bounding rectangle
+  var bounding_rectangle = function(element) {
+    element = $(element);
+
+    var offset = element.offset();
+    var height;
+
+    var parent = element.parent();
+
+    if (element.is('[data-scrivito-widget-obj-class=ColumnWidget]') &&
+        !is_container_wrapping(parent)) {
+      // The column should occupy the entire available height unless its container is wrapping.
+      height = parent.outerHeight();
+    } else {
+      height = element.outerHeight();
+    }
+
+    return {
+      x: offset.left,
+      y: offset.top,
+      width: element.outerWidth(),
+      height: height
+    };
+  };
+
+  // which of the given dom elements is closest to the given point?
+  var detect_closest = function(point, elements) {
+    if (elements.length) {
+      return _.min(elements, function(elem) {
+        return distance_point_rectangle(point, bounding_rectangle(elem));
+      });
+    }
+  };
+
+  // BOOTSTRAP UTILS
+
+  var create_row = function() {
+    return $("<div class='row'></div>");
+  };
+
+  // given an element, return it bootstrap column class, i.e. "col-md-6"
+  var col_class = function(elem) {
+    var classes = $(elem).attr("class").split(/\s+/);
+
+    return _.chain(classes).map(function(klass) {
+      var match = /^col-md-[0-9]+/.exec(klass);
+      return match ? match[0] : undefined;
+    }).detect().value();
+  };
+
+  var change_col_class = function(elem, new_class, animation) {
+    animation = animation || 0;
+
+    var old_class_found;
+
+    _.each(_.range(1, 13), function(i) {
+      var old_class = "col-md-" + i;
+      if ($(elem).hasClass(old_class)) {
+        old_class_found = true;
+        if (old_class !== new_class) {
+          $(elem).switchClass(old_class, new_class, animation);
+        }
+      }
+    });
+
+    if (!old_class_found) {
+      $(elem).addClass(new_class, animation);
+    }
+  };
+
+  var resize_row = function(row) {
+    row = $(row);
+
+    var cols = row.children().toArray();
+    var space = 12;
+
+    while (cols.length > 0) {
+      var size = Math.round(space / cols.length);
+      space -= size;
+
+      var col = cols.shift();
+
+      scrivito.change_col_class(col, "col-md-" + size, 100);
+    }
+  };
+
+  var garbage_collect = function(elem) {
+    if ($(elem).attr("data-scrivito-widget-obj-class") === "ColumnWidget") {
+      if ($(elem).children().length === 0) {
+        // remove empty column
+        var container = $(elem).parent();
+        elem.remove();
+
+        var leftover_columns = $(container).children();
+        if (leftover_columns.length > 1) {
+          resize_row(container);
+        }
+        else {
+          // unwrap last column
+          var last_column = leftover_columns[0];
+          var widgets_to_unwrap = $(last_column).children();
+
+          if (widgets_to_unwrap.length === 0) {
+            // last column is empty.
+            // this should never happen, but better safe than sorry...
+            $(container).remove();
+          }
+          else {
+            // remove column widget
+            $(widgets_to_unwrap).unwrap();
+            // remove column container widget
+            $(widgets_to_unwrap).unwrap();
+          }
+        }
+      }
+    }
+  };
+
+  // FOCUS MARKER
+
+  var focus_marker = function() {
+    var focus_marker;
+
+    var rects;
+
+    var show_rectangle = function(num, x1, y1, x2, y2) {
+      var rect = $(rects[num]);
+
+      rect.offset({left: x1, top: y1});
+      rect.width(x2 - x1);
+      rect.height(y2 - y1);
+
+      rect.show();
+    };
+
+    return {
+      init: function() {
+        rects = _.map(_.range(4), function() {
+          var rect = $("<div class='focus_marker'></div>");
+          rect.css("pointer-events", "none");
+          rect.css("background", "rgba(255, 159, 0, 0.25)");
+          rect.css("position", "absolute");
+          rect.hide();
+
+          $("body").append(rect);
+
+          return rect;
+        });
+      },
+
+      show: function(focus) {
+        var offset = scrivito.cms_document.offset(focus)
+        var bounds = bounding_rectangle(focus);
+        var width = bounds.width;
+        var height = bounds.height;
+
+        // FIXME, use actual values
+        var window_bottom = 2048;
+        var window_right = 2048;
+
+        show_rectangle(0, 0, 0, offset.left, window_bottom);
+        show_rectangle(1, offset.left + width, 0, window_right, window_bottom);
+
+        show_rectangle(2, offset.left, 0, offset.left + width, offset.top);
+        show_rectangle(3, offset.left, offset.top + height, offset.left + width, window_bottom);
+      },
+
+      hide: function() {
+        _.each(rects, function(rect) { $(rect).hide(); });
+      }
+    };
+  }();
+
+  var find_selectable_targets = function(root) {
+    root = $(root);
+
+    if (root.is('[data-scrivito-widget-obj-class=ColumnWidget]')) {
+      return root.children();
+    }
+
+    var widgetlists = root.find('[data-scrivito-field-type=widgetlist]')
+      .addBack('[data-scrivito-field-type=widgetlist]');
+    widgetlists = _.reject(widgetlists, function(widgetlist) {
+      // Reject if not a top-level widgetlist.
+      var wrapping_widgetlist = $(widgetlist).parent()
+        .closest('[data-scrivito-field-type=widgetlist]').get(0);
+      return wrapping_widgetlist && $.contains(root.get(0), wrapping_widgetlist);
+    });
+
+    var selectable_targets = [];
+    _.each(widgetlists, function(widgetlist) {
+      var widgets = $(widgetlist).children();
+      if (widgets.length) {
+        selectable_targets = selectable_targets.concat(widgets.toArray());
+      } else {
+        selectable_targets.push(widgetlist);
+      }
+    });
+
+    return selectable_targets;
+  };
+
+  var find_gesture_targets = function(mouse, focus) {
+    var selectable_targets = find_selectable_targets(focus);
+    var target_row = detect_closest(mouse, selectable_targets);
+    var target;
+
+    if ($(target_row).is("[data-scrivito-widget-obj-class=ColumnContainerWidget]")) {
+      target = detect_closest(mouse, $(target_row).children());
+    } else {
+      target = target_row;
+    }
+
+    return {
+      target_row: target_row,
+      target: target
+    };
+  };
+
+  var detect_gesture = function(mouse, target, target_row) {
+    if ($(target).is('[data-scrivito-field-type=widgetlist]')) {
+      return {
+        name: 'row_insert'
+      };
+    }
+
+    target_row = $(target_row);
+    var rowY = target_row.offset().top;
+    var rowHeight = target_row.height();
+
+    var targetY = $(target).offset().top;
+    var targetHeight = $(target).height();
+
+    var event_row_y = (mouse.y - rowY) / rowHeight;
+    var event_target_y_abs = mouse.y - targetY;
+    var event_target_y = event_target_y_abs / targetHeight;
+
+    var is_row_insert_before = event_row_y < (1 / 4) && event_target_y < (1 /4) &&
+      event_target_y_abs < 20;
+    var is_row_insert_after = event_row_y > (3 / 4) && event_target_y > (3 /4) &&
+      event_target_y_abs > (targetHeight - 20);
+
+    if (is_row_insert_before || is_row_insert_after) {
+      return {
+        name: 'row_insert',
+        before: is_row_insert_before
+      };
+    } else {
+      var targetX = $(target).offset().left;
+      var targetWidth = $(target).width();
+      var event_target_x_abs = mouse.x - targetX;
+      var eventX = event_target_x_abs / targetWidth;
+
+      var widget_obj_class = $(target).attr("data-scrivito-widget-obj-class");
+      var contains_widgetlist = !!$(target).find('[data-scrivito-field-type=widgetlist]').length;
+      var is_applicable_for_insert_inside = (contains_widgetlist || widget_obj_class === 'ColumnWidget') &&
+        dragging !== target;
+
+      var is_col_insert_before = eventX < (1 / 4) && event_target_x_abs < 20;
+      var is_col_insert_after = eventX > (3 / 4) && event_target_x_abs > (targetWidth - 20);
+      var distance = distance_point_rectangle(mouse, bounding_rectangle(target));
+      if (is_applicable_for_insert_inside && !is_col_insert_before && !is_col_insert_after && distance < 20) {
+        return {
+          name: 'insert_inside',
+          before: event_target_y < (1 / 2)
+        };
+      } else {
+        return {
+          name: 'col_insert',
+          before: eventX < 0.5
+        };
+      }
+    }
+  };
+
+  var loose_focus = function(mouse, focus) {
+    if (focus) {
+      var distance = distance_point_rectangle(mouse, bounding_rectangle(focus));
+      if (distance > 20) {
+        return focus_stack.pop();
+      } else {
+        var targets = find_gesture_targets(mouse, _.last(focus_stack) || $(focus).closest('body'));
+        if (targets.target && targets.target !== focus) {
+          return focus_stack.pop();
+        }
+      }
+    }
+
+    return focus;
+  };
+
+  var offset_center = function(element, element_offset, next_element, next_element_offset) {
+    var left_boundary = element_offset.left + element.outerWidth();
+    var right_boundary = next_element_offset.left;
+    var horizontal_offset = (right_boundary - left_boundary) / 2
+    var left = left_boundary + horizontal_offset;
+
+    var top_boundary = element_offset.top + element.outerHeight();
+    var bottom_boundary = next_element_offset.top;
+    var vertical_offset = (bottom_boundary - top_boundary) / 2
+    var top = top_boundary + vertical_offset;
+
+    return {left: left, top: top};
+  };
+
+  _.extend(scrivito, {
+    change_col_class: change_col_class,
+
+    drag_n_drool: {
+      init: function() {
+        var hidden;
+
+        var cursor = $('<div class="scrivito_dnd_cursor"></div>');
+        cursor.hide();
+        $("body").append(cursor);
+
+        focus_marker.init();
+
+        var insert_at;
+        var insert_type;
+        var insert_before;
+
+        scrivito.gui.on('document', function(document) {
+          var body = document.dom_element().find("body");
+
+          body.on("dragover", function(e) {
+            e.originalEvent.dataTransfer.dropEffect = 'move';
+
+            if (e.preventDefault) {
+              e.preventDefault(); // Necessary. Allows us to drop.
+            }
+
+
+            // REPLACE ORIGINAL WITH PLACEHOLDER
+            if (!hidden) {
+              $(dragging).css("opacity", "0.5");
+              hidden = true;
+            }
+
+            // using originalEvent as a workaround,
+            // see https://github.com/jquery/jquery/issues/1925
+            var mouse = {x: e.originalEvent.pageX, y: e.originalEvent.pageY}
+
+            focus = loose_focus(mouse, focus);
+
+            if (focus) {
+              focus_marker.show(focus);
+            }
+            else {
+              focus_marker.hide();
+            }
+
+            var targets = find_gesture_targets(mouse, focus || body);
+            var target_row = $(targets.target_row);
+            var target = targets.target;
+
+            // This should NEVER happen!
+            if (!target) {
+              console.error('Missing target!');
+              return;
+            }
+
+            var gesture = detect_gesture(mouse, target, target_row);
+
+            // TODO take widget into account: if small widget,
+            // only upper 1/3 of widget should count as "row"
+            if (gesture.name === 'row_insert') {
+              var before = gesture.before;
+
+              // CURSOR
+              cursor.height("0px");
+              cursor.width(target_row.parent().outerWidth());
+
+              // TODO update Cursor position on scroll
+              // FIXME: why that - offset.top -= 0.5 * cursor.outerHeight();
+
+              var offset = scrivito.cms_document.offset(target_row);
+
+              if (before) {
+                var prev_row = target_row.prev();
+                if (prev_row.length) {
+                  var prev_row_offset = scrivito.cms_document.offset(prev_row);
+                  offset.top = offset_center(prev_row, prev_row_offset, target_row, offset).top;
+                }
+              } else {
+                var next_row = target_row.next();
+                if (next_row.length) {
+                  var next_row_offset = scrivito.cms_document.offset(next_row);
+                  offset.top = offset_center(target_row, offset, next_row, next_row_offset).top;
+                } else {
+                  offset.top += target_row.outerHeight();
+                }
+              }
+
+              offset.left = scrivito.cms_document.offset(target_row.parent()).left;
+              cursor.offset(offset);
+              cursor.show();
+
+              // REMEMBER
+              insert_at = target_row;
+              insert_type = "row";
+              insert_before = before;
+            } else if (gesture.name === 'insert_inside') {
+              // CURSOR
+
+              var bounds = bounding_rectangle(target);
+              cursor.width(bounds.width);
+              cursor.height(bounds.height);
+
+              // TODO update Cursor position on scroll
+              var offset = scrivito.cms_document.offset(target);
+              cursor.offset(offset);
+              cursor.show();
+
+              if (insert_at === target && insert_type === "inside") {
+                var focus_time = (new Date()) - focus_since;
+
+                if (focus_time > 500) {
+                  if (focus) {
+                    focus_stack.push(focus);
+                  }
+                  focus = target;
+                  focus_since = undefined;
+                }
+              } else {
+                focus_since = new Date();
+                // REMEMBER
+                insert_at = target;
+                insert_type = "inside";
+              }
+
+              insert_before = gesture.before;
+            } else if (gesture.name === 'col_insert') {
+              var before = gesture.before;
+
+              // CURSOR
+              cursor.height($(target).outerHeight());
+              cursor.width("0px");
+
+              // TODO update Cursor position on scroll
+              var offset = scrivito.cms_document.offset(target);
+              var target_jq = $(target);
+
+              if (before) {
+                var prev_column = target_jq.prev();
+                if (prev_column.length && !is_wrap_between(prev_column, target_jq)) {
+                  offset.left = offset_center(prev_column, scrivito.cms_document.offset(prev_column),
+                                              target_jq, offset).left;
+                  cursor.height(target_jq.parent().outerHeight());
+                }
+              } else {
+                var next_column = target_jq.next();
+                if (next_column.length && !is_wrap_between(target_jq, next_column)) {
+                  offset.left = offset_center(target_jq, offset, next_column,
+                                              scrivito.cms_document.offset(next_column)).left;
+                  cursor.height(target_jq.parent().outerHeight());
+                } else {
+                  offset.left += target_jq.outerWidth();
+                }
+              }
+
+              cursor.offset(offset);
+              cursor.show();
+
+              // REMEMBER
+              insert_at = target;
+              insert_type = "col";
+              insert_before = before;
+            } else {
+              $.error('Unknown gesture: ' + gesture);
+            }
+          });
+
+        });
+
+        scrivito.on('content', function(root_element) {
+          var widget_lists = $(root_element).find("[data-scrivito-field-type=widgetlist]");
+
+          var widgets = widget_lists.children();
+
+          var handles = widgets.find("> .scrivito_editing_marker");
+
+          handles.attr("draggable", "true");
+
+          handles.on("dragstart", function(e) {
+            e.originalEvent.dataTransfer.effectAllowed = 'move';
+
+            // Is required in order to dragover event is triggered in FF and Safari.
+            // http://stackoverflow.com/questions/21507189/dragenter-dragover-and-drop-events-not-working-in-firefox
+            // IE 11 however does not allow to set the data, which results in a security exception.
+            try {
+              e.originalEvent.dataTransfer.setData('text/plain', e.originalEvent.target.id);
+            } catch(error) {}
+
+            //var dragIcon = document.createElement('img');
+            //// TODO use real logo
+            //dragIcon.src = 'logo.png';
+            //dragIcon.width = 100;
+            //e.originalEvent.dataTransfer.setDragImage(dragIcon, -10, -10);
+
+            dragging = $(this).parent()[0];
+            // FIXME: Find also the structure widget.
+            focus = $(dragging).closest("[data-scrivito-widget-obj-class=ColumnWidget]")[0];
+
+            if ($(focus).children().length === 1) { // TODO: Only for ColumnContainerWidget
+              // if dragging the only widget inside a column
+              // focussing that column does not make sense
+              focus = $(focus).parent().
+                closest("[data-scrivito-widget-obj-class=ColumnWidget]")[0];
+            }
+
+            hidden = false;
+          });
+
+          handles.on("dragend", function(e) {
+
+            if (window.debugdrag) { return }
+
+            if (insert_at == dragging) {
+              // dragged a widget on itself - do nothing
+              $(dragging).css("opacity", "1");
+            }
+            else if (insert_at) {
+              var old_parent = $(dragging).parent();
+
+              if (insert_type == "inside") {
+                // TODO do noting if not ColumnContainerWidget
+                // INSIDE EXISTING COLUMN
+                $(dragging).hide();
+                $(insert_at)[insert_before ? "prepend" : "append"](dragging);
+                $(dragging).slideDown(100);
+
+                $(dragging).css("opacity", "1");
+
+                garbage_collect(old_parent);
+              }
+              else if (insert_type == "row") {
+                // ROW INSERT
+                $(dragging).hide();
+
+                if (insert_before === undefined) {
+                  $(insert_at).append(dragging);
+                } else {
+                  $(insert_at)[insert_before ? "before" : "after"](dragging);
+                }
+                $(dragging).css("opacity", "1");
+
+                $(dragging).slideDown(100);
+
+                garbage_collect(old_parent);
+              }
+              else {
+                // COL INSERT
+                var insert_at_obj_class = $(insert_at).attr("data-scrivito-widget-obj-class");
+                if (insert_at_obj_class !== "ColumnWidget") {
+                  $(insert_at).wrap(
+                    "<div class='row' data-scrivito-widget-obj-class=ColumnContainerWidget>" +
+                    "<div class='col-md-12' data-scrivito-widget-obj-class=ColumnWidget></div>" +
+                    "</div>");
+
+                  insert_at = $(insert_at).parent();
+                }
+
+                $(dragging).detach();
+                $(dragging).wrap("<div class='col-md-12' data-scrivito-widget-obj-class=ColumnWidget></div>");
+                var insert_column = $(dragging).parent();
+
+                $(insert_at)[insert_before ? "before" : "after"](insert_column);
+
+                $(dragging).css("opacity", "1");
+                $(dragging).show(100);
+
+                // collect old parent before resizing,
+                // since it could be inside the same row
+                garbage_collect(old_parent);
+
+                resize_row($(insert_at).closest(".row"));
+              }
+            }
+
+            cursor.hide();
+            focus_marker.hide();
+
+            return false;
+          });
+        });
+      }
+    }
+  });
+}());
+
+
+
+
 
 
 
@@ -35614,6 +37794,7 @@ var scrivito = {};
 
 
 
+
 //