" +
+ "
" ),
+ innerDiv = div.children()[ 0 ];
+
+ $( "body" ).append( div );
+ w1 = innerDiv.offsetWidth;
+ div.css( "overflow", "scroll" );
+
+ w2 = innerDiv.offsetWidth;
+
+ if ( w1 === w2 ) {
+ w2 = div[ 0 ].clientWidth;
+ }
+
+ div.remove();
+
+ return ( cachedScrollbarWidth = w1 - w2 );
+ },
+ getScrollInfo: function( within ) {
+ var overflowX = within.isWindow || within.isDocument ? "" :
+ within.element.css( "overflow-x" ),
+ overflowY = within.isWindow || within.isDocument ? "" :
+ within.element.css( "overflow-y" ),
+ hasOverflowX = overflowX === "scroll" ||
+ ( overflowX === "auto" && within.width < within.element[ 0 ].scrollWidth ),
+ hasOverflowY = overflowY === "scroll" ||
+ ( overflowY === "auto" && within.height < within.element[ 0 ].scrollHeight );
+ return {
+ width: hasOverflowY ? $.position.scrollbarWidth() : 0,
+ height: hasOverflowX ? $.position.scrollbarWidth() : 0
+ };
+ },
+ getWithinInfo: function( element ) {
+ var withinElement = $( element || window ),
+ isWindow = $.isWindow( withinElement[ 0 ] ),
+ isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9,
+ hasOffset = !isWindow && !isDocument;
+ return {
+ element: withinElement,
+ isWindow: isWindow,
+ isDocument: isDocument,
+ offset: hasOffset ? $( element ).offset() : { left: 0, top: 0 },
+ scrollLeft: withinElement.scrollLeft(),
+ scrollTop: withinElement.scrollTop(),
+ width: withinElement.outerWidth(),
+ height: withinElement.outerHeight()
+ };
+ }
+};
+
+$.fn.position = function( options ) {
+ if ( !options || !options.of ) {
+ return _position.apply( this, arguments );
+ }
+
+ // Make a copy, we don't want to modify arguments
+ options = $.extend( {}, options );
+
+ var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
+ target = $( options.of ),
+ within = $.position.getWithinInfo( options.within ),
+ scrollInfo = $.position.getScrollInfo( within ),
+ collision = ( options.collision || "flip" ).split( " " ),
+ offsets = {};
+
+ dimensions = getDimensions( target );
+ if ( target[ 0 ].preventDefault ) {
+
+ // Force left top to allow flipping
+ options.at = "left top";
+ }
+ targetWidth = dimensions.width;
+ targetHeight = dimensions.height;
+ targetOffset = dimensions.offset;
+
+ // Clone to reuse original targetOffset later
+ basePosition = $.extend( {}, targetOffset );
+
+ // Force my and at to have valid horizontal and vertical positions
+ // if a value is missing or invalid, it will be converted to center
+ $.each( [ "my", "at" ], function() {
+ var pos = ( options[ this ] || "" ).split( " " ),
+ horizontalOffset,
+ verticalOffset;
+
+ if ( pos.length === 1 ) {
+ pos = rhorizontal.test( pos[ 0 ] ) ?
+ pos.concat( [ "center" ] ) :
+ rvertical.test( pos[ 0 ] ) ?
+ [ "center" ].concat( pos ) :
+ [ "center", "center" ];
+ }
+ pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
+ pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
+
+ // Calculate offsets
+ horizontalOffset = roffset.exec( pos[ 0 ] );
+ verticalOffset = roffset.exec( pos[ 1 ] );
+ offsets[ this ] = [
+ horizontalOffset ? horizontalOffset[ 0 ] : 0,
+ verticalOffset ? verticalOffset[ 0 ] : 0
+ ];
+
+ // Reduce to just the positions without the offsets
+ options[ this ] = [
+ rposition.exec( pos[ 0 ] )[ 0 ],
+ rposition.exec( pos[ 1 ] )[ 0 ]
+ ];
+ } );
+
+ // Normalize collision option
+ if ( collision.length === 1 ) {
+ collision[ 1 ] = collision[ 0 ];
+ }
+
+ if ( options.at[ 0 ] === "right" ) {
+ basePosition.left += targetWidth;
+ } else if ( options.at[ 0 ] === "center" ) {
+ basePosition.left += targetWidth / 2;
+ }
+
+ if ( options.at[ 1 ] === "bottom" ) {
+ basePosition.top += targetHeight;
+ } else if ( options.at[ 1 ] === "center" ) {
+ basePosition.top += targetHeight / 2;
+ }
+
+ atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
+ basePosition.left += atOffset[ 0 ];
+ basePosition.top += atOffset[ 1 ];
+
+ return this.each( function() {
+ var collisionPosition, using,
+ elem = $( this ),
+ elemWidth = elem.outerWidth(),
+ elemHeight = elem.outerHeight(),
+ marginLeft = parseCss( this, "marginLeft" ),
+ marginTop = parseCss( this, "marginTop" ),
+ collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) +
+ scrollInfo.width,
+ collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) +
+ scrollInfo.height,
+ position = $.extend( {}, basePosition ),
+ myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
+
+ if ( options.my[ 0 ] === "right" ) {
+ position.left -= elemWidth;
+ } else if ( options.my[ 0 ] === "center" ) {
+ position.left -= elemWidth / 2;
+ }
+
+ if ( options.my[ 1 ] === "bottom" ) {
+ position.top -= elemHeight;
+ } else if ( options.my[ 1 ] === "center" ) {
+ position.top -= elemHeight / 2;
+ }
+
+ position.left += myOffset[ 0 ];
+ position.top += myOffset[ 1 ];
+
+ collisionPosition = {
+ marginLeft: marginLeft,
+ marginTop: marginTop
+ };
+
+ $.each( [ "left", "top" ], function( i, dir ) {
+ if ( $.ui.position[ collision[ i ] ] ) {
+ $.ui.position[ collision[ i ] ][ dir ]( position, {
+ targetWidth: targetWidth,
+ targetHeight: targetHeight,
+ elemWidth: elemWidth,
+ elemHeight: elemHeight,
+ collisionPosition: collisionPosition,
+ collisionWidth: collisionWidth,
+ collisionHeight: collisionHeight,
+ offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
+ my: options.my,
+ at: options.at,
+ within: within,
+ elem: elem
+ } );
+ }
+ } );
+
+ if ( options.using ) {
+
+ // Adds feedback as second argument to using callback, if present
+ using = function( props ) {
+ var left = targetOffset.left - position.left,
+ right = left + targetWidth - elemWidth,
+ top = targetOffset.top - position.top,
+ bottom = top + targetHeight - elemHeight,
+ feedback = {
+ target: {
+ element: target,
+ left: targetOffset.left,
+ top: targetOffset.top,
+ width: targetWidth,
+ height: targetHeight
+ },
+ element: {
+ element: elem,
+ left: position.left,
+ top: position.top,
+ width: elemWidth,
+ height: elemHeight
+ },
+ horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
+ vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
+ };
+ if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
+ feedback.horizontal = "center";
+ }
+ if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
+ feedback.vertical = "middle";
+ }
+ if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
+ feedback.important = "horizontal";
+ } else {
+ feedback.important = "vertical";
+ }
+ options.using.call( this, props, feedback );
+ };
+ }
+
+ elem.offset( $.extend( position, { using: using } ) );
+ } );
+};
+
+$.ui.position = {
+ fit: {
+ left: function( position, data ) {
+ var within = data.within,
+ withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
+ outerWidth = within.width,
+ collisionPosLeft = position.left - data.collisionPosition.marginLeft,
+ overLeft = withinOffset - collisionPosLeft,
+ overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
+ newOverRight;
+
+ // Element is wider than within
+ if ( data.collisionWidth > outerWidth ) {
+
+ // Element is initially over the left side of within
+ if ( overLeft > 0 && overRight <= 0 ) {
+ newOverRight = position.left + overLeft + data.collisionWidth - outerWidth -
+ withinOffset;
+ position.left += overLeft - newOverRight;
+
+ // Element is initially over right side of within
+ } else if ( overRight > 0 && overLeft <= 0 ) {
+ position.left = withinOffset;
+
+ // Element is initially over both left and right sides of within
+ } else {
+ if ( overLeft > overRight ) {
+ position.left = withinOffset + outerWidth - data.collisionWidth;
+ } else {
+ position.left = withinOffset;
+ }
+ }
+
+ // Too far left -> align with left edge
+ } else if ( overLeft > 0 ) {
+ position.left += overLeft;
+
+ // Too far right -> align with right edge
+ } else if ( overRight > 0 ) {
+ position.left -= overRight;
+
+ // Adjust based on position and margin
+ } else {
+ position.left = max( position.left - collisionPosLeft, position.left );
+ }
+ },
+ top: function( position, data ) {
+ var within = data.within,
+ withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
+ outerHeight = data.within.height,
+ collisionPosTop = position.top - data.collisionPosition.marginTop,
+ overTop = withinOffset - collisionPosTop,
+ overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
+ newOverBottom;
+
+ // Element is taller than within
+ if ( data.collisionHeight > outerHeight ) {
+
+ // Element is initially over the top of within
+ if ( overTop > 0 && overBottom <= 0 ) {
+ newOverBottom = position.top + overTop + data.collisionHeight - outerHeight -
+ withinOffset;
+ position.top += overTop - newOverBottom;
+
+ // Element is initially over bottom of within
+ } else if ( overBottom > 0 && overTop <= 0 ) {
+ position.top = withinOffset;
+
+ // Element is initially over both top and bottom of within
+ } else {
+ if ( overTop > overBottom ) {
+ position.top = withinOffset + outerHeight - data.collisionHeight;
+ } else {
+ position.top = withinOffset;
+ }
+ }
+
+ // Too far up -> align with top
+ } else if ( overTop > 0 ) {
+ position.top += overTop;
+
+ // Too far down -> align with bottom edge
+ } else if ( overBottom > 0 ) {
+ position.top -= overBottom;
+
+ // Adjust based on position and margin
+ } else {
+ position.top = max( position.top - collisionPosTop, position.top );
+ }
+ }
+ },
+ flip: {
+ left: function( position, data ) {
+ var within = data.within,
+ withinOffset = within.offset.left + within.scrollLeft,
+ outerWidth = within.width,
+ offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
+ collisionPosLeft = position.left - data.collisionPosition.marginLeft,
+ overLeft = collisionPosLeft - offsetLeft,
+ overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
+ myOffset = data.my[ 0 ] === "left" ?
+ -data.elemWidth :
+ data.my[ 0 ] === "right" ?
+ data.elemWidth :
+ 0,
+ atOffset = data.at[ 0 ] === "left" ?
+ data.targetWidth :
+ data.at[ 0 ] === "right" ?
+ -data.targetWidth :
+ 0,
+ offset = -2 * data.offset[ 0 ],
+ newOverRight,
+ newOverLeft;
+
+ if ( overLeft < 0 ) {
+ newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth -
+ outerWidth - withinOffset;
+ if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
+ position.left += myOffset + atOffset + offset;
+ }
+ } else if ( overRight > 0 ) {
+ newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset +
+ atOffset + offset - offsetLeft;
+ if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
+ position.left += myOffset + atOffset + offset;
+ }
+ }
+ },
+ top: function( position, data ) {
+ var within = data.within,
+ withinOffset = within.offset.top + within.scrollTop,
+ outerHeight = within.height,
+ offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
+ collisionPosTop = position.top - data.collisionPosition.marginTop,
+ overTop = collisionPosTop - offsetTop,
+ overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
+ top = data.my[ 1 ] === "top",
+ myOffset = top ?
+ -data.elemHeight :
+ data.my[ 1 ] === "bottom" ?
+ data.elemHeight :
+ 0,
+ atOffset = data.at[ 1 ] === "top" ?
+ data.targetHeight :
+ data.at[ 1 ] === "bottom" ?
+ -data.targetHeight :
+ 0,
+ offset = -2 * data.offset[ 1 ],
+ newOverTop,
+ newOverBottom;
+ if ( overTop < 0 ) {
+ newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight -
+ outerHeight - withinOffset;
+ if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) {
+ position.top += myOffset + atOffset + offset;
+ }
+ } else if ( overBottom > 0 ) {
+ newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset +
+ offset - offsetTop;
+ if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) {
+ position.top += myOffset + atOffset + offset;
+ }
+ }
+ }
+ },
+ flipfit: {
+ left: function() {
+ $.ui.position.flip.left.apply( this, arguments );
+ $.ui.position.fit.left.apply( this, arguments );
+ },
+ top: function() {
+ $.ui.position.flip.top.apply( this, arguments );
+ $.ui.position.fit.top.apply( this, arguments );
+ }
+ }
+};
+
+} )();
+
+var position = $.ui.position;
+
+
+/*!
+ * jQuery UI Keycode 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+//>>label: Keycode
+//>>group: Core
+//>>description: Provide keycodes as keynames
+//>>docs: http://api.jqueryui.com/jQuery.ui.keyCode/
+
+
+var keycode = $.ui.keyCode = {
+ BACKSPACE: 8,
+ COMMA: 188,
+ DELETE: 46,
+ DOWN: 40,
+ END: 35,
+ ENTER: 13,
+ ESCAPE: 27,
+ HOME: 36,
+ LEFT: 37,
+ PAGE_DOWN: 34,
+ PAGE_UP: 33,
+ PERIOD: 190,
+ RIGHT: 39,
+ SPACE: 32,
+ TAB: 9,
+ UP: 38
+};
+
+
+/*!
+ * jQuery UI Scroll Parent 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+//>>label: scrollParent
+//>>group: Core
+//>>description: Get the closest ancestor element that is scrollable.
+//>>docs: http://api.jqueryui.com/scrollParent/
+
+
+
+var scrollParent = $.fn.scrollParent = function( includeHidden ) {
+ var position = this.css( "position" ),
+ excludeStaticParent = position === "absolute",
+ overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,
+ scrollParent = this.parents().filter( function() {
+ var parent = $( this );
+ if ( excludeStaticParent && parent.css( "position" ) === "static" ) {
+ return false;
+ }
+ return overflowRegex.test( parent.css( "overflow" ) + parent.css( "overflow-y" ) +
+ parent.css( "overflow-x" ) );
+ } ).eq( 0 );
+
+ return position === "fixed" || !scrollParent.length ?
+ $( this[ 0 ].ownerDocument || document ) :
+ scrollParent;
+};
+
+
+/*!
+ * jQuery UI Unique ID 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+//>>label: uniqueId
+//>>group: Core
+//>>description: Functions to generate and remove uniqueId's
+//>>docs: http://api.jqueryui.com/uniqueId/
+
+
+
+var uniqueId = $.fn.extend( {
+ uniqueId: ( function() {
+ var uuid = 0;
+
+ return function() {
+ return this.each( function() {
+ if ( !this.id ) {
+ this.id = "ui-id-" + ( ++uuid );
+ }
+ } );
+ };
+ } )(),
+
+ removeUniqueId: function() {
+ return this.each( function() {
+ if ( /^ui-id-\d+$/.test( this.id ) ) {
+ $( this ).removeAttr( "id" );
+ }
+ } );
+ }
+} );
+
+
+/*!
+ * jQuery UI Effects 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+//>>label: Effects Core
+//>>group: Effects
+// jscs:disable maximumLineLength
+//>>description: Extends the internal jQuery effects. Includes morphing and easing. Required by all other effects.
+// jscs:enable maximumLineLength
+//>>docs: http://api.jqueryui.com/category/effects-core/
+//>>demos: http://jqueryui.com/effect/
+
+
+
+var dataSpace = "ui-effects-",
+ dataSpaceStyle = "ui-effects-style",
+ dataSpaceAnimated = "ui-effects-animated",
+
+ // 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( "" )[ 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() { + +if ( $.expr && $.expr.filters && $.expr.filters.animated ) { + $.expr.filters.animated = ( function( orig ) { + return function( elem ) { + return !!$( elem ).data( dataSpaceAnimated ) || orig( elem ); + }; + } )( $.expr.filters.animated ); +} + +if ( $.uiBackCompat !== false ) { + $.extend( $.effects, { + + // Saves a set of properties in a data storage + save: function( element, set ) { + var i = 0, length = set.length; + for ( ; i < 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 = 0, length = set.length; + for ( ; i < length; i++ ) { + if ( set[ i ] !== null ) { + val = element.data( dataSpace + set[ i ] ); + element.css( set[ i ], val ); + } + } + }, + + setMode: function( el, mode ) { + if ( mode === "toggle" ) { + mode = el.is( ":hidden" ) ? "show" : "hide"; + } + return mode; + }, + + // 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 = $( "
" ) + .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 ).trigger( "focus" ); + } + + // Hotfix for jQuery 1.4 since some change in wrap() seems to actually + // lose the reference to the wrapped element + wrapper = element.parent(); + + // 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 ).trigger( "focus" ); + } + } + + return element; + } + } ); +} + +$.extend( $.effects, { + version: "1.12.1", + + define: function( name, mode, effect ) { + if ( !effect ) { + effect = mode; + mode = "effect"; + } + + $.effects.effect[ name ] = effect; + $.effects.effect[ name ].mode = mode; + + return effect; + }, + + scaledDimensions: function( element, percent, direction ) { + if ( percent === 0 ) { + return { + height: 0, + width: 0, + outerHeight: 0, + outerWidth: 0 + }; + } + + var x = direction !== "horizontal" ? ( ( percent || 100 ) / 100 ) : 1, + y = direction !== "vertical" ? ( ( percent || 100 ) / 100 ) : 1; + + return { + height: element.height() * y, + width: element.width() * x, + outerHeight: element.outerHeight() * y, + outerWidth: element.outerWidth() * x + }; + + }, + + clipToBox: function( animation ) { + return { + width: animation.clip.right - animation.clip.left, + height: animation.clip.bottom - animation.clip.top, + left: animation.clip.left, + top: animation.clip.top + }; + }, + + // Injects recently queued functions to be first in line (after "inprogress") + unshift: function( element, queueLength, count ) { + var queue = element.queue(); + + if ( queueLength > 1 ) { + queue.splice.apply( queue, + [ 1, 0 ].concat( queue.splice( queueLength, count ) ) ); + } + element.dequeue(); + }, + + saveStyle: function( element ) { + element.data( dataSpaceStyle, element[ 0 ].style.cssText ); + }, + + restoreStyle: function( element ) { + element[ 0 ].style.cssText = element.data( dataSpaceStyle ) || ""; + element.removeData( dataSpaceStyle ); + }, + + mode: function( element, mode ) { + var hidden = element.is( ":hidden" ); + + if ( mode === "toggle" ) { + mode = hidden ? "show" : "hide"; + } + if ( hidden ? mode === "hide" : mode === "show" ) { + mode = "none"; + } + return mode; + }, + + // Translates a [top,left] array into a baseline value + 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 + }; + }, + + // Creates a placeholder element so that the original element can be made absolute + createPlaceholder: function( element ) { + var placeholder, + cssPosition = element.css( "position" ), + position = element.position(); + + // Lock in margins first to account for form elements, which + // will change margin if you explicitly set height + // see: http://jsfiddle.net/JZSMt/3/ https://bugs.webkit.org/show_bug.cgi?id=107380 + // Support: Safari + element.css( { + marginTop: element.css( "marginTop" ), + marginBottom: element.css( "marginBottom" ), + marginLeft: element.css( "marginLeft" ), + marginRight: element.css( "marginRight" ) + } ) + .outerWidth( element.outerWidth() ) + .outerHeight( element.outerHeight() ); + + if ( /^(static|relative)/.test( cssPosition ) ) { + cssPosition = "absolute"; + + placeholder = $( "<" + element[ 0 ].nodeName + ">" ).insertAfter( element ).css( { + + // Convert inline to inline block to account for inline elements + // that turn to inline block based on content (like img) + display: /^(inline|ruby)/.test( element.css( "display" ) ) ? + "inline-block" : + "block", + visibility: "hidden", + + // Margins need to be set to account for margin collapse + marginTop: element.css( "marginTop" ), + marginBottom: element.css( "marginBottom" ), + marginLeft: element.css( "marginLeft" ), + marginRight: element.css( "marginRight" ), + "float": element.css( "float" ) + } ) + .outerWidth( element.outerWidth() ) + .outerHeight( element.outerHeight() ) + .addClass( "ui-effects-placeholder" ); + + element.data( dataSpace + "placeholder", placeholder ); + } + + element.css( { + position: cssPosition, + left: position.left, + top: position.top + } ); + + return placeholder; + }, + + removePlaceholder: function( element ) { + var dataKey = dataSpace + "placeholder", + placeholder = element.data( dataKey ); + + if ( placeholder ) { + placeholder.remove(); + element.removeData( dataKey ); + } + }, + + // Removes a placeholder if it exists and restores + // properties that were modified during placeholder creation + cleanUp: function( element ) { + $.effects.restoreStyle( element ); + $.effects.removePlaceholder( 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 ), + effectMethod = $.effects.effect[ args.effect ], + defaultMode = effectMethod.mode, + queue = args.queue, + queueName = queue || "fx", + complete = args.complete, + mode = args.mode, + modes = [], + prefilter = function( next ) { + var el = $( this ), + normalizedMode = $.effects.mode( el, mode ) || defaultMode; + + // Sentinel for duck-punching the :animated psuedo-selector + el.data( dataSpaceAnimated, true ); + + // Save effect mode for later use, + // we can't just call $.effects.mode again later, + // as the .show() below destroys the initial state + modes.push( normalizedMode ); + + // See $.uiBackCompat inside of run() for removal of defaultMode in 1.13 + if ( defaultMode && ( normalizedMode === "show" || + ( normalizedMode === defaultMode && normalizedMode === "hide" ) ) ) { + el.show(); + } + + if ( !defaultMode || normalizedMode !== "none" ) { + $.effects.saveStyle( el ); + } + + if ( $.isFunction( next ) ) { + next(); + } + }; + + if ( $.fx.off || !effectMethod ) { + + // Delegate to the original method (e.g., .show()) if possible + if ( mode ) { + return this[ mode ]( args.duration, complete ); + } else { + return this.each( function() { + if ( complete ) { + complete.call( this ); + } + } ); + } + } + + function run( next ) { + var elem = $( this ); + + function cleanup() { + elem.removeData( dataSpaceAnimated ); + + $.effects.cleanUp( elem ); + + if ( args.mode === "hide" ) { + elem.hide(); + } + + done(); + } + + function done() { + if ( $.isFunction( complete ) ) { + complete.call( elem[ 0 ] ); + } + + if ( $.isFunction( next ) ) { + next(); + } + } + + // Override mode option on a per element basis, + // as toggle can be either show or hide depending on element state + args.mode = modes.shift(); + + if ( $.uiBackCompat !== false && !defaultMode ) { + if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) { + + // Call the core method to track "olddisplay" properly + elem[ mode ](); + done(); + } else { + effectMethod.call( elem[ 0 ], args, done ); + } + } else { + if ( args.mode === "none" ) { + + // Call the core method to track "olddisplay" properly + elem[ mode ](); + done(); + } else { + effectMethod.call( elem[ 0 ], args, cleanup ); + } + } + } + + // Run prefilter on all elements first to ensure that + // any showing or hiding happens before placeholder creation, + // which ensures that any layout changes are correctly captured. + return queue === false ? + this.each( prefilter ).each( run ) : + this.queue( queueName, prefilter ).queue( queueName, 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 ), + + 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; + }, + + cssClip: function( clipObj ) { + if ( clipObj ) { + return this.css( "clip", "rect(" + clipObj.top + "px " + clipObj.right + "px " + + clipObj.bottom + "px " + clipObj.left + "px)" ); + } + return parseClip( this.css( "clip" ), this ); + }, + + transfer: function( options, done ) { + var element = $( this ), + target = $( options.to ), + targetFixed = target.css( "position" ) === "fixed", + body = $( "body" ), + fixTop = targetFixed ? body.scrollTop() : 0, + fixLeft = targetFixed ? body.scrollLeft() : 0, + endPosition = target.offset(), + animation = { + top: endPosition.top - fixTop, + left: endPosition.left - fixLeft, + height: target.innerHeight(), + width: target.innerWidth() + }, + startPosition = element.offset(), + transfer = $( "" ) + .appendTo( "body" ) + .addClass( options.className ) + .css( { + top: startPosition.top - fixTop, + left: startPosition.left - fixLeft, + height: element.innerHeight(), + width: element.innerWidth(), + position: targetFixed ? "fixed" : "absolute" + } ) + .animate( animation, options.duration, options.easing, function() { + transfer.remove(); + if ( $.isFunction( done ) ) { + done(); + } + } ); + } +} ); + +function parseClip( str, element ) { + var outerWidth = element.outerWidth(), + outerHeight = element.outerHeight(), + clipRegex = /^rect\((-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto),?\s*(-?\d*\.?\d*px|-?\d+%|auto)\)$/, + values = clipRegex.exec( str ) || [ "", 0, outerWidth, outerHeight, 0 ]; + + return { + top: parseFloat( values[ 1 ] ) || 0, + right: values[ 2 ] === "auto" ? outerWidth : parseFloat( values[ 2 ] ), + bottom: values[ 3 ] === "auto" ? outerHeight : parseFloat( values[ 3 ] ), + left: parseFloat( values[ 4 ] ) || 0 + }; +} + +$.fx.step.clip = function( fx ) { + if ( !fx.clipInit ) { + fx.start = $( fx.elem ).cssClip(); + if ( typeof fx.end === "string" ) { + fx.end = parseClip( fx.end, fx.elem ); + } + fx.clipInit = true; + } + + $( fx.elem ).cssClip( { + top: fx.pos * ( fx.end.top - fx.start.top ) + fx.start.top, + right: fx.pos * ( fx.end.right - fx.start.right ) + fx.start.right, + bottom: fx.pos * ( fx.end.bottom - fx.start.bottom ) + fx.start.bottom, + left: fx.pos * ( fx.end.left - fx.start.left ) + fx.start.left + } ); +}; + +} )(); + +/******************************************************************************/ +/*********************************** 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 Effects Blind 1.12.1 + * http://jqueryui.com + * + * Copyright jQuery Foundation and other contributors + * Released under the MIT license. + * http://jquery.org/license + */ + +//>>label: Blind Effect +//>>group: Effects +//>>description: Blinds the element. +//>>docs: http://api.jqueryui.com/blind-effect/ +//>>demos: http://jqueryui.com/effect/ + + + +var effectsEffectBlind = $.effects.define( "blind", "hide", function( options, done ) { + var map = { + up: [ "bottom", "top" ], + vertical: [ "bottom", "top" ], + down: [ "top", "bottom" ], + left: [ "right", "left" ], + horizontal: [ "right", "left" ], + right: [ "left", "right" ] + }, + element = $( this ), + direction = options.direction || "up", + start = element.cssClip(), + animate = { clip: $.extend( {}, start ) }, + placeholder = $.effects.createPlaceholder( element ); + + animate.clip[ map[ direction ][ 0 ] ] = animate.clip[ map[ direction ][ 1 ] ]; + + if ( options.mode === "show" ) { + element.cssClip( animate.clip ); + if ( placeholder ) { + placeholder.css( $.effects.clipToBox( animate ) ); + } + + animate.clip = start; + } + + if ( placeholder ) { + placeholder.animate( $.effects.clipToBox( animate ), options.duration, options.easing ); + } + + element.animate( animate, { + queue: false, + duration: options.duration, + easing: options.easing, + complete: done + } ); +} ); + +// NOTE: Original jQuery UI wrapper was replaced. See README-Fancytree.md +// })); +})(jQuery); + +(function( factory ) { + if ( typeof define === "function" && define.amd ) { + // AMD. Register as an anonymous module. + define( [ "jquery" ], factory ); + } else if ( typeof module === "object" && module.exports ) { + // Node/CommonJS + module.exports = factory(require("jquery")); + } else { + // Browser globals + factory( jQuery ); + } +}(function( $ ) { + + +/*! Fancytree Core *//*! + * jquery.fancytree.js + * Tree view control with support for lazy loading and much more. + * https://github.com/mar10/fancytree/ + * + * Copyright (c) 2008-2017, Martin Wendt (http://wwWendt.de) + * Released under the MIT license + * https://github.com/mar10/fancytree/wiki/LicenseInfo + * + * @version 2.26.0 + * @date 2017-11-04T17:52:53Z + */ + +/** Core Fancytree module. + */ + +// UMD wrapper for the Fancytree core module +;(function( factory ) { + if ( typeof define === "function" && define.amd ) { + // AMD. Register as an anonymous module. + define( [ "jquery", "./jquery.fancytree.ui-deps" ], factory ); + } else if ( typeof module === "object" && module.exports ) { + // Node/CommonJS + require("jquery.fancytree.ui-deps"); + module.exports = factory(require("jquery")); + } else { + // Browser globals + factory( jQuery ); + } + +}( function( $ ) { + +"use strict"; + +// prevent duplicate loading +if ( $.ui && $.ui.fancytree ) { + $.ui.fancytree.warn("Fancytree: ignored duplicate include"); + return; +} + + +/* ***************************************************************************** + * Private functions and variables + */ + +var i, attr, + FT = null, // initialized below + TEST_IMG = new RegExp(/\.|\//), // strings are considered image urls if they contain '.' or '/' + REX_HTML = /[&<>"'\/]/g, + REX_TOOLTIP = /[<>"'\/]/g, + RECURSIVE_REQUEST_ERROR = "$recursive_request", + ENTITY_MAP = {"&": "&", "<": "<", ">": ">", "\"": """, "'": "'", "/": "/"}, + IGNORE_KEYCODES = { 16: true, 17: true, 18: true }, + SPECIAL_KEYCODES = { + 8: "backspace", 9: "tab", 10: "return", 13: "return", + // 16: null, 17: null, 18: null, // ignore shift, ctrl, alt + 19: "pause", 20: "capslock", 27: "esc", 32: "space", 33: "pageup", + 34: "pagedown", 35: "end", 36: "home", 37: "left", 38: "up", + 39: "right", 40: "down", 45: "insert", 46: "del", 59: ";", 61: "=", + 96: "0", 97: "1", 98: "2", 99: "3", 100: "4", 101: "5", 102: "6", + 103: "7", 104: "8", 105: "9", 106: "*", 107: "+", 109: "-", 110: ".", + 111: "/", 112: "f1", 113: "f2", 114: "f3", 115: "f4", 116: "f5", + 117: "f6", 118: "f7", 119: "f8", 120: "f9", 121: "f10", 122: "f11", + 123: "f12", 144: "numlock", 145: "scroll", 173: "-", 186: ";", 187: "=", + 188: ",", 189: "-", 190: ".", 191: "/", 192: "`", 219: "[", 220: "\\", + 221: "]", 222: "'"}, + MOUSE_BUTTONS = { 0: "", 1: "left", 2: "middle", 3: "right" }, + // Boolean attributes that can be set with equivalent class names in the LI tags + // Note: v2.23: checkbox and hideCheckbox are *not* in this list + CLASS_ATTRS = "active expanded focus folder lazy radiogroup selected unselectable unselectableIgnore".split(" "), + CLASS_ATTR_MAP = {}, + // Top-level Fancytree node attributes, that can be set by dict + NODE_ATTRS = "checkbox expanded extraClasses folder icon key lazy radiogroup refKey selected statusNodeType title tooltip unselectable unselectableIgnore unselectableStatus".split(" "), + NODE_ATTR_MAP = {}, + // Mapping of lowercase -> real name (because HTML5 data-... attribute only supports lowercase) + NODE_ATTR_LOWERCASE_MAP = {}, + // Attribute names that should NOT be added to node.data + NONE_NODE_DATA_MAP = {"active": true, "children": true, "data": true, "focus": true}; + +for(i=0; i+ * For lazy nodes, null or undefined means 'not yet loaded'. Use an empty array + * to define a node that has no children. + * @property {boolean} expanded Use isExpanded(), setExpanded() to access this property. + * @property {string} extraClasses Additional CSS classes, added to the node's `<span>`.
+ * Note: use `node.add/remove/toggleClass()` to modify. + * @property {boolean} folder Folder nodes have different default icons and click behavior.
+ * Note: Also non-folders may have children. + * @property {string} statusNodeType null for standard nodes. Otherwise type of special system node: 'error', 'loading', 'nodata', or 'paging'. + * @property {boolean} lazy True if this node is loaded on demand, i.e. on first expansion. + * @property {boolean} selected Use isSelected(), setSelected() to access this property. + * @property {string} tooltip Alternative description used as hover popup + */ +function FancytreeNode(parent, obj){ + var i, l, name, cl; + + this.parent = parent; + this.tree = parent.tree; + this.ul = null; + this.li = null; //
+ * 'child': append this node as last child of targetNode. + * This is the default. To be compatble with the D'n'd + * hitMode, we also accept 'over'. + * 'firstChild': add this node as first child of targetNode. + * 'before': add this node as sibling before targetNode. + * 'after': add this node as sibling after targetNode.+ * @param {function} [map] optional callback(FancytreeNode) to allow modifcations + */ + moveTo: function(targetNode, mode, map) { + if(mode === undefined || mode === "over"){ + mode = "child"; + } else if ( mode === "firstChild" ) { + if( targetNode.children && targetNode.children.length ) { + mode = "before"; + targetNode = targetNode.children[0]; + } else { + mode = "child"; + } + } + var pos, + prevParent = this.parent, + targetParent = (mode === "child") ? targetNode : targetNode.parent; + + if(this === targetNode){ + return; + }else if( !this.parent ){ + $.error("Cannot move system root"); + }else if( targetParent.isDescendantOf(this) ){ + $.error("Cannot move a node to its own descendant"); + } + if( targetParent !== prevParent ) { + prevParent.triggerModifyChild("remove", this); + } + // Unlink this node from current parent + if( this.parent.children.length === 1 ) { + if( this.parent === targetParent ){ + return; // #258 + } + this.parent.children = this.parent.lazy ? [] : null; + this.parent.expanded = false; + } else { + pos = $.inArray(this, this.parent.children); + _assert(pos >= 0, "invalid source parent"); + this.parent.children.splice(pos, 1); + } + // Remove from source DOM parent +// if(this.parent.ul){ +// this.parent.ul.removeChild(this.li); +// } + + // Insert this node to target parent's child list + this.parent = targetParent; + if( targetParent.hasChildren() ) { + switch(mode) { + case "child": + // Append to existing target children + targetParent.children.push(this); + break; + case "before": + // Insert this node before target node + pos = $.inArray(targetNode, targetParent.children); + _assert(pos >= 0, "invalid target parent"); + targetParent.children.splice(pos, 0, this); + break; + case "after": + // Insert this node after target node + pos = $.inArray(targetNode, targetParent.children); + _assert(pos >= 0, "invalid target parent"); + targetParent.children.splice(pos+1, 0, this); + break; + default: + $.error("Invalid mode " + mode); + } + } else { + targetParent.children = [ this ]; + } + // Parent has no
- tag yet:
+// if( !targetParent.ul ) {
+// // This is the parent's first child: create UL tag
+// // (Hidden, because it will be
+// targetParent.ul = document.createElement("ul");
+// targetParent.ul.style.display = "none";
+// targetParent.li.appendChild(targetParent.ul);
+// }
+// // Issue 319: Add to target DOM parent (only if node was already rendered(expanded))
+// if(this.li){
+// targetParent.ul.appendChild(this.li);
+// }^
+
+ // Let caller modify the nodes
+ if( map ){
+ targetNode.visit(map, true);
+ }
+ if( targetParent === prevParent ) {
+ targetParent.triggerModifyChild("move", this);
+ } else {
+ // prevParent.triggerModifyChild("remove", this);
+ targetParent.triggerModifyChild("add", this);
+ }
+ // Handle cross-tree moves
+ if( this.tree !== targetNode.tree ) {
+ // Fix node.tree for all source nodes
+// _assert(false, "Cross-tree move is not yet implemented.");
+ this.warn("Cross-tree moveTo is experimantal!");
+ this.visit(function(n){
+ // TODO: fix selection state and activation, ...
+ n.tree = targetNode.tree;
+ }, true);
+ }
+
+ // A collaposed node won't re-render children, so we have to remove it manually
+ // if( !targetParent.expanded ){
+ // prevParent.ul.removeChild(this.li);
+ // }
+
+ // Update HTML markup
+ if( !prevParent.isDescendantOf(targetParent)) {
+ prevParent.render();
+ }
+ if( !targetParent.isDescendantOf(prevParent) && targetParent !== prevParent) {
+ targetParent.render();
+ }
+ // TODO: fix selection state
+ // TODO: fix active state
+
+/*
+ var tree = this.tree;
+ var opts = tree.options;
+ var pers = tree.persistence;
+
+
+ // Always expand, if it's below minExpandLevel
+// tree.logDebug ("%s._addChildNode(%o), l=%o", this, ftnode, ftnode.getLevel());
+ if ( opts.minExpandLevel >= ftnode.getLevel() ) {
+// tree.logDebug ("Force expand for %o", ftnode);
+ this.bExpanded = true;
+ }
+
+ // In multi-hier mode, update the parents selection state
+ // DT issue #82: only if not initializing, because the children may not exist yet
+// if( !ftnode.data.isStatusNode() && opts.selectMode==3 && !isInitializing )
+// ftnode._fixSelectionState();
+
+ // In multi-hier mode, update the parents selection state
+ if( ftnode.bSelected && opts.selectMode==3 ) {
+ var p = this;
+ while( p ) {
+ if( !p.hasSubSel )
+ p._setSubSel(true);
+ p = p.parent;
+ }
+ }
+ // render this node and the new child
+ if ( tree.bEnableUpdate )
+ this.render();
+
+ return ftnode;
+
+*/
+ },
+ /** Set focus relative to this node and optionally activate.
+ *
+ * @param {number} where The keyCode that would normally trigger this move,
+ * e.g. `$.ui.keyCode.LEFT` would collapse the node if it
+ * is expanded or move to the parent oterwise.
+ * @param {boolean} [activate=true]
+ * @returns {$.Promise}
+ */
+ navigate: function(where, activate) {
+ var i, parents, res,
+ handled = true,
+ KC = $.ui.keyCode,
+ sib = null;
+
+ // Navigate to node
+ function _goto(n){
+ if( n ){
+ // setFocus/setActive will scroll later (if autoScroll is specified)
+ try { n.makeVisible({scrollIntoView: false}); } catch(e) {} // #272
+ // Node may still be hidden by a filter
+ if( ! $(n.span).is(":visible") ) {
+ n.debug("Navigate: skipping hidden node");
+ n.navigate(where, activate);
+ return;
+ }
+ return activate === false ? n.setFocus() : n.setActive();
+ }
+ }
+
+ switch( where ) {
+ case KC.BACKSPACE:
+ if( this.parent && this.parent.parent ) {
+ res = _goto(this.parent);
+ }
+ break;
+ case KC.HOME:
+ this.tree.visit(function(n){ // goto first visible node
+ if( $(n.span).is(":visible") ) {
+ res = _goto(n);
+ return false;
+ }
+ });
+ break;
+ case KC.END:
+ this.tree.visit(function(n){ // goto last visible node
+ if( $(n.span).is(":visible") ) {
+ res = n;
+ }
+ });
+ if( res ) {
+ res = _goto(res);
+ }
+ break;
+ case KC.LEFT:
+ if( this.expanded ) {
+ this.setExpanded(false);
+ res = _goto(this);
+ } else if( this.parent && this.parent.parent ) {
+ res = _goto(this.parent);
+ }
+ break;
+ case KC.RIGHT:
+ if( !this.expanded && (this.children || this.lazy) ) {
+ this.setExpanded();
+ res = _goto(this);
+ } else if( this.children && this.children.length ) {
+ res = _goto(this.children[0]);
+ }
+ break;
+ case KC.UP:
+ sib = this.getPrevSibling();
+ // #359: skip hidden sibling nodes, preventing a _goto() recursion
+ while( sib && !$(sib.span).is(":visible") ) {
+ sib = sib.getPrevSibling();
+ }
+ while( sib && sib.expanded && sib.children && sib.children.length ) {
+ sib = sib.children[sib.children.length - 1];
+ }
+ if( !sib && this.parent && this.parent.parent ){
+ sib = this.parent;
+ }
+ res = _goto(sib);
+ break;
+ case KC.DOWN:
+ if( this.expanded && this.children && this.children.length ) {
+ sib = this.children[0];
+ } else {
+ parents = this.getParentList(false, true);
+ for(i=parents.length-1; i>=0; i--) {
+ sib = parents[i].getNextSibling();
+ // #359: skip hidden sibling nodes, preventing a _goto() recursion
+ while( sib && !$(sib.span).is(":visible") ) {
+ sib = sib.getNextSibling();
+ }
+ if( sib ){ break; }
+ }
+ }
+ res = _goto(sib);
+ break;
+ default:
+ handled = false;
+ }
+ return res || _getResolvedPromise();
+ },
+ /**
+ * Remove this node (not allowed for system root).
+ */
+ remove: function() {
+ return this.parent.removeChild(this);
+ },
+ /**
+ * Remove childNode from list of direct children.
+ * @param {FancytreeNode} childNode
+ */
+ removeChild: function(childNode) {
+ return this.tree._callHook("nodeRemoveChild", this, childNode);
+ },
+ /**
+ * Remove all child nodes and descendents. This converts the node into a leaf.
- It should only be neccessary to call this method after the node object + * was modified by direct access to its properties, because the common + * API methods (node.setTitle(), moveTo(), addChildren(), remove(), ...) + * already handle this. + *
- {@link FancytreeNode#renderTitle} and {@link FancytreeNode#renderStatus} + * are implied. If changes are more local, calling only renderTitle() or + * renderStatus() may be sufficient and faster. + *
- +// node.debug("render..."); + if( !node.li ) { +// node.debug("render... really"); + firstTime = true; + node.li = document.createElement("li"); + node.li.ftnode = node; + + if( node.key && opts.generateIds ){ + node.li.id = opts.idPrefix + node.key; + } + node.span = document.createElement("span"); + node.span.className = "fancytree-node"; + if( aria && !node.tr ) { + $(node.li).attr("role", "treeitem"); + } + node.li.appendChild(node.span); + + // Create inner HTML for the (expander, checkbox, icon, and title) + this.nodeRenderTitle(ctx); + + // Allow tweaking and binding, after node was created for the first time + if ( opts.createNode ){ + opts.createNode.call(tree, {type: "createNode"}, ctx); + } + }else{ +// this.nodeRenderTitle(ctx); + this.nodeRenderStatus(ctx); + } + // Allow tweaking after node state was rendered + if ( opts.renderNode ){ + opts.renderNode.call(tree, {type: "renderNode"}, ctx); + } + } + + // Visit child nodes + if( children ){ + if( isRootNode || node.expanded || deep === true ) { + // Create a UL to hold the children + if( !node.ul ){ + node.ul = document.createElement("ul"); + if((collapsed === true && !_recursive) || !node.expanded){ + // hide top UL, so we can use an animation to show it later + node.ul.style.display = "none"; + } + if(aria){ + $(node.ul).attr("role", "group"); + } + if ( node.li ) { // issue #67 + node.li.appendChild(node.ul); + } else { + node.tree.$div.append(node.ul); + } + } + // Add child markup + for(i=0, l=children.length; i
- order matches node.children order.
+ childLI = node.ul.firstChild;
+ for(i=0, l=children.length-1; i
"); + } else { + ares.push(""); + } + } else { + // standard icon: theme css will take care of this + ares.push(""); + } + } + // Node title + nodeTitle = ""; + if ( opts.renderTitle ){ + nodeTitle = opts.renderTitle.call(tree, {type: "renderTitle"}, ctx) || ""; + } + if ( !nodeTitle ) { + tooltip = FT.evalOption("tooltip", node, node, opts, null); + if( tooltip === true ) { + tooltip = node.title; + } + // if( node.tooltip ) { + // tooltip = node.tooltip; + // } else if ( opts.tooltip ) { + // tooltip = opts.tooltip === true ? node.title : opts.tooltip.call(tree, node); + // } + tooltip = tooltip ? " title='" + _escapeTooltip(tooltip) + "'" : ""; + tabindex = opts.titlesTabbable ? " tabindex='0'" : ""; + + nodeTitle = "" + + (opts.escapeTitles ? FT.escapeHtml(node.title) : node.title) + + ""; + } + ares.push(nodeTitle); + // Note: this will trigger focusout, if node had the focus + //$(node.span).html(ares.join("")); // it will cleanup the jQuery data currently associated with SPAN (if any), but it executes more slowly + node.span.innerHTML = ares.join(""); + // Update CSS classes + this.nodeRenderStatus(ctx); + if ( opts.enhanceTitle ){ + ctx.$title = $(">span.fancytree-title", node.span); + nodeTitle = opts.enhanceTitle.call(tree, {type: "enhanceTitle"}, ctx) || ""; + } + }, + /** Update element classes according to node state. + * @param {EventData} ctx + */ + nodeRenderStatus: function(ctx) { + // Set classes for current status + var $ariaElem, + node = ctx.node, + tree = ctx.tree, + opts = ctx.options, +// nodeContainer = node[tree.nodeContainerAttrName], + hasChildren = node.hasChildren(), + isLastSib = node.isLastSibling(), + aria = opts.aria, + cn = opts._classNames, + cnList = [], + statusElem = node[tree.statusClassPropName]; + + if( !statusElem || tree._enableUpdate === false ){ + // if this function is called for an unrendered node, ignore it (will be updated on nect render anyway) + return; + } + if( aria ) { + $ariaElem = $(node.tr || node.li); + } + // Build a list of class names that we will add to the node + cnList.push(cn.node); + if( tree.activeNode === node ){ + cnList.push(cn.active); +// $(">span.fancytree-title", statusElem).attr("tabindex", "0"); +// tree.$container.removeAttr("tabindex"); + // }else{ +// $(">span.fancytree-title", statusElem).removeAttr("tabindex"); +// tree.$container.attr("tabindex", "0"); + } + if( tree.focusNode === node ){ + cnList.push(cn.focused); + } + if( node.expanded ){ + cnList.push(cn.expanded); + } + if( aria ){ + if (hasChildren !== false) { + $ariaElem.attr("aria-expanded", Boolean(node.expanded)); + } + else { + $ariaElem.removeAttr("aria-expanded"); + } + } + if( node.folder ){ + cnList.push(cn.folder); + } + if( hasChildren !== false ){ + cnList.push(cn.hasChildren); + } + // TODO: required? + if( isLastSib ){ + cnList.push(cn.lastsib); + } + if( node.lazy && node.children == null ){ + cnList.push(cn.lazy); + } + if( node.partload ){ + cnList.push(cn.partload); + } + if( node.partsel ){ + cnList.push(cn.partsel); + } + if( FT.evalOption("unselectable", node, node, opts, false) ){ + cnList.push(cn.unselectable); + } + if( node._isLoading ){ + cnList.push(cn.loading); + } + if( node._error ){ + cnList.push(cn.error); + } + if( node.statusNodeType ) { + cnList.push(cn.statusNodePrefix + node.statusNodeType); + } + if( node.selected ){ + cnList.push(cn.selected); + if(aria){ + $ariaElem.attr("aria-selected", true); + } + }else if(aria){ + $ariaElem.attr("aria-selected", false); + } + if( node.extraClasses ){ + cnList.push(node.extraClasses); + } + // IE6 doesn't correctly evaluate multiple class names, + // so we create combined class names that can be used in the CSS + if( hasChildren === false ){ + cnList.push(cn.combinedExpanderPrefix + "n" + + (isLastSib ? "l" : "") + ); + }else{ + cnList.push(cn.combinedExpanderPrefix + + (node.expanded ? "e" : "c") + + (node.lazy && node.children == null ? "d" : "") + + (isLastSib ? "l" : "") + ); + } + cnList.push(cn.combinedIconPrefix + + (node.expanded ? "e" : "c") + + (node.folder ? "f" : "") + ); +// node.span.className = cnList.join(" "); + statusElem.className = cnList.join(" "); + + // TODO: we should not set this in the tag also, if we set it here: + // Maybe most (all) of the classes should be set in LI instead of SPAN? + if(node.li){ + // #719: we have to consider that there may be already other classes: + $(node.li).toggleClass(cn.lastsib, isLastSib); + } + }, + /** Activate node. + * flag defaults to true. + * If flag is true, the node is activated (must be a synchronous operation) + * If flag is false, the node is deactivated (must be a synchronous operation) + * @param {EventData} ctx + * @param {boolean} [flag=true] + * @param {object} [opts] additional options. Defaults to {noEvents: false, noFocus: false} + * @returns {$.Promise} + */ + nodeSetActive: function(ctx, flag, callOpts) { + // Handle user click / [space] / [enter], according to clickFolderMode. + callOpts = callOpts || {}; + var subCtx, + node = ctx.node, + tree = ctx.tree, + opts = ctx.options, + noEvents = (callOpts.noEvents === true), + noFocus = (callOpts.noFocus === true), + isActive = (node === tree.activeNode); + + // flag defaults to true + flag = (flag !== false); + // node.debug("nodeSetActive", flag); + + if(isActive === flag){ + // Nothing to do + return _getResolvedPromise(node); + }else if(flag && !noEvents && this._triggerNodeEvent("beforeActivate", node, ctx.originalEvent) === false ){ + // Callback returned false + return _getRejectedPromise(node, ["rejected"]); + } + if(flag){ + if(tree.activeNode){ + _assert(tree.activeNode !== node, "node was active (inconsistency)"); + subCtx = $.extend({}, ctx, {node: tree.activeNode}); + tree.nodeSetActive(subCtx, false); + _assert(tree.activeNode === null, "deactivate was out of sync?"); + } + if(opts.activeVisible){ + // If no focus is set (noFocus: true) and there is no focused node, this node is made visible. + node.makeVisible({scrollIntoView: noFocus && tree.focusNode == null}); + } + tree.activeNode = node; + tree.nodeRenderStatus(ctx); + if( !noFocus ) { + tree.nodeSetFocus(ctx); + } + if( !noEvents ) { + tree._triggerNodeEvent("activate", node, ctx.originalEvent); + } + }else{ + _assert(tree.activeNode === node, "node was not active (inconsistency)"); + tree.activeNode = null; + this.nodeRenderStatus(ctx); + if( !noEvents ) { + ctx.tree._triggerNodeEvent("deactivate", node, ctx.originalEvent); + } + } + return _getResolvedPromise(node); + }, + /** Expand or collapse node, return Deferred.promise. + * + * @param {EventData} ctx + * @param {boolean} [flag=true] + * @param {object} [opts] additional options. Defaults to {noAnimation: false, noEvents: false} + * @returns {$.Promise} The deferred will be resolved as soon as the (lazy) + * data was retrieved, rendered, and the expand animation finshed. + */ + nodeSetExpanded: function(ctx, flag, callOpts) { + callOpts = callOpts || {}; + var _afterLoad, dfd, i, l, parents, prevAC, + node = ctx.node, + tree = ctx.tree, + opts = ctx.options, + noAnimation = (callOpts.noAnimation === true), + noEvents = (callOpts.noEvents === true); + + // flag defaults to true + flag = (flag !== false); + + // node.debug("nodeSetExpanded(" + flag + ")"); + + if((node.expanded && flag) || (!node.expanded && !flag)){ + // Nothing to do + // node.debug("nodeSetExpanded(" + flag + "): nothing to do"); + return _getResolvedPromise(node); + }else if(flag && !node.lazy && !node.hasChildren() ){ + // Prevent expanding of empty nodes + // return _getRejectedPromise(node, ["empty"]); + return _getResolvedPromise(node); + }else if( !flag && node.getLevel() < opts.minExpandLevel ) { + // Prevent collapsing locked levels + return _getRejectedPromise(node, ["locked"]); + }else if ( !noEvents && this._triggerNodeEvent("beforeExpand", node, ctx.originalEvent) === false ){ + // Callback returned false + return _getRejectedPromise(node, ["rejected"]); + } + // If this node inside a collpased node, no animation and scrolling is needed + if( !noAnimation && !node.isVisible() ) { + noAnimation = callOpts.noAnimation = true; + } + + dfd = new $.Deferred(); + + // Auto-collapse mode: collapse all siblings + if( flag && !node.expanded && opts.autoCollapse ) { + parents = node.getParentList(false, true); + prevAC = opts.autoCollapse; + try{ + opts.autoCollapse = false; + for(i=0, l=parents.length; i
-
+ this.data = $.extend(this.data, _getElementDataAsDict($ul));
+ break;
+ case "json":
+ source = $.parseJSON($container.text());
+ // $container already contains the
- , but we remove the plain (json) text
+ // $container.empty();
+ $container.contents().filter(function(){
+ return (this.nodeType === 3);
+ }).remove();
+ if( $.isPlainObject(source) ){
+ // We got {foo: 'abc', children: [...]}
+ // Copy extra properties to tree.data.foo
+ _assert($.isArray(source.children), "if an object is passed as source, it must contain a 'children' array (all other properties are added to 'tree.data')");
+ metaData = source;
+ source = source.children;
+ delete metaData.children;
+ $.extend(tree.data, metaData);
+ }
+ break;
+ default:
+ $.error("Invalid data-type: " + type);
+ }
+ }else if(typeof source === "string"){
+ // TODO: source is an element ID
+ $.error("Not implemented");
+ }
+
+ // Trigger fancytreeinit after nodes have been loaded
+ dfd = this.nodeLoadChildren(rootCtx, source).done(function(){
+ tree.render();
+ if( ctx.options.selectMode === 3 ){
+ tree.rootNode.fixSelection3FromEndNodes();
+ }
+ if( tree.activeNode && tree.options.activeVisible ) {
+ tree.activeNode.makeVisible();
+ }
+ tree._triggerTreeEvent("init", null, { status: true });
+ }).fail(function(){
+ tree.render();
+ tree._triggerTreeEvent("init", null, { status: false });
+ });
+ return dfd;
+ },
+ /** Node was inserted into or removed from the tree.
+ * @param {EventData} ctx
+ * @param {boolean} add
+ * @param {FancytreeNode} node
+ */
+ treeRegisterNode: function(ctx, add, node) {
+ },
+ /** Widget got focus.
+ * @param {EventData} ctx
+ * @param {boolean} [flag=true]
+ */
+ treeSetFocus: function(ctx, flag, callOpts) {
+ var targetNode;
+
+ flag = (flag !== false);
+
+ // this.debug("treeSetFocus(" + flag + "), callOpts: ", callOpts, this.hasFocus());
+ // this.debug(" focusNode: " + this.focusNode);
+ // this.debug(" activeNode: " + this.activeNode);
+ if( flag !== this.hasFocus() ){
+ this._hasFocus = flag;
+ if( !flag && this.focusNode ) {
+ // Node also looses focus if widget blurs
+ this.focusNode.setFocus(false);
+ } else if ( flag && (!callOpts || !callOpts.calledByNode) ) {
+ $(this.$container).focus();
+ }
+ this.$container.toggleClass("fancytree-treefocus", flag);
+ this._triggerTreeEvent(flag ? "focusTree" : "blurTree");
+ if( flag && !this.activeNode ) {
+ // #712: Use last mousedowned node ('click' event fires after focusin)
+ targetNode = this._lastMousedownNode || this.getFirstChild();
+ targetNode && targetNode.setFocus();
+ }
+ }
+ },
+ /** Widget option was set using `$().fancytree("option", "foo", "bar")`.
+ * @param {EventData} ctx
+ * @param {string} key option name
+ * @param {any} value option value
+ */
+ treeSetOption: function(ctx, key, value) {
+ var tree = ctx.tree,
+ callDefault = true,
+ callCreate = false,
+ callRender = false;
+
+ switch( key ) {
+ case "aria":
+ case "checkbox":
+ case "icon":
+ case "minExpandLevel":
+ case "tabindex":
+ // tree._callHook("treeCreate", tree);
+ callCreate = true;
+ callRender = true;
+ break;
+ case "escapeTitles":
+ case "tooltip":
+ callRender = true;
+ break;
+ case "rtl":
+ if( value === false ) {
+ tree.$container.removeAttr("DIR").removeClass("fancytree-rtl");
+ }else{
+ tree.$container.attr("DIR", "RTL").addClass("fancytree-rtl");
+ }
+ callRender = true;
+ break;
+ case "source":
+ callDefault = false;
+ tree._callHook("treeLoad", tree, value);
+ callRender = true;
+ break;
+ }
+ tree.debug("set option " + key + "=" + value + " <" + typeof(value) + ">");
+ if(callDefault){
+ if( this.widget._super ) {
+ // jQuery UI 1.9+
+ this.widget._super.call( this.widget, key, value );
+ } else {
+ // jQuery UI <= 1.8, we have to manually invoke the _setOption method from the base widget
+ $.Widget.prototype._setOption.call(this.widget, key, value);
+ }
+ }
+ if(callCreate){
+ tree._callHook("treeCreate", tree);
+ }
+ if(callRender){
+ tree.render(true, false); // force, not-deep
+ }
+ }
+});
+
+
+/* ******************************************************************************
+ * jQuery UI widget boilerplate
+ */
+
+/**
+ * The plugin (derrived from jQuery.Widget).
+ * This constructor is not called directly. Use `$(selector).fancytree({})` + * to initialize the plugin instead.
+ *// Access widget methods and members: + * var tree = $("#tree").fancytree("getTree"); + * var node = $("#tree").fancytree("getActiveNode", "1234"); + *+ * + * @mixin Fancytree_Widget + */ + +$.widget("ui.fancytree", + /** @lends Fancytree_Widget# */ + { + /**These options will be used as defaults + * @type {FancytreeOptions} + */ + options: + { + activeVisible: true, + ajax: { + type: "GET", + cache: false, // false: Append random '_' argument to the request url to prevent caching. +// timeout: 0, // >0: Make sure we get an ajax error if server is unreachable + dataType: "json" // Expect json format and pass json object to callbacks. + }, // + aria: true, + autoActivate: true, + autoCollapse: false, + autoScroll: false, + checkbox: false, + clickFolderMode: 4, + debugLevel: null, // 0..2 (null: use global setting $.ui.fancytree.debugInfo) + disabled: false, // TODO: required anymore? + enableAspx: true, + escapeTitles: false, + extensions: [], + // fx: { height: "toggle", duration: 200 }, + // toggleEffect: { effect: "drop", options: {direction: "left"}, duration: 200 }, + // toggleEffect: { effect: "slide", options: {direction: "up"}, duration: 200 }, + toggleEffect: { effect: "blind", options: {direction: "vertical", scale: "box"}, duration: 200 }, + generateIds: false, + icon: true, + idPrefix: "ft_", + focusOnSelect: false, + keyboard: true, + keyPathSeparator: "/", + minExpandLevel: 1, + quicksearch: false, + rtl: false, + scrollOfs: {top: 0, bottom: 0}, + scrollParent: null, + selectMode: 2, + strings: { + loading: "Loading...", // … would be escaped when escapeTitles is true + loadError: "Load error!", + moreData: "More...", + noData: "No data." + }, + tabindex: "0", + titlesTabbable: false, + tooltip: false, + _classNames: { + node: "fancytree-node", + folder: "fancytree-folder", + animating: "fancytree-animating", + combinedExpanderPrefix: "fancytree-exp-", + combinedIconPrefix: "fancytree-ico-", + hasChildren: "fancytree-has-children", + active: "fancytree-active", + selected: "fancytree-selected", + expanded: "fancytree-expanded", + lazy: "fancytree-lazy", + focused: "fancytree-focused", + partload: "fancytree-partload", + partsel: "fancytree-partsel", + radio: "fancytree-radio", + // radiogroup: "fancytree-radiogroup", + unselectable: "fancytree-unselectable", + lastsib: "fancytree-lastsib", + loading: "fancytree-loading", + error: "fancytree-error", + statusNodePrefix: "fancytree-statusnode-" + }, + // events + lazyLoad: null, + postProcess: null + }, + /* Set up the widget, Called on first $().fancytree() */ + _create: function() { + this.tree = new Fancytree(this); + + this.$source = this.source || this.element.data("type") === "json" ? this.element + : this.element.find(">ul:first"); + // Subclass Fancytree instance with all enabled extensions + var extension, extName, i, + opts = this.options, + extensions = opts.extensions, + base = this.tree; + + for(i=0; i
+ *
+ *// Access static members: + * var node = $.ui.fancytree.getNode(element); + * alert($.ui.fancytree.version); + *
+ * + * @mixin Fancytree_Static + */ +$.extend($.ui.fancytree, + /** @lends Fancytree_Static# */ + { + /** @type {string} */ + version: "2.26.0", // Set to semver by 'grunt release' + /** @type {string} */ + buildType: "production", // Set to 'production' by 'grunt build' + /** @type {int} */ + debugLevel: 1, // Set to 1 by 'grunt build' + // Used by $.ui.fancytree.debug() and as default for tree.options.debugLevel + + _nextId: 1, + _nextNodeKey: 1, + _extensions: {}, + // focusTree: null, + + /** Expose class object as $.ui.fancytree._FancytreeClass */ + _FancytreeClass: Fancytree, + /** Expose class object as $.ui.fancytree._FancytreeNodeClass */ + _FancytreeNodeClass: FancytreeNode, + /* Feature checks to provide backwards compatibility */ + jquerySupports: { + // http://jqueryui.com/upgrade-guide/1.9/#deprecated-offset-option-merged-into-my-and-at + positionMyOfs: isVersionAtLeast($.ui.version, 1, 9) + }, + /** Throw an error if condition fails (debug method). + * @param {boolean} cond + * @param {string} msg + */ + assert: function(cond, msg){ + return _assert(cond, msg); + }, + /** Create a new Fancytree instance on a target element. + * + * @param {Element | jQueryObject | string} el Target DOM element or selector + * @param {FancytreeOptions} [opts] Fancytree options + * @returns {Fancytree} new tree instance + * @example + * var tree = $.ui.fancytree.createTree("#tree", { + * source: {url: "my/webservice"} + * }); // Create tree for this matching element + * + * @since 2.25 + */ + createTree: function(el, opts){ + var tree = $(el).fancytree(opts).fancytree("getTree"); + return tree; + }, + /** Return a function that executes *fn* at most every *timeout* ms. + * @param {integer} timeout + * @param {function} fn + * @param {boolean} [invokeAsap=false] + * @param {any} [ctx] + */ + debounce: function(timeout, fn, invokeAsap, ctx) { + var timer; + if(arguments.length === 3 && typeof invokeAsap !== "boolean") { + ctx = invokeAsap; + invokeAsap = false; + } + return function() { + var args = arguments; + ctx = ctx || this; + invokeAsap && !timer && fn.apply(ctx, args); + clearTimeout(timer); + timer = setTimeout(function() { + invokeAsap || fn.apply(ctx, args); + timer = null; + }, timeout); + }; + }, + /** Write message to console if debugLevel >= 2 + * @param {string} msg + */ + debug: function(msg){ + /*jshint expr:true */ + ($.ui.fancytree.debugLevel >= 2) && consoleApply("log", arguments); + }, + /** Write error message to console. + * @param {string} msg + */ + error: function(msg){ + consoleApply("error", arguments); + }, + /** Convert <, >, &, ", ', / to the equivalent entities. + * + * @param {string} s + * @returns {string} + */ + escapeHtml: function(s){ + return ("" + s).replace(REX_HTML, function(s) { + return ENTITY_MAP[s]; + }); + }, + /** Make jQuery.position() arguments backwards compatible, i.e. if + * jQuery UI version <= 1.8, convert + * { my: "left+3 center", at: "left bottom", of: $target } + * to + * { my: "left center", at: "left bottom", of: $target, offset: "3 0" } + * + * See http://jqueryui.com/upgrade-guide/1.9/#deprecated-offset-option-merged-into-my-and-at + * and http://jsfiddle.net/mar10/6xtu9a4e/ + */ + fixPositionOptions: function(opts) { + if( opts.offset || ("" + opts.my + opts.at ).indexOf("%") >= 0 ) { + $.error("expected new position syntax (but '%' is not supported)"); + } + if( ! $.ui.fancytree.jquerySupports.positionMyOfs ) { + var // parse 'left+3 center' into ['left+3 center', 'left', '+3', 'center', undefined] + myParts = /(\w+)([+-]?\d+)?\s+(\w+)([+-]?\d+)?/.exec(opts.my), + atParts = /(\w+)([+-]?\d+)?\s+(\w+)([+-]?\d+)?/.exec(opts.at), + // convert to numbers + dx = (myParts[2] ? (+myParts[2]) : 0) + (atParts[2] ? (+atParts[2]) : 0), + dy = (myParts[4] ? (+myParts[4]) : 0) + (atParts[4] ? (+atParts[4]) : 0); + + opts = $.extend({}, opts, { // make a copy and overwrite + my: myParts[1] + " " + myParts[3], + at: atParts[1] + " " + atParts[3] + }); + if( dx || dy ) { + opts.offset = "" + dx + " " + dy; + } + } + return opts; + }, + /** Return a {node: FancytreeNode, type: TYPE} object for a mouse event. + * + * @param {Event} event Mouse event, e.g. click, ... + * @returns {object} Return a {node: FancytreeNode, type: TYPE} object + * TYPE: 'title' | 'prefix' | 'expander' | 'checkbox' | 'icon' | undefined + */ + getEventTarget: function(event){ + var tcn = event && event.target ? event.target.className : "", + res = {node: this.getNode(event.target), type: undefined}; + // We use a fast version of $(res.node).hasClass() + // See http://jsperf.com/test-for-classname/2 + if( /\bfancytree-title\b/.test(tcn) ){ + res.type = "title"; + }else if( /\bfancytree-expander\b/.test(tcn) ){ + res.type = (res.node.hasChildren() === false ? "prefix" : "expander"); + // }else if( /\bfancytree-checkbox\b/.test(tcn) || /\bfancytree-radio\b/.test(tcn) ){ + }else if( /\bfancytree-checkbox\b/.test(tcn) ){ + res.type = "checkbox"; + }else if( /\bfancytree(-custom)?-icon\b/.test(tcn) ){ + res.type = "icon"; + }else if( /\bfancytree-node\b/.test(tcn) ){ + // Somewhere near the title + res.type = "title"; + }else if( event && $(event.target).is("ul[role=group]") ) { + // #nnn: Clicking right to a node may hit the surrounding UL + FT.info("Ignoring click on outer UL."); + res.node = null; + }else if( event && event.target && $(event.target).closest(".fancytree-title").length ) { + // #228: clicking an embedded element inside a title + res.type = "title"; + } + return res; + }, + /** Return a string describing the affected node region for a mouse event. + * + * @param {Event} event Mouse event, e.g. click, mousemove, ... + * @returns {string} 'title' | 'prefix' | 'expander' | 'checkbox' | 'icon' | undefined + */ + getEventTargetType: function(event){ + return this.getEventTarget(event).type; + }, + /** Return a FancytreeNode instance from element, event, or jQuery object. + * + * @param {Element | jQueryObject | Event} el + * @returns {FancytreeNode} matching node or null + */ + getNode: function(el){ + if(el instanceof FancytreeNode){ + return el; // el already was a FancytreeNode + }else if( el instanceof $ ){ + el = el[0]; // el was a jQuery object: use the DOM element + }else if(el.originalEvent !== undefined){ + el = el.target; // el was an Event + } + while( el ) { + if(el.ftnode) { + return el.ftnode; + } + el = el.parentNode; + } + return null; + }, + /** Return a Fancytree instance, from element, index, event, or jQueryObject. + * + * @param {Element | jQueryObject | Event | integer | string} [el] + * @returns {Fancytree} matching tree or null + * @example + * $.ui.fancytree.getTree(); // Get first Fancytree instance on page + * $.ui.fancytree.getTree(1); // Get second Fancytree instance on page + * $.ui.fancytree.getTree("#tree"); // Get tree for this matching element + * + * @since 2.13 + */ + getTree: function(el){ + var widget; + + if( el instanceof Fancytree ) { + return el; // el already was a Fancytree + } + if( el === undefined ) { + el = 0; // get first tree + } + if( typeof el === "number" ) { + el = $(".fancytree-container").eq(el); // el was an integer: return nth instance + } else if( typeof el === "string" ) { + el = $(el).eq(0); // el was a selector: use first match + } else if( el.selector !== undefined ) { + el = el.eq(0); // el was a jQuery object: use the first DOM element + } else if( el.originalEvent !== undefined ) { + el = $(el.target); // el was an Event + } + el = el.closest(":ui-fancytree"); + widget = el.data("ui-fancytree") || el.data("fancytree"); // the latter is required by jQuery <= 1.8 + return widget ? widget.tree : null; + }, + /** Return an option value that has a default, but may be overridden by a + * callback or a node instance attribute. + * + * Evaluation sequence:
+ * + * If tree.options.is a callback that returns something, use that.
+ * Else if node.is defined, use that.
+ * Else if tree.options.is a value, use that.
+ * Else use `defaultValue`. + * + * @param {string} optionName name of the option property (on node and tree) + * @param {FancytreeNode} node passed to the callback + * @param {object} nodeObject where to look for the local option property, e.g. `node` or `node.data` + * @param {object} treeOption where to look for the tree option, e.g. `tree.options` or `tree.options.dnd5` + * @param {any} [defaultValue] + * @returns {any} + * + * @example + * // Check for node.foo, tree,options.foo(), and tree.options.foo: + * $.ui.fancytree.evalOption("foo", node, node, tree.options); + * // Check for node.data.bar, tree,options.qux.bar(), and tree.options.qux.bar: + * $.ui.fancytree.evalOption("bar", node, node.data, tree.options.qux); + * + * @since 2.22 + */ + evalOption: function(optionName, node, nodeObject, treeOptions, defaultValue) { + var ctx, res, + tree = node.tree, + treeOpt = treeOptions[optionName], + nodeOpt = nodeObject[optionName]; + + if( $.isFunction(treeOpt) ) { + ctx = { node: node, tree: tree, widget: tree.widget, options: tree.widget.options }; + res = treeOpt.call(tree, {type: optionName}, ctx); + if( res == null ) { + res = nodeOpt; + } + } else { + res = (nodeOpt != null) ? nodeOpt : treeOpt; + } + if( res == null ) { + res = defaultValue; // no option set at all: return default + } + return res; + }, + /** Convert a keydown or mouse event to a canonical string like 'ctrl+a', + * 'ctrl+shift+f2', 'shift+leftdblclick'. + * + * This is especially handy for switch-statements in event handlers. + * + * @param {event} + * @returns {string} + * + * @example + + switch( $.ui.fancytree.eventToString(event) ) { + case "-": + tree.nodeSetExpanded(ctx, false); + break; + case "shift+return": + tree.nodeSetActive(ctx, true); + break; + case "down": + res = node.navigate(event.which, activate, true); + break; + default: + handled = false; + } + if( handled ){ + event.preventDefault(); + } + */ + eventToString: function(event) { + // Poor-man's hotkeys. See here for a complete implementation: + // https://github.com/jeresig/jquery.hotkeys + var which = event.which, + et = event.type, + s = []; + + if( event.altKey ) { s.push("alt"); } + if( event.ctrlKey ) { s.push("ctrl"); } + if( event.metaKey ) { s.push("meta"); } + if( event.shiftKey ) { s.push("shift"); } + + if( et === "click" || et === "dblclick" ) { + s.push(MOUSE_BUTTONS[event.button] + et); + } else { + if( !IGNORE_KEYCODES[which] ) { + s.push( SPECIAL_KEYCODES[which] || String.fromCharCode(which).toLowerCase() ); + } + } + return s.join("+"); + }, + /** Write message to console if debugLevel >= 1 + * @param {string} msg + */ + info: function(msg){ + /*jshint expr:true */ + ($.ui.fancytree.debugLevel >= 1) && consoleApply("info", arguments); + }, + /* @deprecated: use eventToString(event) instead. + */ + keyEventToString: function(event) { + this.warn("keyEventToString() is deprecated: use eventToString()"); + return this.eventToString(event); + }, + /** Return a wrapped handler method, that provides `this.super`. + * + * @example + // Implement `opts.createNode` event to add the 'draggable' attribute + $.ui.fancytree.overrideMethod(ctx.options, "createNode", function(event, data) { + // Default processing if any + this._super.apply(this, arguments); + // Add 'draggable' attribute + data.node.span.draggable = true; + }); + * + * @param {object} instance + * @param {string} methodName + * @param {function} handler + */ + overrideMethod: function(instance, methodName, handler){ + var prevSuper, + _super = instance[methodName] || $.noop; + + // context = context || this; + + instance[methodName] = function() { + try { + prevSuper = this._super; + this._super = _super; + return handler.apply(this, arguments); + } finally { + this._super = prevSuper; + } + }; + }, + /** + * Parse tree data from HTML- markup
+ *
+ * @param {jQueryObject} $ul
+ * @returns {NodeData[]}
+ */
+ parseHtml: function($ul) {
+ // TODO: understand this:
+ /*jshint validthis:true */
+ var classes, className, extraClasses, i, iPos, l, tmp, tmp2,
+ $children = $ul.find(">li"),
+ children = [];
+
+ $children.each(function() {
+ var allData, lowerCaseAttr,
+ $li = $(this),
+ $liSpan = $li.find(">span:first", this),
+ $liA = $liSpan.length ? null : $li.find(">a:first"),
+ d = { tooltip: null, data: {} };
+
+ if( $liSpan.length ) {
+ d.title = $liSpan.html();
+
+ } else if( $liA && $liA.length ) {
+ // If a
- tag is specified, use it literally and extract href/target.
+ d.title = $liA.html();
+ d.data.href = $liA.attr("href");
+ d.data.target = $liA.attr("target");
+ d.tooltip = $liA.attr("title");
+
+ } else {
+ // If only a
- tag is specified, use the trimmed string up to + // the next child
- tag.
+ d.title = $li.html();
+ iPos = d.title.search(/
- as node.data.NAME
+ allData = _getElementDataAsDict($li);
+ if( allData && !$.isEmptyObject(allData) ) {
+ // #507: convert data-hidecheckbox (lower case) to hideCheckbox
+ for( lowerCaseAttr in NODE_ATTR_LOWERCASE_MAP ) {
+ if( allData.hasOwnProperty(lowerCaseAttr) ) {
+ allData[NODE_ATTR_LOWERCASE_MAP[lowerCaseAttr]] = allData[lowerCaseAttr];
+ delete allData[lowerCaseAttr];
+ }
+ }
+ // #56: Allow to set special node.attributes from data-...
+ for(i=0, l=NODE_ATTRS.length; i
+// `this` : the Fancytree instance
+// `this._local`: the namespace that contains extension attributes and private methods (same as this.ext.EXTNAME)
+// `this._super`: the virtual function that was overridden (member of previous extension or Fancytree) +// +// See also the [complete list of available hook functions](http://www.wwwendt.de/tech/fancytree/doc/jsdoc/Fancytree_Hooks.html). + + /* Init */ +// `treeInit` is triggered when a tree is initalized. We can set up classes or +// bind event handlers here... + treeInit: function(ctx){ + var tree = this, // same as ctx.tree, + opts = ctx.options, + extOpts = ctx.options.childcounter; +// Optionally check for dependencies with other extensions + /* this._requireExtension("glyph", false, false); */ +// Call the base implementation + this._superApply(arguments); +// Add a class to the tree container + this.$container.addClass("fancytree-ext-childcounter"); + }, + +// Destroy this tree instance (we only call the default implementation, so +// this method could as well be omitted). + + treeDestroy: function(ctx){ + this._superApply(arguments); + }, + +// Overload the `renderTitle` hook, to append a counter badge + nodeRenderTitle: function(ctx, title) { + var node = ctx.node, + extOpts = ctx.options.childcounter, + count = (node.data.childCounter == null) ? node.countChildren(extOpts.deep) : +node.data.childCounter; +// Let the base implementation render the title +// We use `_super()` instead of `_superApply()` here, since it is a little bit +// more performant when called often + this._super(ctx, title); +// Append a counter badge + if( (count || ! extOpts.hideZeros) && (!node.isExpanded() || !extOpts.hideExpanded) ){ + $("span.fancytree-icon", node.span).append($("").text(count)); + } + }, +// Overload the `setExpanded` hook, so the counters are updated + nodeSetExpanded: function(ctx, flag, callOpts) { + var tree = ctx.tree, + node = ctx.node; +// Let the base implementation expand/collapse the node, then redraw the title +// after the animation has finished + return this._superApply(arguments).always(function(){ + tree.nodeRenderTitle(ctx); + }); + } + +// End of extension definition +}); +// Value returned by `require('jquery.fancytree..')` +return $.ui.fancytree; +})); // End of closure + + +/*! Extension 'jquery.fancytree.clones.js' *//*! + * + * jquery.fancytree.clones.js + * Support faster lookup of nodes by key and shared ref-ids. + * (Extension module for jquery.fancytree.js: https://github.com/mar10/fancytree/) + * + * Copyright (c) 2008-2017, Martin Wendt (http://wwWendt.de) + * + * Released under the MIT license + * https://github.com/mar10/fancytree/wiki/LicenseInfo + * + * @version 2.26.0 + * @date 2017-11-04T17:52:53Z + */ + +;(function( factory ) { + if ( typeof define === "function" && define.amd ) { + // AMD. Register as an anonymous module. + define( [ "jquery", "./jquery.fancytree" ], factory ); + } else if ( typeof module === "object" && module.exports ) { + // Node/CommonJS + require("jquery.fancytree"); + module.exports = factory(require("jquery")); + } else { + // Browser globals + factory( jQuery ); + } + +}( function( $ ) { + +"use strict"; + +/******************************************************************************* + * Private functions and variables + */ +function _assert(cond, msg){ + // TODO: see qunit.js extractStacktrace() + if(!cond){ + msg = msg ? ": " + msg : ""; + $.error("Assertion failed" + msg); + } +} + + +/* Return first occurrence of member from array. */ +function _removeArrayMember(arr, elem) { + // TODO: use Array.indexOf for IE >= 9 + var i; + for (i = arr.length - 1; i >= 0; i--) { + if (arr[i] === elem) { + arr.splice(i, 1); + return true; + } + } + return false; +} + + +// /** +// * Calculate a 32 bit FNV-1a hash +// * Found here: https://gist.github.com/vaiorabbit/5657561 +// * Ref.: http://isthe.com/chongo/tech/comp/fnv/ +// * +// * @param {string} str the input value +// * @param {boolean} [asString=false] set to true to return the hash value as +// * 8-digit hex string instead of an integer +// * @param {integer} [seed] optionally pass the hash of the previous chunk +// * @returns {integer | string} +// */ +// function hashFnv32a(str, asString, seed) { +// /*jshint bitwise:false */ +// var i, l, +// hval = (seed === undefined) ? 0x811c9dc5 : seed; + +// for (i = 0, l = str.length; i < l; i++) { +// hval ^= str.charCodeAt(i); +// hval += (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24); +// } +// if( asString ){ +// // Convert to 8 digit hex string +// return ("0000000" + (hval >>> 0).toString(16)).substr(-8); +// } +// return hval >>> 0; +// } + + +/** + * JS Implementation of MurmurHash3 (r136) (as of May 20, 2011) + * + * @author Gary Court + * @see http://github.com/garycourt/murmurhash-js + * @author Austin Appleby + * @see http://sites.google.com/site/murmurhash/ + * + * @param {string} key ASCII only + * @param {boolean} [asString=false] + * @param {number} seed Positive integer only + * @return {number} 32-bit positive integer hash + */ +function hashMurmur3(key, asString, seed) { + /*jshint bitwise:false */ + var h1b, k1, + remainder = key.length & 3, + bytes = key.length - remainder, + h1 = seed, + c1 = 0xcc9e2d51, + c2 = 0x1b873593, + i = 0; + + while (i < bytes) { + k1 = + ((key.charCodeAt(i) & 0xff)) | + ((key.charCodeAt(++i) & 0xff) << 8) | + ((key.charCodeAt(++i) & 0xff) << 16) | + ((key.charCodeAt(++i) & 0xff) << 24); + ++i; + + k1 = ((((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16))) & 0xffffffff; + k1 = (k1 << 15) | (k1 >>> 17); + k1 = ((((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16))) & 0xffffffff; + + h1 ^= k1; + h1 = (h1 << 13) | (h1 >>> 19); + h1b = ((((h1 & 0xffff) * 5) + ((((h1 >>> 16) * 5) & 0xffff) << 16))) & 0xffffffff; + h1 = (((h1b & 0xffff) + 0x6b64) + ((((h1b >>> 16) + 0xe654) & 0xffff) << 16)); + } + + k1 = 0; + + switch (remainder) { + /*jshint -W086:true */ + case 3: k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16; + case 2: k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8; + case 1: k1 ^= (key.charCodeAt(i) & 0xff); + + k1 = (((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16)) & 0xffffffff; + k1 = (k1 << 15) | (k1 >>> 17); + k1 = (((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16)) & 0xffffffff; + h1 ^= k1; + } + + h1 ^= key.length; + + h1 ^= h1 >>> 16; + h1 = (((h1 & 0xffff) * 0x85ebca6b) + ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16)) & 0xffffffff; + h1 ^= h1 >>> 13; + h1 = ((((h1 & 0xffff) * 0xc2b2ae35) + ((((h1 >>> 16) * 0xc2b2ae35) & 0xffff) << 16))) & 0xffffffff; + h1 ^= h1 >>> 16; + + if( asString ){ + // Convert to 8 digit hex string + return ("0000000" + (h1 >>> 0).toString(16)).substr(-8); + } + return h1 >>> 0; +} + +// console.info(hashMurmur3("costarring")); +// console.info(hashMurmur3("costarring", true)); +// console.info(hashMurmur3("liquid")); +// console.info(hashMurmur3("liquid", true)); + + +/* + * Return a unique key for node by calculationg the hash of the parents refKey-list + */ +function calcUniqueKey(node) { + var key, + path = $.map(node.getParentList(false, true), function(e){ return e.refKey || e.key; }); + path = path.join("/"); + key = "id_" + hashMurmur3(path, true); + // node.debug(path + " -> " + key); + return key; +} + + +/** + * [ext-clones] Return a list of clone-nodes or null. + * @param {boolean} [includeSelf=false] + * @returns {FancytreeNode[] | null} + * + * @alias FancytreeNode#getCloneList + * @requires jquery.fancytree.clones.js + */ +$.ui.fancytree._FancytreeNodeClass.prototype.getCloneList = function(includeSelf){ + var key, + tree = this.tree, + refList = tree.refMap[this.refKey] || null, + keyMap = tree.keyMap; + + if( refList ) { + key = this.key; + // Convert key list to node list + if( includeSelf ) { + refList = $.map(refList, function(val){ return keyMap[val]; }); + } else { + refList = $.map(refList, function(val){ return val === key ? null : keyMap[val]; }); + if( refList.length < 1 ) { + refList = null; + } + } + } + return refList; +}; + + +/** + * [ext-clones] Return true if this node has at least another clone with same refKey. + * @returns {boolean} + * + * @alias FancytreeNode#isClone + * @requires jquery.fancytree.clones.js + */ +$.ui.fancytree._FancytreeNodeClass.prototype.isClone = function(){ + var refKey = this.refKey || null, + refList = refKey && this.tree.refMap[refKey] || null; + return !!(refList && refList.length > 1); +}; + + +/** + * [ext-clones] Update key and/or refKey for an existing node. + * @param {string} key + * @param {string} refKey + * @returns {boolean} + * + * @alias FancytreeNode#reRegister + * @requires jquery.fancytree.clones.js + */ +$.ui.fancytree._FancytreeNodeClass.prototype.reRegister = function(key, refKey){ + key = (key == null) ? null : "" + key; + refKey = (refKey == null) ? null : "" + refKey; + // this.debug("reRegister", key, refKey); + + var tree = this.tree, + prevKey = this.key, + prevRefKey = this.refKey, + keyMap = tree.keyMap, + refMap = tree.refMap, + refList = refMap[prevRefKey] || null, +// curCloneKeys = refList ? node.getCloneList(true), + modified = false; + + // Key has changed: update all references + if( key != null && key !== this.key ) { + if( keyMap[key] ) { + $.error("[ext-clones] reRegister(" + key + "): already exists: " + this); + } + // Update keyMap + delete keyMap[prevKey]; + keyMap[key] = this; + // Update refMap + if( refList ) { + refMap[prevRefKey] = $.map(refList, function(e){ + return e === prevKey ? key : e; + }); + } + this.key = key; + modified = true; + } + + // refKey has changed + if( refKey != null && refKey !== this.refKey ) { + // Remove previous refKeys + if( refList ){ + if( refList.length === 1 ){ + delete refMap[prevRefKey]; + }else{ + refMap[prevRefKey] = $.map(refList, function(e){ + return e === prevKey ? null : e; + }); + } + } + // Add refKey + if( refMap[refKey] ) { + refMap[refKey].append(key); + }else{ + refMap[refKey] = [ this.key ]; + } + this.refKey = refKey; + modified = true; + } + return modified; +}; + + +/** + * [ext-clones] Define a refKey for an existing node. + * @param {string} refKey + * @returns {boolean} + * + * @alias FancytreeNode#setRefKey + * @requires jquery.fancytree.clones.js + * @since 2.16 + */ +$.ui.fancytree._FancytreeNodeClass.prototype.setRefKey = function(refKey){ + return this.reRegister(null, refKey); +}; + + +/** + * [ext-clones] Return all nodes with a given refKey (null if not found). + * @param {string} refKey + * @param {FancytreeNode} [rootNode] optionally restrict results to descendants of this node + * @returns {FancytreeNode[] | null} + * @alias Fancytree#getNodesByRef + * @requires jquery.fancytree.clones.js + */ +$.ui.fancytree._FancytreeClass.prototype.getNodesByRef = function(refKey, rootNode){ + var keyMap = this.keyMap, + refList = this.refMap[refKey] || null; + + if( refList ) { + // Convert key list to node list + if( rootNode ) { + refList = $.map(refList, function(val){ + var node = keyMap[val]; + return node.isDescendantOf(rootNode) ? node : null; + }); + }else{ + refList = $.map(refList, function(val){ return keyMap[val]; }); + } + if( refList.length < 1 ) { + refList = null; + } + } + return refList; +}; + + +/** + * [ext-clones] Replace a refKey with a new one. + * @param {string} oldRefKey + * @param {string} newRefKey + * @alias Fancytree#changeRefKey + * @requires jquery.fancytree.clones.js + */ +$.ui.fancytree._FancytreeClass.prototype.changeRefKey = function(oldRefKey, newRefKey) { + var i, node, + keyMap = this.keyMap, + refList = this.refMap[oldRefKey] || null; + + if (refList) { + for (i = 0; i < refList.length; i++) { + node = keyMap[refList[i]]; + node.refKey = newRefKey; + } + delete this.refMap[oldRefKey]; + this.refMap[newRefKey] = refList; + } +}; + + +/******************************************************************************* + * Extension code + */ +$.ui.fancytree.registerExtension({ + name: "clones", + version: "2.26.0", + // Default options for this extension. + options: { + highlightActiveClones: true, // set 'fancytree-active-clone' on active clones and all peers + highlightClones: false // set 'fancytree-clone' class on any node that has at least one clone + }, + + treeCreate: function(ctx){ + this._superApply(arguments); + ctx.tree.refMap = {}; + ctx.tree.keyMap = {}; + }, + treeInit: function(ctx){ + this.$container.addClass("fancytree-ext-clones"); + _assert(ctx.options.defaultKey == null); + // Generate unique / reproducible default keys + ctx.options.defaultKey = function(node){ + return calcUniqueKey(node); + }; + // The default implementation loads initial data + this._superApply(arguments); + }, + treeClear: function(ctx){ + ctx.tree.refMap = {}; + ctx.tree.keyMap = {}; + return this._superApply(arguments); + }, + treeRegisterNode: function(ctx, add, node) { + var refList, len, + tree = ctx.tree, + keyMap = tree.keyMap, + refMap = tree.refMap, + key = node.key, + refKey = (node && node.refKey != null) ? "" + node.refKey : null; + +// ctx.tree.debug("clones.treeRegisterNode", add, node); + + if( node.isStatusNode() ){ + return this._super(ctx, add, node); + } + + if( add ) { + if( keyMap[node.key] != null ) { + $.error("clones.treeRegisterNode: node.key already exists: " + node); + } + keyMap[key] = node; + if( refKey ) { + refList = refMap[refKey]; + if( refList ) { + refList.push(key); + if( refList.length === 2 && ctx.options.clones.highlightClones ) { + // Mark peer node, if it just became a clone (no need to + // mark current node, since it will be rendered later anyway) + keyMap[refList[0]].renderStatus(); + } + } else { + refMap[refKey] = [key]; + } + // node.debug("clones.treeRegisterNode: add clone =>", refMap[refKey]); + } + }else { + if( keyMap[key] == null ) { + $.error("clones.treeRegisterNode: node.key not registered: " + node.key); + } + delete keyMap[key]; + if( refKey ) { + refList = refMap[refKey]; + // node.debug("clones.treeRegisterNode: remove clone BEFORE =>", refMap[refKey]); + if( refList ) { + len = refList.length; + if( len <= 1 ){ + _assert(len === 1); + _assert(refList[0] === key); + delete refMap[refKey]; + }else{ + _removeArrayMember(refList, key); + // Unmark peer node, if this was the only clone + if( len === 2 && ctx.options.clones.highlightClones ) { +// node.debug("clones.treeRegisterNode: last =>", node.getCloneList()); + keyMap[refList[0]].renderStatus(); + } + } + // node.debug("clones.treeRegisterNode: remove clone =>", refMap[refKey]); + } + } + } + return this._super(ctx, add, node); + }, + nodeRenderStatus: function(ctx) { + var $span, res, + node = ctx.node; + + res = this._super(ctx); + + if( ctx.options.clones.highlightClones ) { + $span = $(node[ctx.tree.statusClassPropName]); + // Only if span already exists + if( $span.length && node.isClone() ){ +// node.debug("clones.nodeRenderStatus: ", ctx.options.clones.highlightClones); + $span.addClass("fancytree-clone"); + } + } + return res; + }, + nodeSetActive: function(ctx, flag, callOpts) { + var res, + scpn = ctx.tree.statusClassPropName, + node = ctx.node; + + res = this._superApply(arguments); + + if( ctx.options.clones.highlightActiveClones && node.isClone() ) { + $.each(node.getCloneList(true), function(idx, n){ + // n.debug("clones.nodeSetActive: ", flag !== false); + $(n[scpn]).toggleClass("fancytree-active-clone", flag !== false); + }); + } + return res; + } +}); +// Value returned by `require('jquery.fancytree..')` +return $.ui.fancytree; +})); // End of closure + + +/*! Extension 'jquery.fancytree.dnd5.js' *//*! + * jquery.fancytree.dnd5.js + * + * Drag-and-drop support (native HTML5). + * (Extension module for jquery.fancytree.js: https://github.com/mar10/fancytree/) + * + * Copyright (c) 2008-2017, Martin Wendt (http://wwWendt.de) + * + * Released under the MIT license + * https://github.com/mar10/fancytree/wiki/LicenseInfo + * + * @version 2.26.0 + * @date 2017-11-04T17:52:53Z + */ + + + /* + #TODO + Compatiblity when dragging between *separate* windows: + + Drag from Chrome Edge FF IE11 Safari + To Chrome ok ok ok NO ? + Edge ok ok ok NO ? + FF ok ok ok NO ? + IE 11 ok ok ok ok ? + Safari ? ? ? ? ok + + */ + +;(function( factory ) { + if ( typeof define === "function" && define.amd ) { + // AMD. Register as an anonymous module. + define( [ "jquery", "./jquery.fancytree" ], factory ); + } else if ( typeof module === "object" && module.exports ) { + // Node/CommonJS + require("jquery.fancytree"); + module.exports = factory(require("jquery")); + } else { + // Browser globals + factory( jQuery ); + } + +}( function( $ ) { + +"use strict"; + +/* ***************************************************************************** + * Private functions and variables + */ +var + classDragSource = "fancytree-drag-source", + classDragRemove = "fancytree-drag-remove", + classDropAccept = "fancytree-drop-accept", + classDropAfter = "fancytree-drop-after", + classDropBefore = "fancytree-drop-before", + classDropOver = "fancytree-drop-over", + classDropReject = "fancytree-drop-reject", + classDropTarget = "fancytree-drop-target", + nodeMimeType = "application/x-fancytree-node", + $dropMarker = null, + SOURCE_NODE = null, + DRAG_ENTER_RESPONSE = null, + LAST_HIT_MODE = null; + +/* Convert number to string and prepend +/-; return empty string for 0.*/ +function offsetString(n){ + return n === 0 ? "" : (( n > 0 ) ? ("+" + n) : ("" + n)); +} + +/* Convert a dragEnter() or dragOver() response to a canonical form. + * Return false or plain object + * @param {string|object|boolean} r + * @return {object|false} + */ +function normalizeDragEnterResponse(r) { + var res; + + if( !r ){ + return false; + } + if ( $.isPlainObject(r) ) { + res = { + over: !!r.over, + before: !!r.before, + after: !!r.after + }; + }else if ( $.isArray(r) ) { + res = { + over: ($.inArray("over", r) >= 0), + before: ($.inArray("before", r) >= 0), + after: ($.inArray("after", r) >= 0) + }; + }else{ + res = { + over: ((r === true) || (r === "over")), + before: ((r === true) || (r === "before")), + after: ((r === true) || (r === "after")) + }; + } + if( Object.keys(res).length === 0 ) { + return false; + } + // if( Object.keys(res).length === 1 ) { + // res.unique = res[0]; + // } + return res; +} + +/* Implement auto scrolling when drag cursor is in top/bottom area of scroll parent. */ +function autoScroll(tree, event) { + var spOfs, scrollTop, delta, + dndOpts = tree.options.dnd5, + sp = tree.$scrollParent[0], + sensitivity = dndOpts.scrollSensitivity, + speed = dndOpts.scrollSpeed, + scrolled = 0; + + if ( sp !== document && sp.tagName !== "HTML" ) { + spOfs = tree.$scrollParent.offset(); + scrollTop = sp.scrollTop; + if ( spOfs.top + sp.offsetHeight - event.pageY < sensitivity ) { + delta = (sp.scrollHeight - tree.$scrollParent.innerHeight() - scrollTop); + // console.log ("sp.offsetHeight: " + sp.offsetHeight + // + ", spOfs.top: " + spOfs.top + // + ", scrollTop: " + scrollTop + // + ", innerHeight: " + tree.$scrollParent.innerHeight() + // + ", scrollHeight: " + sp.scrollHeight + // + ", delta: " + delta + // ); + if( delta > 0 ) { + sp.scrollTop = scrolled = scrollTop + speed; + } + } else if ( scrollTop > 0 && event.pageY - spOfs.top < sensitivity ) { + sp.scrollTop = scrolled = scrollTop - speed; + } + } else { + scrollTop = $(document).scrollTop(); + if (scrollTop > 0 && event.pageY - scrollTop < sensitivity) { + scrolled = scrollTop - speed; + $(document).scrollTop(scrolled); + } else if ($(window).height() - (event.pageY - scrollTop) < sensitivity) { + scrolled = scrollTop + speed; + $(document).scrollTop(scrolled); + } + } + if( scrolled ) { + tree.debug("autoScroll: " + scrolled + "px"); + } + return scrolled; +} + +/* Handle dragover event (fired every x ms) and return hitMode. */ +function handleDragOver(event, data) { + // Implement auto-scrolling + if ( data.options.dnd5.scroll ) { + autoScroll(data.tree, event); + } + // Bail out with previous response if we get an invalid dragover + if( !data.node ) { + data.tree.warn("Ignore dragover for non-node"); //, event, data); + return LAST_HIT_MODE; + } + + var markerOffsetX, nodeOfs, relPosY, //res, + // eventHash = getEventHash(event), + hitMode = null, + tree = data.tree, + options = tree.options, + dndOpts = options.dnd5, + targetNode = data.node, + sourceNode = data.otherNode, + markerAt = "center", + // $source = sourceNode ? $(sourceNode.span) : null, + $target = $(targetNode.span), + $targetTitle = $target.find("span.fancytree-title"); + + if(DRAG_ENTER_RESPONSE === false){ + tree.info("Ignore dragover, since dragenter returned false"); //, event, data); + // $.error("assert failed: dragenter returned false"); + return false; + } else if(typeof DRAG_ENTER_RESPONSE === "string") { + $.error("assert failed: dragenter returned string"); + // Use hitMode from onEnter if provided. + // hitMode = DRAG_ENTER_RESPONSE; + } else { + // Calculate hitMode from relative cursor position. + nodeOfs = $target.offset(); + relPosY = (event.pageY - nodeOfs.top) / $target.height(); + + if( DRAG_ENTER_RESPONSE.after && relPosY > 0.75 ){ + hitMode = "after"; + } else if(!DRAG_ENTER_RESPONSE.over && DRAG_ENTER_RESPONSE.after && relPosY > 0.5 ){ + hitMode = "after"; + } else if(DRAG_ENTER_RESPONSE.before && relPosY <= 0.25) { + hitMode = "before"; + } else if(!DRAG_ENTER_RESPONSE.over && DRAG_ENTER_RESPONSE.before && relPosY <= 0.5) { + hitMode = "before"; + } else if(DRAG_ENTER_RESPONSE.over) { + hitMode = "over"; + } + // Prevent no-ops like 'before source node' + // TODO: these are no-ops when moving nodes, but not in copy mode + if( dndOpts.preventVoidMoves ){ + if(targetNode === sourceNode){ + targetNode.debug("drop over source node prevented"); + hitMode = null; + }else if(hitMode === "before" && sourceNode && targetNode === sourceNode.getNextSibling()){ + targetNode.debug("drop after source node prevented"); + hitMode = null; + }else if(hitMode === "after" && sourceNode && targetNode === sourceNode.getPrevSibling()){ + targetNode.debug("drop before source node prevented"); + hitMode = null; + }else if(hitMode === "over" && sourceNode && sourceNode.parent === targetNode && sourceNode.isLastSibling() ){ + targetNode.debug("drop last child over own parent prevented"); + hitMode = null; + } + } + } + // Let callback modify the calculated hitMode + data.hitMode = hitMode; + if(hitMode && dndOpts.dragOver){ + // TODO: http://code.google.com/p/dynatree/source/detail?r=625 + dndOpts.dragOver(targetNode, data); + hitMode = data.hitMode; + } + // LAST_DROP_EFFECT = data.dataTransfer.dropEffect; + // LAST_EFFECT_ALLOWED = data.dataTransfer.effectAllowed; + LAST_HIT_MODE = hitMode; + // + if( hitMode === "after" || hitMode === "before" || hitMode === "over" ){ + markerOffsetX = dndOpts.dropMarkerOffsetX || 0; + switch(hitMode){ + case "before": + markerAt = "top"; + markerOffsetX += (dndOpts.dropMarkerInsertOffsetX || 0); + break; + case "after": + markerAt = "bottom"; + markerOffsetX += (dndOpts.dropMarkerInsertOffsetX || 0); + break; + } + + $dropMarker + .toggleClass(classDropAfter, hitMode === "after") + .toggleClass(classDropOver, hitMode === "over") + .toggleClass(classDropBefore, hitMode === "before") + .show() + .position($.ui.fancytree.fixPositionOptions({ + my: "left" + offsetString(markerOffsetX) + " center", + at: "left " + markerAt, + of: $targetTitle + })); + } else { + $dropMarker.hide(); + // console.log("hide dropmarker") + } + // if( $source ){ + // $source.toggleClass(classDragRemove, isMove); + // } + $(targetNode.span) + .toggleClass(classDropTarget, hitMode === "after" || hitMode === "before" || hitMode === "over") + .toggleClass(classDropAfter, hitMode === "after") + .toggleClass(classDropBefore, hitMode === "before") + .toggleClass(classDropAccept, hitMode === "over") + .toggleClass(classDropReject, hitMode === false); + + return hitMode; +} + +/* ***************************************************************************** + * + */ + +$.ui.fancytree.registerExtension({ + name: "dnd5", + version: "2.26.0", + // Default options for this extension. + options: { + autoExpandMS: 1500, // Expand nodes after n milliseconds of hovering + setTextTypeJson: false, // Allow dragging of nodes to different IE windows + preventForeignNodes: false, // Prevent dropping nodes from different Fancytrees + preventNonNodes: false, // Prevent dropping items other than Fancytree nodes + preventRecursiveMoves: true, // Prevent dropping nodes on own descendants + preventVoidMoves: true, // Prevent dropping nodes 'before self', etc. + scroll: true, // Enable auto-scrolling while dragging + scrollSensitivity: 20, // Active top/bottom margin in pixel + scrollSpeed: 5, // Pixel per event + dropMarkerOffsetX: -24, // absolute position offset for .fancytree-drop-marker relatively to ..fancytree-title (icon/img near a node accepting drop) + dropMarkerInsertOffsetX: -16,// additional offset for drop-marker with hitMode = "before"/"after" + // Events (drag support) + dragStart: null, // Callback(sourceNode, data), return true, to enable dnd drag + dragDrag: $.noop, // Callback(sourceNode, data) + dragEnd: $.noop, // Callback(sourceNode, data) + // Events (drop support) + dragEnter: null, // Callback(targetNode, data), return true, to enable dnd drop + dragOver: $.noop, // Callback(targetNode, data) + dragExpand: $.noop, // Callback(targetNode, data), return false to prevent autoExpand + dragDrop: $.noop, // Callback(targetNode, data) + dragLeave: $.noop // Callback(targetNode, data) + }, + + treeInit: function(ctx){ + var $temp, + tree = ctx.tree, + opts = ctx.options, + glyph = opts.glyph || null, + dndOpts = opts.dnd5, + getNode = $.ui.fancytree.getNode; + + if( $.inArray("dnd", opts.extensions) >= 0 ) { + $.error("Extensions 'dnd' and 'dnd5' are mutually exclusive."); + } + if( dndOpts.dragStop ) { + $.error("dragStop is not used by ext-dnd5. Use dragEnd instead."); + } + + // Implement `opts.createNode` event to add the 'draggable' attribute + // #680: this must happen before calling super.treeInit() + if( dndOpts.dragStart ) { + $.ui.fancytree.overrideMethod(ctx.options, "createNode", function(event, data) { + // Default processing if any + this._super.apply(this, arguments); + + data.node.span.draggable = true; + }); + } + this._superApply(arguments); + + this.$container.addClass("fancytree-ext-dnd5"); + + // Store the current scroll parent, which may be the tree + // container, any enclosing div, or the document. + // #761: scrollParent() always needs a container child + $temp = $("").appendTo(this.$container); + this.$scrollParent = $temp.scrollParent(); + $temp.remove(); + + $dropMarker = $("#fancytree-drop-marker"); + if( !$dropMarker.length ) { + $dropMarker = $("") + .hide() + .css({ + "z-index": 1000, + // Drop marker should not steal dragenter/dragover events: + "pointer-events": "none" + }).prependTo("body"); + if( glyph ) { + $dropMarker.addClass(glyph.map.dropMarker); + } + } + // Enable drag support if dragStart() is specified: + if( dndOpts.dragStart ) { + // Bind drag event handlers + tree.$container.on("dragstart drag dragend", function(event){ + var json, + node = getNode(event), + dataTransfer = event.dataTransfer || event.originalEvent.dataTransfer, + isMove = dataTransfer.dropEffect === "move", + $source = node ? $(node.span) : null, + data = { + node: node, + tree: tree, + options: tree.options, + originalEvent: event, + dataTransfer: dataTransfer, +// dropEffect: undefined, // set by dragend + isCancelled: undefined // set by dragend + }; + + switch( event.type ) { + + case "dragstart": + $(node.span).addClass(classDragSource); + + // Store current source node in different formats + SOURCE_NODE = node; + + // Set payload + // Note: + // Transfer data is only accessible on dragstart and drop! + // For all other events the formats and kinds in the drag + // data store list of items representing dragged data can be + // enumerated, but the data itself is unavailable and no new + // data can be added. + json = JSON.stringify(node.toDict()); + try { + dataTransfer.setData(nodeMimeType, json); + dataTransfer.setData("text/html", $(node.span).html()); + dataTransfer.setData("text/plain", node.title); + } catch(ex) { + // IE only accepts 'text' type + tree.warn("Could not set data (IE only accepts 'text') - " + ex); + } + // We always need to set the 'text' type if we want to drag + // Because IE 11 only accepts this single type. + // If we pass JSON here, IE can can access all node properties, + // even when the source lives in another window. (D'n'd inside + // the same window will always work.) + // The drawback is, that in this case ALL browsers will see + // the JSON representation as 'text', so dragging + // to a text field will insert the JSON string instead of + // the node title. + if( dndOpts.setTextTypeJson ) { + dataTransfer.setData("text", json); + } else { + dataTransfer.setData("text", node.title); + } + + // Set the allowed and current drag mode (move, copy, or link) + dataTransfer.effectAllowed = "all"; // "copyMove" + // dataTransfer.dropEffect = "move"; + + // Set the title as drag image (otherwise it would contain the expander) + if( dataTransfer.setDragImage ) { + // IE 11 does not support this + dataTransfer.setDragImage($(node.span).find(".fancytree-title")[0], -10, -10); + // dataTransfer.setDragImage($(node.span)[0], -10, -10); + } + // Let user modify above settings + return dndOpts.dragStart(node, data) !== false; + + case "drag": + // Called every few miliseconds + $source.toggleClass(classDragRemove, isMove); + dndOpts.dragDrag(node, data); + break; + + case "dragend": + $(node.span).removeClass(classDragSource + " " + classDragRemove); + SOURCE_NODE = null; + DRAG_ENTER_RESPONSE = null; +// data.dropEffect = dataTransfer.dropEffect; + data.isCancelled = (dataTransfer.dropEffect === "none"); + $dropMarker.hide(); + dndOpts.dragEnd(node, data); + break; + } + }); + } + // Enable drop support if dragEnter() is specified: + if( dndOpts.dragEnter ) { + // Bind drop event handlers + tree.$container.on("dragenter dragover dragleave drop", function(event){ + var json, nodeData, r, res, + allowDrop = null, + node = getNode(event), + dataTransfer = event.dataTransfer || event.originalEvent.dataTransfer, + data = { + node: node, + tree: tree, + options: tree.options, + hitMode: DRAG_ENTER_RESPONSE, + originalEvent: event, + dataTransfer: dataTransfer, + otherNode: SOURCE_NODE || null, + otherNodeData: null, // set by drop event + dropEffect: undefined, // set by drop event + isCancelled: undefined // set by drop event + }; + + switch( event.type ) { + + case "dragenter": + // The dragenter event is fired when a dragged element or + // text selection enters a valid drop target. + + if( !node ) { + // Sometimes we get dragenter for the container element + tree.debug("Ignore non-node " + event.type + ": " + event.target.tagName + "." + event.target.className); + DRAG_ENTER_RESPONSE = false; + break; + } + + $(node.span) + .addClass(classDropOver) + .removeClass(classDropAccept + " " + classDropReject); + + if( dndOpts.preventNonNodes && !nodeData ) { + node.debug("Reject dropping a non-node"); + DRAG_ENTER_RESPONSE = false; + break; + } else if( dndOpts.preventForeignNodes && (!SOURCE_NODE || SOURCE_NODE.tree !== node.tree ) ) { + node.debug("Reject dropping a foreign node"); + DRAG_ENTER_RESPONSE = false; + break; + } + + // NOTE: dragenter is fired BEFORE the dragleave event + // of the previous element! + // https://www.w3.org/Bugs/Public/show_bug.cgi?id=19041 + setTimeout(function(){ + // node.info("DELAYED " + event.type, event.target, DRAG_ENTER_RESPONSE); + // Auto-expand node (only when 'over' the node, not 'before', or 'after') + if( dndOpts.autoExpandMS && + node.hasChildren() !== false && !node.expanded && + (!dndOpts.dragExpand || dndOpts.dragExpand(node, data) !== false) + ) { + node.scheduleAction("expand", dndOpts.autoExpandMS); + } + }, 0); + + $dropMarker.show(); + + // Call dragEnter() to figure out if (and where) dropping is allowed + if( dndOpts.preventRecursiveMoves && node.isDescendantOf(data.otherNode) ){ + res = false; + }else{ + r = dndOpts.dragEnter(node, data); + res = normalizeDragEnterResponse(r); + } + DRAG_ENTER_RESPONSE = res; + + allowDrop = res && ( res.over || res.before || res.after ); + break; + + case "dragover": + // The dragover event is fired when an element or text + // selection is being dragged over a valid drop target + // (every few hundred milliseconds). + LAST_HIT_MODE = handleDragOver(event, data); + allowDrop = !!LAST_HIT_MODE; + break; + + case "dragleave": + // NOTE: dragleave is fired AFTER the dragenter event of the + // FOLLOWING element. + if( !node ) { + tree.debug("Ignore non-node " + event.type + ": " + event.target.tagName + "." + event.target.className); + break; + } + if( !$(node.span).hasClass(classDropOver) ) { + node.debug("Ignore dragleave (multi)"); //, event.currentTarget); + break; + } + $(node.span).removeClass(classDropOver + " " + classDropAccept + " " + classDropReject); + node.scheduleAction("cancel"); + dndOpts.dragLeave(node, data); + $dropMarker.hide(); + break; + + case "drop": + // Data is only readable in the (dragenter and) drop event: + + if( $.inArray(nodeMimeType, dataTransfer.types) >= 0 ) { + nodeData = dataTransfer.getData(nodeMimeType); + tree.info(event.type + ": getData('application/x-fancytree-node'): '" + nodeData + "'"); + } + if( !nodeData ) { + // 1. Source is not a Fancytree node, or + // 2. If the FT mime type was set, but returns '', this + // is probably IE 11 (which only supports 'text') + nodeData = dataTransfer.getData("text"); + tree.info(event.type + ": getData('text'): '" + nodeData + "'"); + } + if( nodeData ) { + try { + // 'text' type may contain JSON if IE is involved + // and setTextTypeJson option was set + json = JSON.parse(nodeData); + if( json.title !== undefined ) { + data.otherNodeData = json; + } + } catch(ex) { + // assume 'text' type contains plain text, so `otherNodeData` + // should not be set + } + } + tree.debug(event.type + ": nodeData: '" + nodeData + "', otherNodeData: ", data.otherNodeData); + + $(node.span).removeClass(classDropOver + " " + classDropAccept + " " + classDropReject); + $dropMarker.hide(); + + data.hitMode = LAST_HIT_MODE; + data.dropEffect = dataTransfer.dropEffect; + data.isCancelled = data.dropEffect === "none"; + + // Let user implement the actual drop operation + dndOpts.dragDrop(node, data); + + // Prevent browser's default drop handling + event.preventDefault(); + break; + } + // Dnd API madness: we must PREVENT default handling to enable dropping + if( allowDrop ) { + event.preventDefault(); + return false; + } + }); + } + } +}); +// Value returned by `require('jquery.fancytree..')` +return $.ui.fancytree; +})); // End of closure + + +/*! Extension 'jquery.fancytree.edit.js' *//*! + * jquery.fancytree.edit.js + * + * Make node titles editable. + * (Extension module for jquery.fancytree.js: https://github.com/mar10/fancytree/) + * + * Copyright (c) 2008-2017, Martin Wendt (http://wwWendt.de) + * + * Released under the MIT license + * https://github.com/mar10/fancytree/wiki/LicenseInfo + * + * @version 2.26.0 + * @date 2017-11-04T17:52:53Z + */ + +;(function( factory ) { + if ( typeof define === "function" && define.amd ) { + // AMD. Register as an anonymous module. + define( [ "jquery", "./jquery.fancytree" ], factory ); + } else if ( typeof module === "object" && module.exports ) { + // Node/CommonJS + require("jquery.fancytree"); + module.exports = factory(require("jquery")); + } else { + // Browser globals + factory( jQuery ); + } + +}( function( $ ) { + +"use strict"; + + +/******************************************************************************* + * Private functions and variables + */ + +var isMac = /Mac/.test(navigator.platform), + escapeHtml = $.ui.fancytree.escapeHtml, + unescapeHtml = $.ui.fancytree.unescapeHtml; + +/** + * [ext-edit] Start inline editing of current node title. + * + * @alias FancytreeNode#editStart + * @requires Fancytree + */ +$.ui.fancytree._FancytreeNodeClass.prototype.editStart = function(){ + var $input, + node = this, + tree = this.tree, + local = tree.ext.edit, + instOpts = tree.options.edit, + $title = $(".fancytree-title", node.span), + eventData = { + node: node, + tree: tree, + options: tree.options, + isNew: $(node[tree.statusClassPropName]).hasClass("fancytree-edit-new"), + orgTitle: node.title, + input: null, + dirty: false + }; + + // beforeEdit may want to modify the title before editing + if( instOpts.beforeEdit.call(node, {type: "beforeEdit"}, eventData) === false ) { + return false; + } + $.ui.fancytree.assert(!local.currentNode, "recursive edit"); + local.currentNode = this; + local.eventData = eventData; + + // Disable standard Fancytree mouse- and key handling + tree.widget._unbind(); + // #116: ext-dnd prevents the blur event, so we have to catch outer clicks + $(document).on("mousedown.fancytree-edit", function(event){ + if( ! $(event.target).hasClass("fancytree-edit-input") ){ + node.editEnd(true, event); + } + }); + + // Replace node with + $input = $("", { + "class": "fancytree-edit-input", + type: "text", + value: tree.options.escapeTitles ? eventData.orgTitle : unescapeHtml(eventData.orgTitle) + }); + local.eventData.input = $input; + if ( instOpts.adjustWidthOfs != null ) { + $input.width($title.width() + instOpts.adjustWidthOfs); + } + if ( instOpts.inputCss != null ) { + $input.css(instOpts.inputCss); + } + + $title.html($input); + + // Focus and bind keyboard handler + $input + .focus() + .change(function(event){ + $input.addClass("fancytree-edit-dirty"); + }).keydown(function(event){ + switch( event.which ) { + case $.ui.keyCode.ESCAPE: + node.editEnd(false, event); + break; + case $.ui.keyCode.ENTER: + node.editEnd(true, event); + return false; // so we don't start editmode on Mac + } + event.stopPropagation(); + }).blur(function(event){ + return node.editEnd(true, event); + }); + + instOpts.edit.call(node, {type: "edit"}, eventData); +}; + + +/** + * [ext-edit] Stop inline editing. + * @param {Boolean} [applyChanges=false] false: cancel edit, true: save (if modified) + * @alias FancytreeNode#editEnd + * @requires jquery.fancytree.edit.js + */ +$.ui.fancytree._FancytreeNodeClass.prototype.editEnd = function(applyChanges, _event){ + var newVal, + node = this, + tree = this.tree, + local = tree.ext.edit, + eventData = local.eventData, + instOpts = tree.options.edit, + $title = $(".fancytree-title", node.span), + $input = $title.find("input.fancytree-edit-input"); + + if( instOpts.trim ) { + $input.val($.trim($input.val())); + } + newVal = $input.val(); + + eventData.dirty = ( newVal !== node.title ); + eventData.originalEvent = _event; + + // Find out, if saving is required + if( applyChanges === false ) { + // If true/false was passed, honor this (except in rename mode, if unchanged) + eventData.save = false; + } else if( eventData.isNew ) { + // In create mode, we save everyting, except for empty text + eventData.save = (newVal !== ""); + } else { + // In rename mode, we save everyting, except for empty or unchanged text + eventData.save = eventData.dirty && (newVal !== ""); + } + // Allow to break (keep editor open), modify input, or re-define data.save + if( instOpts.beforeClose.call(node, {type: "beforeClose"}, eventData) === false){ + return false; + } + if( eventData.save && instOpts.save.call(node, {type: "save"}, eventData) === false){ + return false; + } + $input + .removeClass("fancytree-edit-dirty") + .off(); + // Unbind outer-click handler + $(document).off(".fancytree-edit"); + + if( eventData.save ) { + // # 171: escape user input (not required if global escaping is on) + node.setTitle( tree.options.escapeTitles ? newVal : escapeHtml(newVal) ); + node.setFocus(); + }else{ + if( eventData.isNew ) { + node.remove(); + node = eventData.node = null; + local.relatedNode.setFocus(); + } else { + node.renderTitle(); + node.setFocus(); + } + } + local.eventData = null; + local.currentNode = null; + local.relatedNode = null; + // Re-enable mouse and keyboard handling + tree.widget._bind(); + // Set keyboard focus, even if setFocus() claims 'nothing to do' + $(tree.$container).focus(); + eventData.input = null; + instOpts.close.call(node, {type: "close"}, eventData); + return true; +}; + + +/** +* [ext-edit] Create a new child or sibling node and start edit mode. +* +* @param {String} [mode='child'] 'before', 'after', or 'child' +* @param {Object} [init] NodeData (or simple title string) +* @alias FancytreeNode#editCreateNode +* @requires jquery.fancytree.edit.js +* @since 2.4 +*/ +$.ui.fancytree._FancytreeNodeClass.prototype.editCreateNode = function(mode, init){ + var newNode, + tree = this.tree, + self = this; + + mode = mode || "child"; + if( init == null ) { + init = { title: "" }; + } else if( typeof init === "string" ) { + init = { title: init }; + } else { + $.ui.fancytree.assert($.isPlainObject(init)); + } + // Make sure node is expanded (and loaded) in 'child' mode + if( mode === "child" && !this.isExpanded() && this.hasChildren() !== false ) { + this.setExpanded().done(function(){ + self.editCreateNode(mode, init); + }); + return; + } + newNode = this.addNode(init, mode); + + // #644: Don't filter new nodes. + newNode.match = true; + $(newNode[tree.statusClassPropName]) + .removeClass("fancytree-hide") + .addClass("fancytree-match"); + + newNode.makeVisible(/*{noAnimation: true}*/).done(function(){ + $(newNode[tree.statusClassPropName]).addClass("fancytree-edit-new"); + self.tree.ext.edit.relatedNode = self; + newNode.editStart(); + }); +}; + + +/** + * [ext-edit] Check if any node in this tree in edit mode. + * + * @returns {FancytreeNode | null} + * @alias Fancytree#isEditing + * @requires jquery.fancytree.edit.js + */ +$.ui.fancytree._FancytreeClass.prototype.isEditing = function(){ + return this.ext.edit ? this.ext.edit.currentNode : null; +}; + + +/** + * [ext-edit] Check if this node is in edit mode. + * @returns {Boolean} true if node is currently beeing edited + * @alias FancytreeNode#isEditing + * @requires jquery.fancytree.edit.js + */ +$.ui.fancytree._FancytreeNodeClass.prototype.isEditing = function(){ + return this.tree.ext.edit ? this.tree.ext.edit.currentNode === this : false; +}; + + +/******************************************************************************* + * Extension code + */ +$.ui.fancytree.registerExtension({ + name: "edit", + version: "2.26.0", + // Default options for this extension. + options: { + adjustWidthOfs: 4, // null: don't adjust input size to content + allowEmpty: false, // Prevent empty input + inputCss: {minWidth: "3em"}, + // triggerCancel: ["esc", "tab", "click"], + // triggerStart: ["f2", "dblclick", "shift+click", "mac+enter"], + triggerStart: ["f2", "shift+click", "mac+enter"], + trim: true, // Trim whitespace before save + // Events: + beforeClose: $.noop, // Return false to prevent cancel/save (data.input is available) + beforeEdit: $.noop, // Return false to prevent edit mode + close: $.noop, // Editor was removed + edit: $.noop, // Editor was opened (available as data.input) +// keypress: $.noop, // Not yet implemented + save: $.noop // Save data.input.val() or return false to keep editor open + }, + // Local attributes + currentNode: null, + + treeInit: function(ctx){ + this._superApply(arguments); + this.$container.addClass("fancytree-ext-edit"); + }, + nodeClick: function(ctx) { + if( $.inArray("shift+click", ctx.options.edit.triggerStart) >= 0 ){ + if( ctx.originalEvent.shiftKey ){ + ctx.node.editStart(); + return false; + } + } + return this._superApply(arguments); + }, + nodeDblclick: function(ctx) { + if( $.inArray("dblclick", ctx.options.edit.triggerStart) >= 0 ){ + ctx.node.editStart(); + return false; + } + return this._superApply(arguments); + }, + nodeKeydown: function(ctx) { + switch( ctx.originalEvent.which ) { + case 113: // [F2] + if( $.inArray("f2", ctx.options.edit.triggerStart) >= 0 ){ + ctx.node.editStart(); + return false; + } + break; + case $.ui.keyCode.ENTER: + if( $.inArray("mac+enter", ctx.options.edit.triggerStart) >= 0 && isMac ){ + ctx.node.editStart(); + return false; + } + break; + } + return this._superApply(arguments); + } +}); +// Value returned by `require('jquery.fancytree..')` +return $.ui.fancytree; +})); // End of closure + + +/*! Extension 'jquery.fancytree.filter.js' *//*! + * jquery.fancytree.filter.js + * + * Remove or highlight tree nodes, based on a filter. + * (Extension module for jquery.fancytree.js: https://github.com/mar10/fancytree/) + * + * Copyright (c) 2008-2017, Martin Wendt (http://wwWendt.de) + * + * Released under the MIT license + * https://github.com/mar10/fancytree/wiki/LicenseInfo + * + * @version 2.26.0 + * @date 2017-11-04T17:52:53Z + */ + +;(function( factory ) { + if ( typeof define === "function" && define.amd ) { + // AMD. Register as an anonymous module. + define( [ "jquery", "./jquery.fancytree" ], factory ); + } else if ( typeof module === "object" && module.exports ) { + // Node/CommonJS + require("jquery.fancytree"); + module.exports = factory(require("jquery")); + } else { + // Browser globals + factory( jQuery ); + } + +}( function( $ ) { + +"use strict"; + + +/******************************************************************************* + * Private functions and variables + */ + +var KeyNoData = "__not_found__", + escapeHtml = $.ui.fancytree.escapeHtml; + +function _escapeRegex(str){ + /*jshint regexdash:true */ + return (str + "").replace(/([.?*+\^\$\[\]\\(){}|-])/g, "\\$1"); +} + +function extractHtmlText(s){ + if( s.indexOf(">") >= 0 ) { + return $("").html(s).text(); + } + return s; +} + +$.ui.fancytree._FancytreeClass.prototype._applyFilterImpl = function(filter, branchMode, _opts){ + var match, statusNode, re, reHighlight, temp, + count = 0, + treeOpts = this.options, + escapeTitles = treeOpts.escapeTitles, + prevAutoCollapse = treeOpts.autoCollapse, + opts = $.extend({}, treeOpts.filter, _opts), + hideMode = opts.mode === "hide", + leavesOnly = !!opts.leavesOnly && !branchMode; + + // Default to 'match title substring (not case sensitive)' + if(typeof filter === "string"){ + if( filter === "" ) { + this.warn("Fancytree passing an empty string as a filter is handled as clearFilter()."); + this.clearFilter(); + return; + } + if( opts.fuzzy ) { + // See https://codereview.stackexchange.com/questions/23899/faster-javascript-fuzzy-string-matching-function/23905#23905 + // and http://www.quora.com/How-is-the-fuzzy-search-algorithm-in-Sublime-Text-designed + // and http://www.dustindiaz.com/autocomplete-fuzzy-matching + match = filter.split("").reduce(function(a, b) { + return a + "[^" + b + "]*" + b; + }); + } else { + match = _escapeRegex(filter); // make sure a '.' is treated literally + } + re = new RegExp(".*" + match + ".*", "i"); + reHighlight = new RegExp(_escapeRegex(filter), "gi"); + filter = function(node){ + var text = escapeTitles ? node.title : extractHtmlText(node.title), + res = !!re.test(text); + + if( res && opts.highlight ) { + if( escapeTitles ) { + // #740: we must not apply the marks to escaped entity names, e.g. `"` + // Use some exotic characters to mark matches: + temp = text.replace(reHighlight, function(s){ + return "\uFFF7" + s + "\uFFF8"; + }); + // now we can escape the title... + node.titleWithHighlight = escapeHtml(temp) + // ... and finally insert the desired `` tags + .replace(/\uFFF7/g, "") + .replace(/\uFFF8/g, ""); + } else { + node.titleWithHighlight = text.replace(reHighlight, function(s){ + return "" + s + ""; + }); + } + // node.debug("filter", escapeTitles, text, node.titleWithHighlight); + } + return res; + }; + } + + this.enableFilter = true; + this.lastFilterArgs = arguments; + + this.$div.addClass("fancytree-ext-filter"); + if( hideMode ){ + this.$div.addClass("fancytree-ext-filter-hide"); + } else { + this.$div.addClass("fancytree-ext-filter-dimm"); + } + this.$div.toggleClass("fancytree-ext-filter-hide-expanders", !!opts.hideExpanders); + // Reset current filter + this.visit(function(node){ + delete node.match; + delete node.titleWithHighlight; + node.subMatchCount = 0; + }); + statusNode = this.getRootNode()._findDirectChild(KeyNoData); + if( statusNode ) { + statusNode.remove(); + } + + // Adjust node.hide, .match, and .subMatchCount properties + treeOpts.autoCollapse = false; // #528 + + this.visit(function(node){ + if ( leavesOnly && node.children != null ) { + return; + } + var res = filter(node), + matchedByBranch = false; + + if( res === "skip" ) { + node.visit(function(c){ + c.match = false; + }, true); + return "skip"; + } + if( !res && (branchMode || res === "branch") && node.parent.match ) { + res = true; + matchedByBranch = true; + } + if( res ) { + count++; + node.match = true; + node.visitParents(function(p){ + p.subMatchCount += 1; + // Expand match (unless this is no real match, but only a node in a matched branch) + if( opts.autoExpand && !matchedByBranch && !p.expanded ) { + p.setExpanded(true, {noAnimation: true, noEvents: true, scrollIntoView: false}); + p._filterAutoExpanded = true; + } + }); + } + }); + treeOpts.autoCollapse = prevAutoCollapse; + + if( count === 0 && opts.nodata && hideMode ) { + statusNode = opts.nodata; + if( $.isFunction(statusNode) ) { + statusNode = statusNode(); + } + if( statusNode === true ) { + statusNode = {}; + } else if( typeof statusNode === "string" ) { + statusNode = { title: statusNode }; + } + statusNode = $.extend({ + statusNodeType: "nodata", + key: KeyNoData, + title: this.options.strings.noData + }, statusNode); + + this.getRootNode().addNode(statusNode).match = true; + } + // Redraw whole tree + this.render(); + return count; +}; + +/** + * [ext-filter] Dimm or hide nodes. + * + * @param {function | string} filter + * @param {boolean} [opts={autoExpand: false, leavesOnly: false}] + * @returns {integer} count + * @alias Fancytree#filterNodes + * @requires jquery.fancytree.filter.js + */ +$.ui.fancytree._FancytreeClass.prototype.filterNodes = function(filter, opts) { + if( typeof opts === "boolean" ) { + opts = { leavesOnly: opts }; + this.warn("Fancytree.filterNodes() leavesOnly option is deprecated since 2.9.0 / 2015-04-19. Use opts.leavesOnly instead."); + } + return this._applyFilterImpl(filter, false, opts); +}; + +/** + * @deprecated + */ +$.ui.fancytree._FancytreeClass.prototype.applyFilter = function(filter){ + this.warn("Fancytree.applyFilter() is deprecated since 2.1.0 / 2014-05-29. Use .filterNodes() instead."); + return this.filterNodes.apply(this, arguments); +}; + +/** + * [ext-filter] Dimm or hide whole branches. + * + * @param {function | string} filter + * @param {boolean} [opts={autoExpand: false}] + * @returns {integer} count + * @alias Fancytree#filterBranches + * @requires jquery.fancytree.filter.js + */ +$.ui.fancytree._FancytreeClass.prototype.filterBranches = function(filter, opts){ + return this._applyFilterImpl(filter, true, opts); +}; + + +/** + * [ext-filter] Reset the filter. + * + * @alias Fancytree#clearFilter + * @requires jquery.fancytree.filter.js + */ +$.ui.fancytree._FancytreeClass.prototype.clearFilter = function(){ + var $title, + statusNode = this.getRootNode()._findDirectChild(KeyNoData), + escapeTitles = this.options.escapeTitles, + enhanceTitle = this.options.enhanceTitle; + + if( statusNode ) { + statusNode.remove(); + } + this.visit(function(node){ + if( node.match && node.span ) { // #491, #601 + $title = $(node.span).find(">span.fancytree-title"); + if( escapeTitles ) { + $title.text(node.title); + } else { + $title.html(node.title); + } + if( enhanceTitle ) { + enhanceTitle({type: "enhanceTitle"}, {node: node, $title: $title}); + } + } + delete node.match; + delete node.subMatchCount; + delete node.titleWithHighlight; + if ( node.$subMatchBadge ) { + node.$subMatchBadge.remove(); + delete node.$subMatchBadge; + } + if( node._filterAutoExpanded && node.expanded ) { + node.setExpanded(false, {noAnimation: true, noEvents: true, scrollIntoView: false}); + } + delete node._filterAutoExpanded; + }); + this.enableFilter = false; + this.lastFilterArgs = null; + this.$div.removeClass("fancytree-ext-filter fancytree-ext-filter-dimm fancytree-ext-filter-hide"); + this.render(); +}; + + +/** + * [ext-filter] Return true if a filter is currently applied. + * + * @returns {Boolean} + * @alias Fancytree#isFilterActive + * @requires jquery.fancytree.filter.js + * @since 2.13 + */ +$.ui.fancytree._FancytreeClass.prototype.isFilterActive = function(){ + return !!this.enableFilter; +}; + + +/** + * [ext-filter] Return true if this node is matched by current filter (or no filter is active). + * + * @returns {Boolean} + * @alias FancytreeNode#isMatched + * @requires jquery.fancytree.filter.js + * @since 2.13 + */ +$.ui.fancytree._FancytreeNodeClass.prototype.isMatched = function(){ + return !(this.tree.enableFilter && !this.match); +}; + + +/******************************************************************************* + * Extension code + */ +$.ui.fancytree.registerExtension({ + name: "filter", + version: "2.26.0", + // Default options for this extension. + options: { + autoApply: true, // Re-apply last filter if lazy data is loaded + autoExpand: false, // Expand all branches that contain matches while filtered + counter: true, // Show a badge with number of matching child nodes near parent icons + fuzzy: false, // Match single characters in order, e.g. 'fb' will match 'FooBar' + hideExpandedCounter: true, // Hide counter badge if parent is expanded + hideExpanders: false, // Hide expanders if all child nodes are hidden by filter + highlight: true, // Highlight matches by wrapping inside tags + leavesOnly: false, // Match end nodes only + nodata: true, // Display a 'no data' status node if result is empty + mode: "dimm" // Grayout unmatched nodes (pass "hide" to remove unmatched node instead) + }, + nodeLoadChildren: function(ctx, source) { + return this._superApply(arguments).done(function() { + if( ctx.tree.enableFilter && ctx.tree.lastFilterArgs && ctx.options.filter.autoApply ) { + ctx.tree._applyFilterImpl.apply(ctx.tree, ctx.tree.lastFilterArgs); + } + }); + }, + nodeSetExpanded: function(ctx, flag, callOpts) { + delete ctx.node._filterAutoExpanded; + // Make sure counter badge is displayed again, when node is beeing collapsed + if( !flag && ctx.options.filter.hideExpandedCounter && ctx.node.$subMatchBadge ) { + ctx.node.$subMatchBadge.show(); + } + return this._superApply(arguments); + }, + nodeRenderStatus: function(ctx) { + // Set classes for current status + var res, + node = ctx.node, + tree = ctx.tree, + opts = ctx.options.filter, + $title = $(node.span).find("span.fancytree-title"), + $span = $(node[tree.statusClassPropName]), + enhanceTitle = ctx.options.enhanceTitle, + escapeTitles = ctx.options.escapeTitles; + + res = this._super(ctx); + // nothing to do, if node was not yet rendered + if( !$span.length || !tree.enableFilter ) { + return res; + } + $span + .toggleClass("fancytree-match", !!node.match) + .toggleClass("fancytree-submatch", !!node.subMatchCount) + .toggleClass("fancytree-hide", !(node.match || node.subMatchCount)); + // Add/update counter badge + if( opts.counter && node.subMatchCount && (!node.isExpanded() || !opts.hideExpandedCounter) ) { + if( !node.$subMatchBadge ) { + node.$subMatchBadge = $(""); + $("span.fancytree-icon, span.fancytree-custom-icon", node.span).append(node.$subMatchBadge); + } + node.$subMatchBadge.show().text(node.subMatchCount); + } else if ( node.$subMatchBadge ) { + node.$subMatchBadge.hide(); + } + // node.debug("nodeRenderStatus", node.titleWithHighlight, node.title) + // #601: also chek for $title.length, because we don't need to render + // if node.span is null (i.e. not rendered) + if( node.span && (!node.isEditing || !node.isEditing.call(node)) ) { + if( node.titleWithHighlight ) { + $title.html(node.titleWithHighlight); + } else if ( escapeTitles ) { + $title.text(node.title); + } else { + $title.html(node.title); + } + if( enhanceTitle ) { + enhanceTitle({type: "enhanceTitle"}, {node: node, $title: $title}); + } + } + return res; + } +}); +// Value returned by `require('jquery.fancytree..')` +return $.ui.fancytree; +})); // End of closure + + +/*! Extension 'jquery.fancytree.glyph.js' *//*! + * jquery.fancytree.glyph.js + * + * Use glyph fonts as instead of icon sprites. + * (Extension module for jquery.fancytree.js: https://github.com/mar10/fancytree/) + * + * Copyright (c) 2008-2017, Martin Wendt (http://wwWendt.de) + * + * Released under the MIT license + * https://github.com/mar10/fancytree/wiki/LicenseInfo + * + * @version 2.26.0 + * @date 2017-11-04T17:52:53Z + */ + +;(function( factory ) { + if ( typeof define === "function" && define.amd ) { + // AMD. Register as an anonymous module. + define( [ "jquery", "./jquery.fancytree" ], factory ); + } else if ( typeof module === "object" && module.exports ) { + // Node/CommonJS + require("jquery.fancytree"); + module.exports = factory(require("jquery")); + } else { + // Browser globals + factory( jQuery ); + } + +}( function( $ ) { + +"use strict"; + +/* ***************************************************************************** + * Private functions and variables + */ + +var FT = $.ui.fancytree, + PRESETS = { + "awesome3": { + checkbox: "icon-check-empty", + checkboxSelected: "icon-check", + checkboxUnknown: "icon-check icon-muted", + radio: "icon-circle-blank", + radioSelected: "icon-circle", + radioUnknown: "icon-circle icon-muted", + // radioUnknown: "icon-remove-circle-blank", + dragHelper: "icon-caret-right", + dropMarker: "icon-caret-right", + error: "icon-exclamation-sign", + expanderClosed: "icon-caret-right", + expanderLazy: "icon-angle-right", + expanderOpen: "icon-caret-down", + loading: "icon-refresh icon-spin", + nodata: "icon-meh", + noExpander: "", + // Default node icons. + // (Use tree.options.icon callback to define custom icons based on node data) + doc: "icon-file-alt", + docOpen: "icon-file-alt", + folder: "icon-folder-close-alt", + folderOpen: "icon-folder-open-alt" + }, + "awesome4": { + checkbox: "fa fa-square-o", + checkboxSelected: "fa fa-check-square-o", + // checkboxUnknown: "fa fa-window-close-o", + checkboxUnknown: "fa fa-square", + radio: "fa fa-circle-o", + radioSelected: "fa fa-circle", + radioUnknown: "fa fa-dot-circle-o", + dragHelper: "fa fa-arrow-right", + dropMarker: "fa fa-long-arrow-right", + error: "fa fa-warning", + expanderClosed: "fa fa-caret-right", + expanderLazy: "fa fa-angle-right", + expanderOpen: "fa fa-caret-down", + loading: "fa fa-spinner fa-pulse", + nodata: "fa fa-meh-o", + noExpander: "", + // Default node icons. + // (Use tree.options.icon callback to define custom icons based on node data) + doc: "fa fa-file-o", + docOpen: "fa fa-file-o", + folder: "fa fa-folder-o", + folderOpen: "fa fa-folder-open-o" + }, + "bootstrap3": { + checkbox: "glyphicon glyphicon-unchecked", + checkboxSelected: "glyphicon glyphicon-check", + checkboxUnknown: "glyphicon glyphicon-expand", + radio: "glyphicon glyphicon-remove-circle", + radioSelected: "glyphicon glyphicon-ok-circle", + radioUnknown: "glyphicon glyphicon-ban-circle", + dragHelper: "glyphicon glyphicon-play", + dropMarker: "glyphicon glyphicon-arrow-right", + error: "glyphicon glyphicon-warning-sign", + expanderClosed: "glyphicon glyphicon-menu-right", // glyphicon-plus-sign + expanderLazy: "glyphicon glyphicon-menu-right", // glyphicon-plus-sign + expanderOpen: "glyphicon glyphicon-menu-down", // glyphicon-minus-sign + loading: "glyphicon glyphicon-refresh glyphicon-spin", + nodata: "glyphicon glyphicon-info-sign", + noExpander: "", + // Default node icons. + // (Use tree.options.icon callback to define custom icons based on node data) + doc: "glyphicon glyphicon-file", + docOpen: "glyphicon glyphicon-file", + folder: "glyphicon glyphicon-folder-close", + folderOpen: "glyphicon glyphicon-folder-open" + } + }; + + +function _getIcon(opts, type){ + return opts.map[type]; +} + + +$.ui.fancytree.registerExtension({ + name: "glyph", + version: "2.26.0", + // Default options for this extension. + options: { + preset: null, // 'awesome3', 'awesome4', 'bootstrap3' + map: { + } + }, + + treeInit: function(ctx){ + var tree = ctx.tree, + opts = ctx.options.glyph; + + if( opts.preset ) { + FT.assert( !!PRESETS[opts.preset], + "Invalid value for `options.glyph.preset`: " + opts.preset); + opts.map = $.extend({}, PRESETS[opts.preset], opts.map); + } else { + tree.warn("ext-glyph: missing `preset` option."); + } + this._superApply(arguments); + tree.$container.addClass("fancytree-ext-glyph"); + }, + nodeRenderStatus: function(ctx) { + var checkbox, className, icon, res, span, + node = ctx.node, + $span = $(node.span), + opts = ctx.options.glyph, + map = opts.map; + + res = this._super(ctx); + + if( node.isRoot() ){ + return res; + } + span = $span.children("span.fancytree-expander").get(0); + if( span ){ + // if( node.isLoading() ){ + // icon = "loading"; + if( node.expanded && node.hasChildren() ){ + icon = "expanderOpen"; + }else if( node.isUndefined() ){ + icon = "expanderLazy"; + }else if( node.hasChildren() ){ + icon = "expanderClosed"; + }else{ + icon = "noExpander"; + } + span.className = "fancytree-expander " + map[icon]; + } + + if( node.tr ){ + span = $("td", node.tr).find("span.fancytree-checkbox").get(0); + }else{ + span = $span.children("span.fancytree-checkbox").get(0); + } + if( span ){ + checkbox = FT.evalOption("checkbox", node, node, ctx.options, false); + if( checkbox && !node.isStatusNode() ) { + className = "fancytree-checkbox "; + if( checkbox === "radio" || (node.parent && node.parent.radiogroup) ) { + className += "fancytree-radio "; + icon = node.selected ? "radioSelected" : (node.partsel ? "radioUnknown" : "radio"); + } else { + icon = node.selected ? "checkboxSelected" : (node.partsel ? "checkboxUnknown" : "checkbox"); + } + span.className = className + map[icon]; + } + } + + // Standard icon (note that this does not match .fancytree-custom-icon, + // that might be set by opts.icon callbacks) + span = $span.children("span.fancytree-icon").get(0); + if( span ){ + if( node.statusNodeType ){ + icon = _getIcon(opts, node.statusNodeType); // loading, error + }else if( node.folder ){ + icon = node.expanded && node.hasChildren() ? _getIcon(opts, "folderOpen") : _getIcon(opts, "folder"); + }else{ + icon = node.expanded ? _getIcon(opts, "docOpen") : _getIcon(opts, "doc"); + } + span.className = "fancytree-icon " + icon; + } + return res; + }, + nodeSetStatus: function(ctx, status, message, details) { + var res, span, + opts = ctx.options.glyph, + node = ctx.node; + + res = this._superApply(arguments); + + if( status === "error" || status === "loading" || status === "nodata" ){ + if(node.parent){ + span = $("span.fancytree-expander", node.span).get(0); + if( span ) { + span.className = "fancytree-expander " + _getIcon(opts, status); + } + }else{ // + span = $(".fancytree-statusnode-" + status, node[this.nodeContainerAttrName]) + .find("span.fancytree-icon").get(0); + if( span ) { + span.className = "fancytree-icon " + _getIcon(opts, status); + } + } + } + return res; + } +}); +// Value returned by `require('jquery.fancytree..')` +return $.ui.fancytree; +})); // End of closure + + +/*! Extension 'jquery.fancytree.gridnav.js' *//*! + * jquery.fancytree.gridnav.js + * + * Support keyboard navigation for trees with embedded input controls. + * (Extension module for jquery.fancytree.js: https://github.com/mar10/fancytree/) + * + * Copyright (c) 2008-2017, Martin Wendt (http://wwWendt.de) + * + * Released under the MIT license + * https://github.com/mar10/fancytree/wiki/LicenseInfo + * + * @version 2.26.0 + * @date 2017-11-04T17:52:53Z + */ + +;(function( factory ) { + if ( typeof define === "function" && define.amd ) { + // AMD. Register as an anonymous module. + define([ + "jquery", + "./jquery.fancytree", + "./jquery.fancytree.table" + ], factory ); + } else if ( typeof module === "object" && module.exports ) { + // Node/CommonJS + require("jquery.fancytree.table"); // core + table + module.exports = factory(require("jquery")); + } else { + // Browser globals + factory( jQuery ); + } + +}( function( $ ) { + +"use strict"; + + +/******************************************************************************* + * Private functions and variables + */ + +// Allow these navigation keys even when input controls are focused + +var KC = $.ui.keyCode, + // which keys are *not* handled by embedded control, but passed to tree + // navigation handler: + NAV_KEYS = { + "text": [KC.UP, KC.DOWN], + "checkbox": [KC.UP, KC.DOWN, KC.LEFT, KC.RIGHT], + "link": [KC.UP, KC.DOWN, KC.LEFT, KC.RIGHT], + "radiobutton": [KC.UP, KC.DOWN, KC.LEFT, KC.RIGHT], + "select-one": [KC.LEFT, KC.RIGHT], + "select-multiple": [KC.LEFT, KC.RIGHT] + }; + + +/* Calculate TD column index (considering colspans).*/ +function getColIdx($tr, $td) { + var colspan, + td = $td.get(0), + idx = 0; + + $tr.children().each(function () { + if( this === td ) { + return false; + } + colspan = $(this).prop("colspan"); + idx += colspan ? colspan : 1; + }); + return idx; +} + + +/* Find TD at given column index (considering colspans).*/ +function findTdAtColIdx($tr, colIdx) { + var colspan, + res = null, + idx = 0; + + $tr.children().each(function () { + if( idx >= colIdx ) { + res = $(this); + return false; + } + colspan = $(this).prop("colspan"); + idx += colspan ? colspan : 1; + }); + return res; +} + + +/* Find adjacent cell for a given direction. Skip empty cells and consider merged cells */ +function findNeighbourTd($target, keyCode){ + var $tr, colIdx, + $td = $target.closest("td"), + $tdNext = null; + + switch( keyCode ){ + case KC.LEFT: + $tdNext = $td.prev(); + break; + case KC.RIGHT: + $tdNext = $td.next(); + break; + case KC.UP: + case KC.DOWN: + $tr = $td.parent(); + colIdx = getColIdx($tr, $td); + while( true ) { + $tr = (keyCode === KC.UP) ? $tr.prev() : $tr.next(); + if( !$tr.length ) { + break; + } + // Skip hidden rows + if( $tr.is(":hidden") ) { + continue; + } + // Find adjacent cell in the same column + $tdNext = findTdAtColIdx($tr, colIdx); + // Skip cells that don't conatain a focusable element + if( $tdNext && $tdNext.find(":input,a").length ) { + break; + } + } + break; + } + return $tdNext; +} + + +/******************************************************************************* + * Extension code + */ +$.ui.fancytree.registerExtension({ + name: "gridnav", + version: "2.26.0", + // Default options for this extension. + options: { + autofocusInput: false, // Focus first embedded input if node gets activated + handleCursorKeys: true // Allow UP/DOWN in inputs to move to prev/next node + }, + + treeInit: function(ctx){ + // gridnav requires the table extension to be loaded before itself + this._requireExtension("table", true, true); + this._superApply(arguments); + + this.$container.addClass("fancytree-ext-gridnav"); + + // Activate node if embedded input gets focus (due to a click) + this.$container.on("focusin", function(event){ + var ctx2, + node = $.ui.fancytree.getNode(event.target); + + if( node && !node.isActive() ){ + // Call node.setActive(), but also pass the event + ctx2 = ctx.tree._makeHookContext(node, event); + ctx.tree._callHook("nodeSetActive", ctx2, true); + } + }); + }, + nodeSetActive: function(ctx, flag, callOpts) { + var $outer, + opts = ctx.options.gridnav, + node = ctx.node, + event = ctx.originalEvent || {}, + triggeredByInput = $(event.target).is(":input"); + + flag = (flag !== false); + + this._superApply(arguments); + + if( flag ){ + if( ctx.options.titlesTabbable ){ + if( !triggeredByInput ) { + $(node.span).find("span.fancytree-title").focus(); + node.setFocus(); + } + // If one node is tabbable, the container no longer needs to be + ctx.tree.$container.attr("tabindex", "-1"); + // ctx.tree.$container.removeAttr("tabindex"); + } else if( opts.autofocusInput && !triggeredByInput ){ + // Set focus to input sub input (if node was clicked, but not + // when TAB was pressed ) + $outer = $(node.tr || node.span); + $outer.find(":input:enabled:first").focus(); + } + } + }, + nodeKeydown: function(ctx) { + var inputType, handleKeys, $td, + opts = ctx.options.gridnav, + event = ctx.originalEvent, + $target = $(event.target); + + if( $target.is(":input:enabled") ) { + inputType = $target.prop("type"); + } else if( $target.is("a") ) { + inputType = "link"; + } + // ctx.tree.debug("ext-gridnav nodeKeydown", event, inputType); + + if( inputType && opts.handleCursorKeys ){ + handleKeys = NAV_KEYS[inputType]; + if( handleKeys && $.inArray(event.which, handleKeys) >= 0 ){ + $td = findNeighbourTd($target, event.which); + if( $td && $td.length ) { + // ctx.node.debug("ignore keydown in input", event.which, handleKeys); + $td.find(":input:enabled,a").focus(); + // Prevent Fancytree default navigation + return false; + } + } + return true; + } + // ctx.tree.debug("ext-gridnav NOT HANDLED", event, inputType); + return this._superApply(arguments); + } +}); +// Value returned by `require('jquery.fancytree..')` +return $.ui.fancytree; +})); // End of closure + + +/*! Extension 'jquery.fancytree.persist.js' *//*! + * jquery.fancytree.persist.js + * + * Persist tree status in cookiesRemove or highlight tree nodes, based on a filter. + * (Extension module for jquery.fancytree.js: https://github.com/mar10/fancytree/) + * + * @depends: js-cookie or jquery-cookie + * + * Copyright (c) 2008-2017, Martin Wendt (http://wwWendt.de) + * + * Released under the MIT license + * https://github.com/mar10/fancytree/wiki/LicenseInfo + * + * @version 2.26.0 + * @date 2017-11-04T17:52:53Z + */ + +;(function( factory ) { + if ( typeof define === "function" && define.amd ) { + // AMD. Register as an anonymous module. + define( [ "jquery", "./jquery.fancytree" ], factory ); + } else if ( typeof module === "object" && module.exports ) { + // Node/CommonJS + require("jquery.fancytree"); + module.exports = factory(require("jquery")); + } else { + // Browser globals + factory( jQuery ); + } + +}( function( $ ) { + +"use strict"; +/* global Cookies:false */ + +/******************************************************************************* + * Private functions and variables + */ +var cookieGetter, cookieRemover, cookieSetter, + _assert = $.ui.fancytree.assert, + ACTIVE = "active", + EXPANDED = "expanded", + FOCUS = "focus", + SELECTED = "selected"; + +if( typeof Cookies === "function" ) { + // Assume https://github.com/js-cookie/js-cookie + cookieSetter = Cookies.set; + cookieGetter = Cookies.get; + cookieRemover = Cookies.remove; +} else { + // Fall back to https://github.com/carhartl/jquery-cookie + cookieSetter = cookieGetter = $.cookie; + cookieRemover = $.removeCookie; +} + +/* Recursively load lazy nodes + * @param {string} mode 'load', 'expand', false + */ +function _loadLazyNodes(tree, local, keyList, mode, dfd) { + var i, key, l, node, + foundOne = false, + expandOpts = tree.options.persist.expandOpts, + deferredList = [], + missingKeyList = []; + + keyList = keyList || []; + dfd = dfd || $.Deferred(); + + for( i=0, l=keyList.length; i-' by default + cookie: { + raw: false, + expires: "", + path: "", + domain: "", + secure: false + }, + expandLazy: false, // true: recursively expand and load lazy nodes + expandOpts: undefined, // optional `opts` argument passed to setExpanded() + fireActivate: true, // false: suppress `activate` event after active node was restored + overrideSource: true, // true: cookie takes precedence over `source` data attributes. + store: "auto", // 'cookie': force cookie, 'local': force localStore, 'session': force sessionStore + types: "active expanded focus selected" + }, + + /* Generic read/write string data to cookie, sessionStorage or localStorage. */ + _data: function(key, value){ + var ls = this._local.localStorage; // null, sessionStorage, or localStorage + + if( value === undefined ) { + return ls ? ls.getItem(key) : cookieGetter(key); + } else if ( value === null ) { + if( ls ) { + ls.removeItem(key); + } else { + cookieRemover(key); + } + } else { + if( ls ) { + ls.setItem(key, value); + } else { + cookieSetter(key, value, this.options.persist.cookie); + } + } + }, + + /* Append `key` to a cookie. */ + _appendKey: function(type, key, flag){ + key = "" + key; // #90 + var local = this._local, + instOpts = this.options.persist, + delim = instOpts.cookieDelimiter, + cookieName = local.cookiePrefix + type, + data = local._data(cookieName), + keyList = data ? data.split(delim) : [], + idx = $.inArray(key, keyList); + // Remove, even if we add a key, so the key is always the last entry + if(idx >= 0){ + keyList.splice(idx, 1); + } + // Append key to cookie + if(flag){ + keyList.push(key); + } + local._data(cookieName, keyList.join(delim)); + }, + + treeInit: function(ctx){ + var tree = ctx.tree, + opts = ctx.options, + local = this._local, + instOpts = this.options.persist; + + // For 'auto' or 'cookie' mode, the cookie plugin must be available + _assert((instOpts.store !== "auto" && instOpts.store !== "cookie") || cookieGetter, + "Missing required plugin for 'persist' extension: js.cookie.js or jquery.cookie.js"); + + local.cookiePrefix = instOpts.cookiePrefix || ("fancytree-" + tree._id + "-"); + local.storeActive = instOpts.types.indexOf(ACTIVE) >= 0; + local.storeExpanded = instOpts.types.indexOf(EXPANDED) >= 0; + local.storeSelected = instOpts.types.indexOf(SELECTED) >= 0; + local.storeFocus = instOpts.types.indexOf(FOCUS) >= 0; + if( instOpts.store === "cookie" || !window.localStorage ) { + local.localStorage = null; + } else { + local.localStorage = (instOpts.store === "local") ? window.localStorage : window.sessionStorage; + } + + // Bind init-handler to apply cookie state + tree.$div.on("fancytreeinit", function(event){ + if ( tree._triggerTreeEvent("beforeRestore", null, {}) === false ) { + return; + } + + var cookie, dfd, i, keyList, node, + prevFocus = local._data(local.cookiePrefix + FOCUS), // record this before node.setActive() overrides it; + noEvents = instOpts.fireActivate === false; + + // tree.debug("document.cookie:", document.cookie); + + cookie = local._data(local.cookiePrefix + EXPANDED); + keyList = cookie && cookie.split(instOpts.cookieDelimiter); + + if( local.storeExpanded ) { + // Recursively load nested lazy nodes if expandLazy is 'expand' or 'load' + // Also remove expand-cookies for unmatched nodes + dfd = _loadLazyNodes(tree, local, keyList, instOpts.expandLazy ? "expand" : false , null); + } else { + // nothing to do + dfd = new $.Deferred().resolve(); + } + + dfd.done(function(){ + if(local.storeSelected){ + cookie = local._data(local.cookiePrefix + SELECTED); + if(cookie){ + keyList = cookie.split(instOpts.cookieDelimiter); + for(i=0; i tag) + while(prev.children && prev.children.length){ + last = prev.children[prev.children.length - 1]; + if(!last.tr){ + break; + } + prev = last; + } + }else{ + // if there is no preceding sibling, use the direct parent + prev = parent; + } + return prev; +} + +/* Render callback for 'wide' mode. */ +// function _renderStatusNodeWide(event, data) { +// var node = data.node, +// nodeColumnIdx = data.options.table.nodeColumnIdx, +// $tdList = $(node.tr).find(">td"); + +// $tdList.eq(nodeColumnIdx).attr("colspan", data.tree.columnCount); +// $tdList.not(":eq(" + nodeColumnIdx + ")").remove(); +// } + + +$.ui.fancytree.registerExtension({ + name: "table", + version: "2.26.0", + // Default options for this extension. + options: { + checkboxColumnIdx: null, // render the checkboxes into the this column index (default: nodeColumnIdx) + // customStatus: false, // true: generate renderColumns events for status nodes + indentation: 16, // indent every node level by 16px + nodeColumnIdx: 0 // render node expander, icon, and title to this column (default: #0) + }, + // Overide virtual methods for this extension. + // `this` : is this extension object + // `this._super`: the virtual function that was overriden (member of prev. extension or Fancytree) + treeInit: function(ctx){ + var i, columnCount, n, $row, $tbody, + tree = ctx.tree, + opts = ctx.options, + tableOpts = opts.table, + $table = tree.widget.element; + + if( tableOpts.customStatus != null ) { + if( opts.renderStatusColumns != null) { + $.error("The 'customStatus' option is deprecated since v2.15.0. Use 'renderStatusColumns' only instead."); + } else { + tree.warn("The 'customStatus' option is deprecated since v2.15.0. Use 'renderStatusColumns' instead."); + opts.renderStatusColumns = tableOpts.customStatus; + } + } + if( opts.renderStatusColumns ) { + if( opts.renderStatusColumns === true ) { + opts.renderStatusColumns = opts.renderColumns; + // } else if( opts.renderStatusColumns === "wide" ) { + // opts.renderStatusColumns = _renderStatusNodeWide; + } + } + + $table.addClass("fancytree-container fancytree-ext-table"); + tree.tbody = $table.find(">tbody")[0]; + $tbody = $(tree.tbody); + + // Prepare row templates: + // Determine column count from table header if any + columnCount = $("thead >tr:last >th", $table).length; + // Read TR templates from tbody if any + $row = $tbody.children("tr:first"); + if( $row.length ) { + n = $row.children("td").length; + if( columnCount && n !== columnCount ) { + tree.warn("Column count mismatch between thead (" + columnCount + ") and tbody (" + n + "): using tbody."); + columnCount = n; + } + $row = $row.clone(); + } else { + // Only thead is defined: create default row markup + _assert(columnCount >= 1, "Need either or withelements to determine column count."); + $row = $(" "); + for(i=0; i elements + tree.statusClassPropName = "tr"; + tree.ariaPropName = "tr"; + this.nodeContainerAttrName = "tr"; + + // #489: make sure $container is set to , even if ext-dnd is listed before ext-table + tree.$container = $table; + + this._superApply(arguments); + + // standard Fancytree created a root UL + $(tree.rootNode.ul).remove(); + tree.rootNode.ul = null; + + // Add container to the TAB chain + // #577: Allow to set tabindex to "0", "-1" and "" + this.$container.attr("tabindex", opts.tabindex); + // this.$container.attr("tabindex", opts.tabbable ? "0" : "-1"); + if(opts.aria) { + tree.$container + .attr("role", "treegrid") + .attr("aria-readonly", true); + } + }, + nodeRemoveChildMarkup: function(ctx) { + var node = ctx.node; +// node.debug("nodeRemoveChildMarkup()"); + node.visit(function(n){ + if(n.tr){ + $(n.tr).remove(); + n.tr = null; + } + }); + }, + nodeRemoveMarkup: function(ctx) { + var node = ctx.node; +// node.debug("nodeRemoveMarkup()"); + if(node.tr){ + $(node.tr).remove(); + node.tr = null; + } + this.nodeRemoveChildMarkup(ctx); + }, + /* Override standard render. */ + nodeRender: function(ctx, force, deep, collapsed, _recursive) { + var children, firstTr, i, l, newRow, prevNode, prevTr, subCtx, + tree = ctx.tree, + node = ctx.node, + opts = ctx.options, + isRootNode = !node.parent; + + if( tree._enableUpdate === false ) { + // $.ui.fancytree.debug("*** nodeRender _enableUpdate: false"); + return; + } + if( !_recursive ){ + ctx.hasCollapsedParents = node.parent && !node.parent.expanded; + } + // $.ui.fancytree.debug("*** nodeRender " + node + ", isRoot=" + isRootNode, "tr=" + node.tr, "hcp=" + ctx.hasCollapsedParents, "parent.tr=" + (node.parent && node.parent.tr)); + if( !isRootNode ){ + if( node.tr && force ) { + this.nodeRemoveMarkup(ctx); + } + if( !node.tr ) { + if( ctx.hasCollapsedParents && !deep ) { + // #166: we assume that the parent will be (recursively) rendered + // later anyway. + // node.debug("nodeRender ignored due to unrendered parent"); + return; + } + // Create new
after previous row + // if( node.isStatusNode() ) { + // newRow = tree.statusRowFragment.firstChild.cloneNode(true); + // } else { + newRow = tree.rowFragment.firstChild.cloneNode(true); + // } + prevNode = findPrevRowNode(node); + // $.ui.fancytree.debug("*** nodeRender " + node + ": prev: " + prevNode.key); + _assert(prevNode); + if(collapsed === true && _recursive){ + // hide all child rows, so we can use an animation to show it later + newRow.style.display = "none"; + }else if(deep && ctx.hasCollapsedParents){ + // also hide this row if deep === true but any parent is collapsed + newRow.style.display = "none"; +// newRow.style.color = "red"; + } + if(!prevNode.tr){ + _assert(!prevNode.parent, "prev. row must have a tr, or be system root"); + // tree.tbody.appendChild(newRow); + insertFirstChild(tree.tbody, newRow); // #675 + }else{ + insertSiblingAfter(prevNode.tr, newRow); + } + node.tr = newRow; + if( node.key && opts.generateIds ){ + node.tr.id = opts.idPrefix + node.key; + } + node.tr.ftnode = node; + // if(opts.aria){ + // $(node.tr).attr("aria-labelledby", "ftal_" + opts.idPrefix + node.key); + // } + node.span = $("span.fancytree-node", node.tr).get(0); + // Set icon, link, and title (normally this is only required on initial render) + this.nodeRenderTitle(ctx); + // Allow tweaking, binding, after node was created for the first time +// tree._triggerNodeEvent("createNode", ctx); + if ( opts.createNode ){ + opts.createNode.call(tree, {type: "createNode"}, ctx); + } + } else { + if( force ) { + // Set icon, link, and title (normally this is only required on initial render) + this.nodeRenderTitle(ctx); // triggers renderColumns() + } else { + // Update element classes according to node state + this.nodeRenderStatus(ctx); + } + } + } + // Allow tweaking after node state was rendered +// tree._triggerNodeEvent("renderNode", ctx); + if ( opts.renderNode ){ + opts.renderNode.call(tree, {type: "renderNode"}, ctx); + } + // Visit child nodes + // Add child markup + children = node.children; + if(children && (isRootNode || deep || node.expanded)){ + for(i=0, l=children.length; i
+// * May be called explicitly on container resize, since there is no resize event +// * for DIV tags. +// * +// * @alias Fancytree#wideUpdate +// * @requires jquery.fancytree.wide.js +// */ +// $.ui.fancytree._FancytreeClass.prototype.wideUpdate = function(){ +// var inst = this.ext.wide, +// prevCw = inst.contWidth, +// prevLo = inst.lineOfs; + +// inst.contWidth = realInnerWidth(this.$container); +// // Each title is precceeded by 2 or 3 icons (16px + 3 margin) +// // + 1px title border and 3px title padding +// // TODO: use code from treeInit() below +// inst.lineOfs = (this.options.checkbox ? 3 : 2) * 19; +// if( prevCw !== inst.contWidth || prevLo !== inst.lineOfs ) { +// this.debug("wideUpdate: " + inst.contWidth); +// this.visit(function(node){ +// node.tree._callHook("nodeRenderTitle", node); +// }); +// } +// }; + +/******************************************************************************* + * Extension code + */ +$.ui.fancytree.registerExtension({ + name: "wide", + version: "2.26.0", + // Default options for this extension. + options: { + iconWidth: null, // Adjust this if @fancy-icon-width != "16px" + iconSpacing: null, // Adjust this if @fancy-icon-spacing != "3px" + labelSpacing: null, // Adjust this if padding between icon and label != "3px" + levelOfs: null // Adjust this if ul padding != "16px" + }, + + treeCreate: function(ctx){ + this._superApply(arguments); + this.$container.addClass("fancytree-ext-wide"); + + var containerId, cssText, iconSpacingUnit, labelSpacingUnit, iconWidthUnit, levelOfsUnit, + instOpts = ctx.options.wide, + // css sniffing + $dummyLI = $("
- = 0 ){
+ d.title = d.title.substring(0, iPos);
+ }
+ }
+ d.title = $.trim(d.title);
+
+ // Make sure all fields exist
+ for(i=0, l=CLASS_ATTRS.length; i
- tag is specified, use the trimmed string up to + // the next child
- tag is specified, use it literally and extract href/target.
+ d.title = $liA.html();
+ d.data.href = $liA.attr("href");
+ d.data.target = $liA.attr("target");
+ d.tooltip = $liA.attr("title");
+
+ } else {
+ // If only a
+ * If this was a lazy node, it is still considered 'loaded'; call node.resetLazy() + * in order to trigger lazyLoad on next expand. + */ + removeChildren: function() { + return this.tree._callHook("nodeRemoveChildren", this); + }, + /** + * Remove class from node's span tag and .extraClasses. + * + * @param {string} className class name + * + * @since 2.17 + */ + removeClass: function(className){ + return this.toggleClass(className, false); + }, + /** + * This method renders and updates all HTML markup that is required + * to display this node in its current state.
+ * Note: + *
-
+ *
+ * Stop iteration, if fn() returns false. Skip current branch, if fn() returns "skip".
+ * Return false if iteration was stopped. + * + * @param {function} fn the callback function. + * Return false to stop iteration, return "skip" to skip this node and + * its children only. + * @param {boolean} [includeSelf=false] + * @returns {boolean} + */ + visit: function(fn, includeSelf) { + var i, l, + res = true, + children = this.children; + + if( includeSelf === true ) { + res = fn(this); + if( res === false || res === "skip" ){ + return res; + } + } + if(children){ + for(i=0, l=children.length; i
+ * Return false if iteration was stopped. + * + * @param {function} fn the callback function. + * Return false to stop iteration, return "skip" to skip this node and children only. + * @param {boolean} [includeSelf=false] + * @returns {boolean} + */ + visitParents: function(fn, includeSelf) { + // Visit parent nodes (bottom up) + if(includeSelf && fn(this) === false){ + return false; + } + var p = this.parent; + while( p ) { + if(fn(p) === false){ + return false; + } + p = p.parent; + } + return true; + }, + /** Call fn(node) for all sibling nodes.
+ * Stop iteration, if fn() returns false.
+ * Return false if iteration was stopped. + * + * @param {function} fn the callback function. + * Return false to stop iteration. + * @param {boolean} [includeSelf=false] + * @returns {boolean} + */ + visitSiblings: function(fn, includeSelf) { + var i, l, n, + ac = this.parent.children; + + for (i=0, l=ac.length; i
+ this.data = _getElementDataAsDict(this.$div);
+ // TODO: use widget.uuid instead?
+ this._id = $.ui.fancytree._nextId++;
+ // TODO: use widget.eventNamespace instead?
+ this._ns = ".fancytree-" + this._id; // append for namespaced events
+ this.activeNode = null;
+ this.focusNode = null;
+ this._hasFocus = null;
+ this._tempCache = {};
+ this._lastMousedownNode = null;
+ this._enableUpdate = true;
+ // this._dirtyRoots = null;
+ this.lastSelectedNode = null;
+ this.systemFocusElement = null;
+ this.lastQuicksearchTerm = "";
+ this.lastQuicksearchTime = 0;
+
+ this.statusClassPropName = "span";
+ this.ariaPropName = "li";
+ this.nodeContainerAttrName = "li";
+
+ // Remove previous markup if any
+ this.$div.find(">ul.fancytree-container").remove();
+
+ // Create a node without parent.
+ var fakeParent = { tree: this },
+ $ul;
+ this.rootNode = new FancytreeNode(fakeParent, {
+ title: "root",
+ key: "root_" + this._id,
+ children: null,
+ expanded: true
+ });
+ this.rootNode.parent = null;
+
+ // Create root markup
+ $ul = $("
- ", {
+ "class": "ui-fancytree fancytree-container fancytree-plain"
+ }).appendTo(this.$div);
+ this.$container = $ul;
+ this.rootNode.ul = $ul[0];
+
+ if(this.options.debugLevel == null){
+ this.options.debugLevel = FT.debugLevel;
+ }
+ // // Add container to the TAB chain
+ // // See http://www.w3.org/TR/wai-aria-practices/#focus_activedescendant
+ // // #577: Allow to set tabindex to "0", "-1" and ""
+ // this.$container.attr("tabindex", this.options.tabindex);
+
+ // if( this.options.rtl ) {
+ // this.$container.attr("DIR", "RTL").addClass("fancytree-rtl");
+ // // }else{
+ // // this.$container.attr("DIR", null).removeClass("fancytree-rtl");
+ // }
+ // if(this.options.aria){
+ // this.$container.attr("role", "tree");
+ // if( this.options.selectMode !== 1 ) {
+ // this.$container.attr("aria-multiselectable", true);
+ // }
+ // }
+}
+
+
+Fancytree.prototype = /** @lends Fancytree# */{
+ /* Return a context object that can be re-used for _callHook().
+ * @param {Fancytree | FancytreeNode | EventData} obj
+ * @param {Event} originalEvent
+ * @param {Object} extra
+ * @returns {EventData}
+ */
+ _makeHookContext: function(obj, originalEvent, extra) {
+ var ctx, tree;
+ if(obj.node !== undefined){
+ // obj is already a context object
+ if(originalEvent && obj.originalEvent !== originalEvent){
+ $.error("invalid args");
+ }
+ ctx = obj;
+ }else if(obj.tree){
+ // obj is a FancytreeNode
+ tree = obj.tree;
+ ctx = { node: obj, tree: tree, widget: tree.widget, options: tree.widget.options, originalEvent: originalEvent };
+ }else if(obj.widget){
+ // obj is a Fancytree
+ ctx = { node: null, tree: obj, widget: obj.widget, options: obj.widget.options, originalEvent: originalEvent };
+ }else{
+ $.error("invalid args");
+ }
+ if(extra){
+ $.extend(ctx, extra);
+ }
+ return ctx;
+ },
+ /* Trigger a hook function: funcName(ctx, [...]).
+ *
+ * @param {string} funcName
+ * @param {Fancytree|FancytreeNode|EventData} contextObject
+ * @param {any} [_extraArgs] optional additional arguments
+ * @returns {any}
+ */
+ _callHook: function(funcName, contextObject, _extraArgs) {
+ var ctx = this._makeHookContext(contextObject),
+ fn = this[funcName],
+ args = Array.prototype.slice.call(arguments, 2);
+ if(!$.isFunction(fn)){
+ $.error("_callHook('" + funcName + "') is not a function");
+ }
+ args.unshift(ctx);
+// this.debug("_hook", funcName, ctx.node && ctx.node.toString() || ctx.tree.toString(), args);
+ return fn.apply(this, args);
+ },
+ _setExpiringValue: function(key, value, ms){
+ this._tempCache[key] = {value: value, expire: Date.now() + (+ms || 50)};
+ },
+ _getExpiringValue: function(key){
+ var entry = this._tempCache[key];
+ if( entry && entry.expire < Date.now() ) {
+ return entry.value;
+ }
+ delete this._tempCache[key];
+ return null;
+ },
+ /* Check if current extensions dependencies are met and throw an error if not.
+ *
+ * This method may be called inside the `treeInit` hook for custom extensions.
+ *
+ * @param {string} extension name of the required extension
+ * @param {boolean} [required=true] pass `false` if the extension is optional, but we want to check for order if it is present
+ * @param {boolean} [before] `true` if `name` must be included before this, `false` otherwise (use `null` if order doesn't matter)
+ * @param {string} [message] optional error message (defaults to a descriptve error message)
+ */
+ _requireExtension: function(name, required, before, message) {
+ before = !!before;
+ var thisName = this._local.name,
+ extList = this.options.extensions,
+ isBefore = $.inArray(name, extList) < $.inArray(thisName, extList),
+ isMissing = required && this.ext[name] == null,
+ badOrder = !isMissing && before != null && (before !== isBefore);
+
+ _assert(thisName && thisName !== name, "invalid or same name");
+
+ if( isMissing || badOrder ){
+ if( !message ){
+ if( isMissing || required ){
+ message = "'" + thisName + "' extension requires '" + name + "'";
+ if( badOrder ){
+ message += " to be registered " + (before ? "before" : "after") + " itself";
+ }
+ }else{
+ message = "If used together, `" + name + "` must be registered " + (before ? "before" : "after") + " `" + thisName + "`";
+ }
+ }
+ $.error(message);
+ return false;
+ }
+ return true;
+ },
+ /** Activate node with a given key and fire focus and activate events.
+ *
+ * A previously activated node will be deactivated.
+ * If activeVisible option is set, all parents will be expanded as necessary.
+ * Pass key = false, to deactivate the current node only.
+ * @param {string} key
+ * @returns {FancytreeNode} activated node (null, if not found)
+ */
+ activateKey: function(key) {
+ var node = this.getNodeByKey(key);
+ if(node){
+ node.setActive();
+ }else if(this.activeNode){
+ this.activeNode.setActive(false);
+ }
+ return node;
+ },
+ /** (experimental) Add child status nodes that indicate 'More...', ....
+ * @param {boolean|object} node optional node definition. Pass `false` to remove all paging nodes.
+ * @param {string} [mode='append'] 'child'|firstChild'
+ * @since 2.15
+ */
+ addPagingNode: function(node, mode){
+ return this.rootNode.addPagingNode(node, mode);
+ },
+ /** (experimental) Modify existing data model.
+ *
+ * @param {Array} patchList array of [key, NodePatch] arrays
+ * @returns {$.Promise} resolved, when all patches have been applied
+ * @see TreePatch
+ */
+ applyPatch: function(patchList) {
+ var dfd, i, p2, key, patch, node,
+ patchCount = patchList.length,
+ deferredList = [];
+
+ for(i=0; i
", {
+ id: id
+ }).hide().insertAfter(this.$container);
+ }
+ if(active !== false && this.activeNode){
+ $result.append($("", {
+ type: "radio",
+ name: activeName,
+ value: this.activeNode.key,
+ checked: true
+ }));
+ }
+ function _appender( node ) {
+ $result.append($("", {
+ type: "checkbox",
+ name: selectedName,
+ value: node.key,
+ checked: true
+ }));
+ }
+ if ( opts.filter ) {
+ this.visit(function(node) {
+ var res = opts.filter(node);
+ if( res === "skip" ) { return res; }
+ if ( res !== false ) {
+ _appender(node);
+ }
+ });
+ } else if ( selected !== false ) {
+ nodeList = this.getSelectedNodes(stopOnParents);
+ $.each(nodeList, function(idx, node) {
+ _appender(node);
+ });
+ }
+ },
+ /**
+ * Return the currently active node or null.
+ * @returns {FancytreeNode}
+ */
+ getActiveNode: function() {
+ return this.activeNode;
+ },
+ /** Return the first top level node if any (not the invisible root node).
+ * @returns {FancytreeNode | null}
+ */
+ getFirstChild: function() {
+ return this.rootNode.getFirstChild();
+ },
+ /**
+ * Return node that has keyboard focus or null.
+ * @returns {FancytreeNode}
+ */
+ getFocusNode: function() {
+ return this.focusNode;
+ },
+ /**
+ * Return node with a given key or null if not found.
+ * @param {string} key
+ * @param {FancytreeNode} [searchRoot] only search below this node
+ * @returns {FancytreeNode | null}
+ */
+ getNodeByKey: function(key, searchRoot) {
+ // Search the DOM by element ID (assuming this is faster than traversing all nodes).
+ // $("#...") has problems, if the key contains '.', so we use getElementById()
+ var el, match;
+ if(!searchRoot){
+ el = document.getElementById(this.options.idPrefix + key);
+ if( el ){
+ return el.ftnode ? el.ftnode : null;
+ }
+ }
+ // Not found in the DOM, but still may be in an unrendered part of tree
+ // TODO: optimize with specialized loop
+ // TODO: consider keyMap?
+ searchRoot = searchRoot || this.rootNode;
+ match = null;
+ searchRoot.visit(function(node){
+// window.console.log("getNodeByKey(" + key + "): ", node.key);
+ if(node.key === key) {
+ match = node;
+ return false;
+ }
+ }, true);
+ return match;
+ },
+ /** Return the invisible system root node.
+ * @returns {FancytreeNode}
+ */
+ getRootNode: function() {
+ return this.rootNode;
+ },
+ /**
+ * Return an array of selected nodes.
+ * @param {boolean} [stopOnParents=false] only return the topmost selected
+ * node (useful with selectMode 3)
+ * @returns {FancytreeNode[]}
+ */
+ getSelectedNodes: function(stopOnParents) {
+ return this.rootNode.getSelectedNodes(stopOnParents);
+ },
+ /** Return true if the tree control has keyboard focus
+ * @returns {boolean}
+ */
+ hasFocus: function(){
+ return !!this._hasFocus;
+ },
+ /** Write to browser console if debugLevel >= 1 (prepending tree name)
+ * @param {*} msg string or object or array of such
+ */
+ info: function(msg){
+ if( this.options.debugLevel >= 1 ) {
+ Array.prototype.unshift.call(arguments, this.toString());
+ consoleApply("info", arguments);
+ }
+ },
+/*
+ TODO: isInitializing: function() {
+ return ( this.phase=="init" || this.phase=="postInit" );
+ },
+ TODO: isReloading: function() {
+ return ( this.phase=="init" || this.phase=="postInit" ) && this.options.persist && this.persistence.cookiesFound;
+ },
+ TODO: isUserEvent: function() {
+ return ( this.phase=="userEvent" );
+ },
+*/
+
+ /**
+ * Make sure that a node with a given ID is loaded, by traversing - and
+ * loading - its parents. This method is ment for lazy hierarchies.
+ * A callback is executed for every node as we go.
+ * @example
+ * tree.loadKeyPath("/_3/_23/_26/_27", function(node, status){
+ * if(status === "loaded") {
+ * console.log("loaded intermiediate node " + node);
+ * }else if(status === "ok") {
+ * node.activate();
+ * }
+ * });
+ *
+ * @param {string | string[]} keyPathList one or more key paths (e.g. '/3/2_1/7')
+ * @param {function} callback callback(node, status) is called for every visited node ('loading', 'loaded', 'ok', 'error')
+ * @returns {$.Promise}
+ */
+ loadKeyPath: function(keyPathList, callback, _rootNode) {
+ var deferredList, dfd, i, path, key, loadMap, node, root, segList,
+ sep = this.options.keyPathSeparator,
+ self = this;
+
+ callback = callback || $.noop;
+ if(!$.isArray(keyPathList)){
+ keyPathList = [keyPathList];
+ }
+ // Pass 1: handle all path segments for nodes that are already loaded
+ // Collect distinct top-most lazy nodes in a map
+ loadMap = {};
+
+ for(i=0; i";
+ },
+ /* _trigger a widget event with additional node ctx.
+ * @see EventData
+ */
+ _triggerNodeEvent: function(type, node, originalEvent, extra) {
+// this.debug("_trigger(" + type + "): '" + ctx.node.title + "'", ctx);
+ var ctx = this._makeHookContext(node, originalEvent, extra),
+ res = this.widget._trigger(type, originalEvent, ctx);
+ if(res !== false && ctx.result !== undefined){
+ return ctx.result;
+ }
+ return res;
+ },
+ /* _trigger a widget event with additional tree data. */
+ _triggerTreeEvent: function(type, originalEvent, extra) {
+// this.debug("_trigger(" + type + ")", ctx);
+ var ctx = this._makeHookContext(this, originalEvent, extra),
+ res = this.widget._trigger(type, originalEvent, ctx);
+
+ if(res !== false && ctx.result !== undefined){
+ return ctx.result;
+ }
+ return res;
+ },
+ /** Call fn(node) for all nodes.
+ *
+ * @param {function} fn the callback function.
+ * Return false to stop iteration, return "skip" to skip this node and children only.
+ * @returns {boolean} false, if the iterator was stopped.
+ */
+ visit: function(fn) {
+ return this.rootNode.visit(fn, false);
+ },
+ /** Write warning to browser console (prepending tree info)
+ *
+ * @param {*} msg string or object or array of such
+ */
+ warn: function(msg){
+ Array.prototype.unshift.call(arguments, this.toString());
+ consoleApply("warn", arguments);
+ }
+};
+
+/**
+ * These additional methods of the {@link Fancytree} class are 'hook functions'
+ * that can be used and overloaded by extensions.
+ * (See writing extensions.)
+ * @mixin Fancytree_Hooks
+ */
+$.extend(Fancytree.prototype,
+ /** @lends Fancytree_Hooks# */
+ {
+ /** Default handling for mouse click events.
+ *
+ * @param {EventData} ctx
+ */
+ nodeClick: function(ctx) {
+ var activate, expand,
+ // event = ctx.originalEvent,
+ targetType = ctx.targetType,
+ node = ctx.node;
+
+// this.debug("ftnode.onClick(" + event.type + "): ftnode:" + this + ", button:" + event.button + ", which: " + event.which, ctx);
+ // TODO: use switch
+ // TODO: make sure clicks on embedded doesn't steal focus (see table sample)
+ if( targetType === "expander" ) {
+ if( node.isLoading() ) {
+ // #495: we probably got a click event while a lazy load is pending.
+ // The 'expanded' state is not yet set, so 'toggle' would expand
+ // and trigger lazyLoad again.
+ // It would be better to allow to collapse/expand the status node
+ // while loading (instead of ignoring), but that would require some
+ // more work.
+ node.debug("Got 2nd click while loading: ignored");
+ return;
+ }
+ // Clicking the expander icon always expands/collapses
+ this._callHook("nodeToggleExpanded", ctx);
+
+ } else if( targetType === "checkbox" ) {
+ // Clicking the checkbox always (de)selects
+ this._callHook("nodeToggleSelected", ctx);
+ if( ctx.options.focusOnSelect ) { // #358
+ this._callHook("nodeSetFocus", ctx, true);
+ }
+
+ } else {
+ // Honor `clickFolderMode` for
+ expand = false;
+ activate = true;
+ if( node.folder ) {
+ switch( ctx.options.clickFolderMode ) {
+ case 2: // expand only
+ expand = true;
+ activate = false;
+ break;
+ case 3: // expand and activate
+ activate = true;
+ expand = true; //!node.isExpanded();
+ break;
+ // else 1 or 4: just activate
+ }
+ }
+ if( activate ) {
+ this.nodeSetFocus(ctx);
+ this._callHook("nodeSetActive", ctx, true);
+ }
+ if( expand ) {
+ if(!activate){
+// this._callHook("nodeSetFocus", ctx);
+ }
+// this._callHook("nodeSetExpanded", ctx, true);
+ this._callHook("nodeToggleExpanded", ctx);
+ }
+ }
+ // Make sure that clicks stop, otherwise jumps to the top
+ // if(event.target.localName === "a" && event.target.className === "fancytree-title"){
+ // event.preventDefault();
+ // }
+ // TODO: return promise?
+ },
+ /** Collapse all other children of same parent.
+ *
+ * @param {EventData} ctx
+ * @param {object} callOpts
+ */
+ nodeCollapseSiblings: function(ctx, callOpts) {
+ // TODO: return promise?
+ var ac, i, l,
+ node = ctx.node;
+
+ if( node.parent ){
+ ac = node.parent.children;
+ for (i=0, l=ac.length; i 500 ) {
+ tree.lastQuicksearchTerm = "";
+ }
+ tree.lastQuicksearchTime = stamp;
+ tree.lastQuicksearchTerm += whichChar;
+ // tree.debug("quicksearch find", tree.lastQuicksearchTerm);
+ matchNode = tree.findNextNode(tree.lastQuicksearchTerm, tree.getActiveNode());
+ if( matchNode ) {
+ matchNode.setActive();
+ }
+ event.preventDefault();
+ return;
+ }
+ switch( FT.eventToString(event) ) {
+ case "+":
+ case "=": // 187: '+' @ Chrome, Safari
+ tree.nodeSetExpanded(ctx, true);
+ break;
+ case "-":
+ tree.nodeSetExpanded(ctx, false);
+ break;
+ case "space":
+ if( node.isPagingNode() ) {
+ tree._triggerNodeEvent("clickPaging", ctx, event);
+ } else if( FT.evalOption("checkbox", node, node, opts, false) ) { // #768
+ tree.nodeToggleSelected(ctx);
+ }else{
+ tree.nodeSetActive(ctx, true);
+ }
+ break;
+ case "return":
+ tree.nodeSetActive(ctx, true);
+ break;
+ case "home":
+ case "end":
+ case "backspace":
+ case "left":
+ case "right":
+ case "up":
+ case "down":
+ res = node.navigate(event.which, activate, true);
+ break;
+ default:
+ handled = false;
+ }
+ if(handled){
+ event.preventDefault();
+ }
+ },
+
+
+ // /** Default handling for mouse keypress events. */
+ // nodeKeypress: function(ctx) {
+ // var event = ctx.originalEvent;
+ // },
+
+ // /** Trigger lazyLoad event (async). */
+ // nodeLazyLoad: function(ctx) {
+ // var node = ctx.node;
+ // if(this._triggerNodeEvent())
+ // },
+ /** Load child nodes (async).
+ *
+ * @param {EventData} ctx
+ * @param {object[]|object|string|$.Promise|function} source
+ * @returns {$.Promise} The deferred will be resolved as soon as the (ajax)
+ * data was rendered.
+ */
+ nodeLoadChildren: function(ctx, source) {
+ var ajax, delay, dfd,
+ tree = ctx.tree,
+ node = ctx.node,
+ requestId = new Date().getTime();
+
+ if($.isFunction(source)){
+ source = source.call(tree, {type: "source"}, ctx);
+ _assert(!$.isFunction(source), "source callback must not return another function");
+ }
+ if(source.url){
+ if( node._requestId ) {
+ node.warn("Recursive load request #" + requestId + " while #" + node._requestId + " is pending.");
+ // } else {
+ // node.debug("Send load request #" + requestId);
+ }
+ // `source` is an Ajax options object
+ ajax = $.extend({}, ctx.options.ajax, source);
+ node._requestId = requestId;
+ if(ajax.debugDelay){
+ // simulate a slow server
+ delay = ajax.debugDelay;
+ if($.isArray(delay)){ // random delay range [min..max]
+ delay = delay[0] + Math.random() * (delay[1] - delay[0]);
+ }
+ node.warn("nodeLoadChildren waiting debugDelay " + Math.round(delay) + " ms ...");
+ ajax.debugDelay = false;
+ dfd = $.Deferred(function (dfd) {
+ setTimeout(function () {
+ $.ajax(ajax)
+ .done(function () { dfd.resolveWith(this, arguments); })
+ .fail(function () { dfd.rejectWith(this, arguments); });
+ }, delay);
+ });
+ }else{
+ dfd = $.ajax(ajax);
+ }
+
+ // Defer the deferred: we want to be able to reject, even if ajax
+ // resolved ok.
+ source = new $.Deferred();
+ dfd.done(function (data, textStatus, jqXHR) {
+ var errorObj, res;
+
+ if((this.dataType === "json" || this.dataType === "jsonp") && typeof data === "string"){
+ $.error("Ajax request returned a string (did you get the JSON dataType wrong?).");
+ }
+ if( node._requestId && node._requestId > requestId ) {
+ // The expected request time stamp is later than `requestId`
+ // (which was kept as as closure variable to this handler function)
+ // node.warn("Ignored load response for obsolete request #" + requestId + " (expected #" + node._requestId + ")");
+ source.rejectWith(this, [RECURSIVE_REQUEST_ERROR]);
+ return;
+ // } else {
+ // node.debug("Response returned for load request #" + requestId);
+ }
+ // postProcess is similar to the standard ajax dataFilter hook,
+ // but it is also called for JSONP
+ if( ctx.options.postProcess ){
+ try {
+ res = tree._triggerNodeEvent("postProcess", ctx, ctx.originalEvent, {
+ response: data, error: null, dataType: this.dataType
+ });
+ } catch(e) {
+ res = { error: e, message: "" + e, details: "postProcess failed"};
+ }
+ if( res.error ) {
+ errorObj = $.isPlainObject(res.error) ? res.error : {message: res.error};
+ errorObj = tree._makeHookContext(node, null, errorObj);
+ source.rejectWith(this, [errorObj]);
+ return;
+ }
+ data = $.isArray(res) ? res : data;
+
+ } else if (data && data.hasOwnProperty("d") && ctx.options.enableAspx ) {
+ // Process ASPX WebMethod JSON object inside "d" property
+ data = (typeof data.d === "string") ? $.parseJSON(data.d) : data.d;
+ }
+ source.resolveWith(this, [data]);
+ }).fail(function (jqXHR, textStatus, errorThrown) {
+ var errorObj = tree._makeHookContext(node, null, {
+ error: jqXHR,
+ args: Array.prototype.slice.call(arguments),
+ message: errorThrown,
+ details: jqXHR.status + ": " + errorThrown
+ });
+ source.rejectWith(this, [errorObj]);
+ });
+ }
+ // #383: accept and convert ECMAScript 6 Promise
+ if( $.isFunction(source.then) && $.isFunction(source["catch"]) ) {
+ dfd = source;
+ source = new $.Deferred();
+ dfd.then(function(value){
+ source.resolve(value);
+ }, function(reason){
+ source.reject(reason);
+ });
+ }
+ if($.isFunction(source.promise)){
+ // `source` is a deferred, i.e. ajax request
+ // _assert(!node.isLoading(), "recursive load");
+ tree.nodeSetStatus(ctx, "loading");
+
+ source.done(function (children) {
+ tree.nodeSetStatus(ctx, "ok");
+ node._requestId = null;
+ }).fail(function(error){
+ var ctxErr;
+
+ if ( error === RECURSIVE_REQUEST_ERROR ) {
+ node.warn("Ignored response for obsolete load request #" + requestId + " (expected #" + node._requestId + ")");
+ return;
+ } else if (error.node && error.error && error.message) {
+ // error is already a context object
+ ctxErr = error;
+ } else {
+ ctxErr = tree._makeHookContext(node, null, {
+ error: error, // it can be jqXHR or any custom error
+ args: Array.prototype.slice.call(arguments),
+ message: error ? (error.message || error.toString()) : ""
+ });
+ if( ctxErr.message === "[object Object]" ) {
+ ctxErr.message = "";
+ }
+ }
+ node.warn("Load children failed (" + ctxErr.message + ")", ctxErr);
+ if( tree._triggerNodeEvent("loadError", ctxErr, null) !== false ) {
+ tree.nodeSetStatus(ctx, "error", ctxErr.message, ctxErr.details);
+ }
+ });
+ } else {
+ if( ctx.options.postProcess ){
+ // #792: Call postProcess for non-deferred source
+ tree._triggerNodeEvent("postProcess", ctx, ctx.originalEvent, {
+ response: source, error: null, dataType: typeof source
+ });
+ }
+ }
+ // $.when(source) resolves also for non-deferreds
+ return $.when(source).done(function(children){
+ var metaData;
+
+ if( $.isPlainObject(children) ){
+ // We got {foo: 'abc', children: [...]}
+ // Copy extra properties to tree.data.foo
+ _assert(node.isRootNode(), "source may only be an object for root nodes (expecting an array of child objects otherwise)");
+ _assert($.isArray(children.children), "if an object is passed as source, it must contain a 'children' array (all other properties are added to 'tree.data')");
+ metaData = children;
+ children = children.children;
+ delete metaData.children;
+ $.extend(tree.data, metaData);
+ }
+ _assert($.isArray(children), "expected array of children");
+ node._setChildren(children);
+ // trigger fancytreeloadchildren
+ tree._triggerNodeEvent("loadChildren", node);
+ });
+ },
+ /** [Not Implemented] */
+ nodeLoadKeyPath: function(ctx, keyPathList) {
+ // TODO: implement and improve
+ // http://code.google.com/p/dynatree/issues/detail?id=222
+ },
+ /**
+ * Remove a single direct child of ctx.node.
+ * @param {EventData} ctx
+ * @param {FancytreeNode} childNode dircect child of ctx.node
+ */
+ nodeRemoveChild: function(ctx, childNode) {
+ var idx,
+ node = ctx.node,
+ // opts = ctx.options,
+ subCtx = $.extend({}, ctx, {node: childNode}),
+ children = node.children;
+
+ // FT.debug("nodeRemoveChild()", node.toString(), childNode.toString());
+
+ if( children.length === 1 ) {
+ _assert(childNode === children[0], "invalid single child");
+ return this.nodeRemoveChildren(ctx);
+ }
+ if( this.activeNode && (childNode === this.activeNode || this.activeNode.isDescendantOf(childNode))){
+ this.activeNode.setActive(false); // TODO: don't fire events
+ }
+ if( this.focusNode && (childNode === this.focusNode || this.focusNode.isDescendantOf(childNode))){
+ this.focusNode = null;
+ }
+ // TODO: persist must take care to clear select and expand cookies
+ this.nodeRemoveMarkup(subCtx);
+ this.nodeRemoveChildren(subCtx);
+ idx = $.inArray(childNode, children);
+ _assert(idx >= 0, "invalid child");
+ // Notify listeners
+ node.triggerModifyChild("remove", childNode);
+ // Unlink to support GC
+ childNode.visit(function(n){
+ n.parent = null;
+ }, true);
+ this._callHook("treeRegisterNode", this, false, childNode);
+ // remove from child list
+ children.splice(idx, 1);
+ },
+ /**Remove HTML markup for all descendents of ctx.node.
+ * @param {EventData} ctx
+ */
+ nodeRemoveChildMarkup: function(ctx) {
+ var node = ctx.node;
+
+ // FT.debug("nodeRemoveChildMarkup()", node.toString());
+ // TODO: Unlink attr.ftnode to support GC
+ if(node.ul){
+ if( node.isRootNode() ) {
+ $(node.ul).empty();
+ } else {
+ $(node.ul).remove();
+ node.ul = null;
+ }
+ node.visit(function(n){
+ n.li = n.ul = null;
+ });
+ }
+ },
+ /**Remove all descendants of ctx.node.
+ * @param {EventData} ctx
+ */
+ nodeRemoveChildren: function(ctx) {
+ var subCtx,
+ tree = ctx.tree,
+ node = ctx.node,
+ children = node.children;
+ // opts = ctx.options;
+
+ // FT.debug("nodeRemoveChildren()", node.toString());
+ if(!children){
+ return;
+ }
+ if( this.activeNode && this.activeNode.isDescendantOf(node)){
+ this.activeNode.setActive(false); // TODO: don't fire events
+ }
+ if( this.focusNode && this.focusNode.isDescendantOf(node)){
+ this.focusNode = null;
+ }
+ // TODO: persist must take care to clear select and expand cookies
+ this.nodeRemoveChildMarkup(ctx);
+ // Unlink children to support GC
+ // TODO: also delete this.children (not possible using visit())
+ subCtx = $.extend({}, ctx);
+ node.triggerModifyChild("remove", null);
+ node.visit(function(n){
+ n.parent = null;
+ tree._callHook("treeRegisterNode", tree, false, n);
+ });
+ if( node.lazy ){
+ // 'undefined' would be interpreted as 'not yet loaded' for lazy nodes
+ node.children = [];
+ } else{
+ node.children = null;
+ }
+ if( !node.isRootNode() ) {
+ node.expanded = false; // #449, #459
+ }
+ this.nodeRenderStatus(ctx);
+ },
+ /**Remove HTML markup for ctx.node and all its descendents.
+ * @param {EventData} ctx
+ */
+ nodeRemoveMarkup: function(ctx) {
+ var node = ctx.node;
+ // FT.debug("nodeRemoveMarkup()", node.toString());
+ // TODO: Unlink attr.ftnode to support GC
+ if(node.li){
+ $(node.li).remove();
+ node.li = null;
+ }
+ this.nodeRemoveChildMarkup(ctx);
+ },
+ /**
+ * Create `<li><span>..</span> .. </li>` tags for this node.
+ *
+ * This method takes care that all HTML markup is created that is required
+ * to display this node in its current state.
+ *
+ * Call this method to create new nodes, or after the strucuture
+ * was changed (e.g. after moving this node or adding/removing children)
+ * nodeRenderTitle() and nodeRenderStatus() are implied.
+ *
+ * <code>
+ * <li id='KEY' ftnode=NODE>
+ * <span class='fancytree-node fancytree-expanded fancytree-has-children fancytree-lastsib fancytree-exp-el fancytree-ico-e'>
+ * <span class="fancytree-expander"></span>
+ * <span class="fancytree-checkbox"></span> // only present in checkbox mode
+ * <span class="fancytree-icon"></span>
+ * <a href="#" class="fancytree-title"> Node 1 </a>
+ * </span>
+ * <ul> // only present if node has children
+ * <li id='KEY' ftnode=NODE> child1 ... </li>
+ * <li id='KEY' ftnode=NODE> child2 ... </li>
+ * </ul>
+ * </li>
+ * </code>
+ *
+ * @param {EventData} ctx
+ * @param {boolean} [force=false] re-render, even if html markup was already created
+ * @param {boolean} [deep=false] also render all descendants, even if parent is collapsed
+ * @param {boolean} [collapsed=false] force root node to be collapsed, so we can apply animated expand later
+ */
+ nodeRender: function(ctx, force, deep, collapsed, _recursive) {
+ /* This method must take care of all cases where the current data mode
+ * (i.e. node hierarchy) does not match the current markup.
+ *
+ * - node was not yet rendered:
+ * create markup
+ * - node was rendered: exit fast
+ * - children have been added
+ * - children have been removed
+ */
+ var childLI, childNode1, childNode2, i, l, next, subCtx,
+ node = ctx.node,
+ tree = ctx.tree,
+ opts = ctx.options,
+ aria = opts.aria,
+ firstTime = false,
+ parent = node.parent,
+ isRootNode = !parent,
+ children = node.children,
+ successorLi = null;
+ // FT.debug("nodeRender(" + !!force + ", " + !!deep + ")", node.toString());
+
+ if( tree._enableUpdate === false ) {
+ // tree.debug("no render", tree._enableUpdate);
+ return;
+ }
+ if( ! isRootNode && ! parent.ul ) {
+ // Calling node.collapse on a deep, unrendered node
+ return;
+ }
+ _assert(isRootNode || parent.ul, "parent UL must exist");
+
+ // Render the node
+ if( !isRootNode ){
+ // Discard markup on force-mode, or if it is not linked to parent
-
+ if(node.li && (force || (node.li.parentNode !== node.parent.ul) ) ){
+ if( node.li.parentNode === node.parent.ul ){
+ // #486: store following node, so we can insert the new markup there later
+ successorLi = node.li.nextSibling;
+ }else{
+ // May happen, when a top-level node was dropped over another
+ this.debug("Unlinking " + node + " (must be child of " + node.parent + ")");
+ }
+// this.debug("nodeRemoveMarkup...");
+ this.nodeRemoveMarkup(ctx);
+ }
+ // Create