CLICK HERE TO BUY IT TODAY! OR GET IT FREE VIA TRIALPAY  

PHP Demo Application - Source Code

/Framework/Model/Vendor/CkEditor/_source/core/dom/node.js



/*
Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.html or http://ckeditor.com/license
*/
/**
 * @fileOverview Defines the {@link CKEDITOR.dom.node} class, which is the base
 *        class for classes that represent DOM nodes.
 */
/**
 * Base class for classes representing DOM nodes. This constructor may return
 * and instance of classes that inherits this class, like
 * {@link CKEDITOR.dom.element} or {@link CKEDITOR.dom.text}.
 * @augments CKEDITOR.dom.domObject
 * @param {Object} domNode A native DOM node.
 * @constructor
 * @see CKEDITOR.dom.element
 * @see CKEDITOR.dom.text
 * @example
 */
CKEDITOR.dom.node = function( domNode )
{
	    if ( domNode )
	    {
		        switch ( domNode.nodeType )
		        {
			            // Safari don't consider document as element node type. (#3389)
			            case CKEDITOR.NODE_DOCUMENT :
			                return new CKEDITOR.dom.documentdomNode );
			            case CKEDITOR.NODE_ELEMENT :
			                return new CKEDITOR.dom.elementdomNode );
			            case CKEDITOR.NODE_TEXT :
			                return new CKEDITOR.dom.textdomNode );
			        }
		        // Call the base constructor.
		        CKEDITOR.dom.domObject.callthisdomNode );
		    }
	    return this;
	};
CKEDITOR.dom.node.prototype = new CKEDITOR.dom.domObject();
/**
 * Element node type.
 * @constant
 * @example
 */
CKEDITOR.NODE_ELEMENT 1;
/**
 * Document node type.
 * @constant
 * @example
 */
CKEDITOR.NODE_DOCUMENT 9;
/**
 * Text node type.
 * @constant
 * @example
 */
CKEDITOR.NODE_TEXT 3;
/**
 * Comment node type.
 * @constant
 * @example
 */
CKEDITOR.NODE_COMMENT 8;
CKEDITOR.NODE_DOCUMENT_FRAGMENT 11;
CKEDITOR.POSITION_IDENTICAL 0;
CKEDITOR.POSITION_DISCONNECTED 1;
CKEDITOR.POSITION_FOLLOWING 2;
CKEDITOR.POSITION_PRECEDING 4;
CKEDITOR.POSITION_IS_CONTAINED 8;
CKEDITOR.POSITION_CONTAINS 16;
CKEDITOR.tools.extendCKEDITOR.dom.node.prototype,
    /** @lends CKEDITOR.dom.node.prototype */
    {
	        /**
	         * Makes this node child of another element.
	         * @param {CKEDITOR.dom.element} element The target element to which append
	         *        this node.
	         * @returns {CKEDITOR.dom.element} The target element.
	         * @example
	         * var p = new CKEDITOR.dom.element( 'p' );
	         * var strong = new CKEDITOR.dom.element( 'strong' );
	         * strong.appendTo( p );
	         *
	         * // result: "<
	p>
	<
	strong>
	<
	/strong>
	<
	/p>
	"
	         */
	        appendTo : function( elementtoStart )
	        {
		            element.appendthistoStart );
		            return element;
		        },
	        clone : function( includeChildrencloneId )
	        {
		            var $clone this.$.cloneNodeincludeChildren );
		            if ( !cloneId )
		            {
			                var removeIds = function( node )
			                {
				                    if ( node.nodeType != CKEDITOR.NODE_ELEMENT )
				                        return;
				                    node.removeAttribute'id'false ) ;
				                    node.removeAttribute'_cke_expando'false ) ;
				                    var childs node.childNodes;
				                    for ( var i=;
				 childs.length ;
				 i++ )
				                        removeIdschilds] );
				                };
			                // The "id" attribute should never be cloned to avoid duplication.
			                removeIds$clone );
			            }
		            return new CKEDITOR.dom.node$clone );
		        },
	        hasPrevious : function()
	        {
		            return !!this.$.previousSibling;
		        },
	        hasNext : function()
	        {
		            return !!this.$.nextSibling;
		        },
	        /**
	         * Inserts this element after a node.
	         * @param {CKEDITOR.dom.node} node The that will preceed this element.
	         * @returns {CKEDITOR.dom.node} The node preceeding this one after
	         *        insertion.
	         * @example
	         * var em = new CKEDITOR.dom.element( 'em' );
	         * var strong = new CKEDITOR.dom.element( 'strong' );
	         * strong.insertAfter( em );
	         *
	         * // result: "<
	em>
	<
	/em>
	<
	strong>
	<
	/strong>
	"
	         */
	        insertAfter : function( node )
	        {
		            node.$.parentNode.insertBeforethis.$, node.$.nextSibling );
		            return node;
		        },
	        /**
	         * Inserts this element before a node.
	         * @param {CKEDITOR.dom.node} node The that will be after this element.
	         * @returns {CKEDITOR.dom.node} The node being inserted.
	         * @example
	         * var em = new CKEDITOR.dom.element( 'em' );
	         * var strong = new CKEDITOR.dom.element( 'strong' );
	         * strong.insertBefore( em );
	         *
	         * // result: "<
	strong>
	<
	/strong>
	<
	em>
	<
	/em>
	"
	         */
	        insertBefore : function( node )
	        {
		            node.$.parentNode.insertBeforethis.$, node.$ );
		            return node;
		        },
	        insertBeforeMe : function( node )
	        {
		            this.$.parentNode.insertBeforenode.$, this.$ );
		            return node;
		        },
	        /**
	         * Retrieves a uniquely identifiable tree address for this node.
	         * The tree address returns is an array of integers, with each integer
	         * indicating a child index of a DOM node, starting from
	         * document.documentElement.
	         *
	         * For example, assuming <body> is the second child from <html> (<head>
	         * being the first), and we'd like to address the third child under the
	         * fourth child of body, the tree address returned would be:
	         * [1, 3, 2]
	         *
	         * The tree address cannot be used for finding back the DOM tree node once
	         * the DOM tree structure has been modified.
	         */
	        getAddress : function( normalized )
	        {
		            var address [];
		            var $documentElement this.getDocument().$.documentElement;
		            var node this.$;
		            while ( node && node != $documentElement )
		            {
			                var parentNode node.parentNode;
			                var currentIndex = -1;
			                if ( parentNode )
			                {
				                    for ( var ;
				 parentNode.childNodes.length ;
				 i++ )
				                    {
					                        var candidate parentNode.childNodes[i];
					                        if ( normalized &&
					                                candidate.nodeType == &&
					                                candidate.previousSibling &&
					                                candidate.previousSibling.nodeType == )
					                        {
						                            continue;
						                        }
					                        currentIndex++;
					                        if ( candidate == node )
					                            break;
					                    }
				                    address.unshiftcurrentIndex );
				                }
			                node parentNode;
			            }
		            return address;
		        },
	        /**
	         * Gets the document containing this element.
	         * @returns {CKEDITOR.dom.document} The document.
	         * @example
	         * var element = CKEDITOR.document.getById( 'example' );
	         * alert( <b>element.getDocument().equals( CKEDITOR.document )</b> );
	  // "true"
	         */
	        getDocument : function()
	        {
		            var document = new CKEDITOR.dom.documentthis.$.ownerDocument || this.$.parentNode.ownerDocument );
		            return (
		            this.getDocument = function()
		                {
			                    return document;
			                })();
		        },
	        getIndex : function()
	        {
		            var $ = this.$;
		            var currentNode = $.parentNode && $.parentNode.firstChild;
		            var currentIndex = -1;
		            while ( currentNode )
		            {
			                currentIndex++;
			                if ( currentNode == $ )
			                    return currentIndex;
			                currentNode currentNode.nextSibling;
			            }
		            return -1;
		        },
	        getNextSourceNode : function( startFromSiblingnodeTypeguard )
	        {
		            // If "guard" is a node, transform it in a function.
		            if ( guard && !guard.call )
		            {
			                var guardNode guard;
			                guard = function( node )
			                {
				                    return !node.equalsguardNode );
				                };
			            }
		            var node = ( !startFromSibling && this.getFirst && this.getFirst() ),
		                parent;
		            // Guarding when we're skipping the current element( no children or 'startFromSibling' ).
		            // send the 'moving out' signal even we don't actually dive into.
		            if ( !node )
		            {
			                if ( this.type == CKEDITOR.NODE_ELEMENT && guard && guardthistrue ) === false )
			                    return null;
			                node this.getNext();
			            }
		            while ( !node && ( parent = ( parent || this ).getParent() ) )
		            {
			                // The guard check sends the "true" paramenter to indicate that
			                // we are moving "out" of the element.
			                if ( guard && guardparenttrue ) === false )
			                    return null;
			                node parent.getNext();
			            }
		            if ( !node )
		                return null;
		            if ( guard && guardnode ) === false )
		                return null;
		            if ( nodeType && nodeType != node.type )
		                return node.getNextSourceNodefalsenodeTypeguard );
		            return node;
		        },
	        getPreviousSourceNode : function( startFromSiblingnodeTypeguard )
	        {
		            if ( guard && !guard.call )
		            {
			                var guardNode guard;
			                guard = function( node )
			                {
				                    return !node.equalsguardNode );
				                };
			            }
		            var node = ( !startFromSibling && this.getLast && this.getLast() ),
		                parent;
		            // Guarding when we're skipping the current element( no children or 'startFromSibling' ).
		            // send the 'moving out' signal even we don't actually dive into.
		            if ( !node )
		            {
			                if ( this.type == CKEDITOR.NODE_ELEMENT && guard && guardthistrue ) === false )
			                    return null;
			                node this.getPrevious();
			            }
		            while ( !node && ( parent = ( parent || this ).getParent() ) )
		            {
			                // The guard check sends the "true" paramenter to indicate that
			                // we are moving "out" of the element.
			                if ( guard && guardparenttrue ) === false )
			                    return null;
			                node parent.getPrevious();
			            }
		            if ( !node )
		                return null;
		            if ( guard && guardnode ) === false )
		                return null;
		            if ( nodeType && node.type != nodeType )
		                return node.getPreviousSourceNodefalsenodeTypeguard );
		            return node;
		        },
	        getPrevious : function( evaluator )
	        {
		            var previous this.$, retval;
		            do
		            {
			                previous previous.previousSibling;
			                retval previous && new CKEDITOR.dom.nodeprevious );
			            }
		            while ( retval && evaluator && !evaluatorretval ) )
		            return retval;
		        },
	        /**
	         * Gets the node that follows this element in its parent's child list.
	         * @param {Function} evaluator Filtering the result node.
	         * @returns {CKEDITOR.dom.node} The next node or null if not available.
	         * @example
	         * var element = CKEDITOR.dom.element.createFromHtml( '&lt;
	div&gt;
	&lt;
	b&gt;
	Example&lt;
	/b&gt;
	 &lt;
	i&gt;
	next&lt;
	/i&gt;
	&lt;
	/div&gt;
	' );
	         * var first = <b>element.getFirst().getNext()</b>;
	         * alert( first.getName() );
	  // "i"
	         */
	        getNext : function( evaluator )
	        {
		            var next this.$, retval;
		            do
		            {
			                next next.nextSibling;
			                retval next && new CKEDITOR.dom.nodenext );
			            }
		            while ( retval && evaluator && !evaluatorretval ) )
		            return retval;
		        },
	        /**
	         * Gets the parent element for this node.
	         * @returns {CKEDITOR.dom.element} The parent element.
	         * @example
	         * var node = editor.document.getBody().getFirst();
	         * var parent = node.<b>getParent()</b>;
	         * alert( node.getName() );
	  // "body"
	         */
	        getParent : function()
	        {
		            var parent this.$.parentNode;
		            return ( parent && parent.nodeType == ) ? new CKEDITOR.dom.nodeparent ) : null;
		        },
	        getParents : function( closerFirst )
	        {
		            var node this;
		            var parents [];
		            do
		            {
			                parents[  closerFirst 'push' 'unshift' ]( node );
			            }
		            while ( ( node node.getParent() ) )
		            return parents;
		        },
	        getCommonAncestor : function( node )
	        {
		            if ( node.equalsthis ) )
		                return this;
		            if ( node.contains && node.containsthis ) )
		                return node;
		            var start this.contains this this.getParent();
		            do
		            {
			                if ( start.containsnode ) )
			                    return start;
			            }
		            while ( ( start start.getParent() ) );
		            return null;
		        },
	        getPosition : function( otherNode )
	        {
		            var $ = this.$;
		            var $other otherNode.$;
		            if ( $.compareDocumentPosition )
		                return $.compareDocumentPosition$other );
		            // IE and Safari have no support for compareDocumentPosition.
		            if ( $ == $other )
		                return CKEDITOR.POSITION_IDENTICAL;
		            // Only element nodes support contains and sourceIndex.
		            if ( this.type == CKEDITOR.NODE_ELEMENT && otherNode.type == CKEDITOR.NODE_ELEMENT )
		            {
			                if ( $.contains )
			                {
				                    if ( $.contains$other ) )
				                        return CKEDITOR.POSITION_CONTAINS CKEDITOR.POSITION_PRECEDING;
				                    if ( $other.contains( $ ) )
				                        return CKEDITOR.POSITION_IS_CONTAINED CKEDITOR.POSITION_FOLLOWING;
				                }
			                if ( 'sourceIndex' in $ )
			                {
				                    return ( $.sourceIndex || $other.sourceIndex ) ? CKEDITOR.POSITION_DISCONNECTED :
				                        ( $.sourceIndex $other.sourceIndex ) ? CKEDITOR.POSITION_PRECEDING :
				                        CKEDITOR.POSITION_FOLLOWING;
				                }
			            }
		            // For nodes that don't support compareDocumentPosition, contains
		            // or sourceIndex, their "address" is compared.
		            var addressOfThis this.getAddress(),
		                addressOfOther otherNode.getAddress(),
		                minLevel Math.minaddressOfThis.lengthaddressOfOther.length );
		                // Determinate preceed/follow relationship.
		                for ( var ;
		 <= minLevel ;
		 i++ )
		                 {
			                    if ( addressOfThis] != addressOfOther] )
			                    {
				                        if ( minLevel )
				                        {
					                            return addressOfThis] < addressOfOther] ?
					                                    CKEDITOR.POSITION_PRECEDING CKEDITOR.POSITION_FOLLOWING;
					                        }
				                        break;
				                    }
			                 }
		                // Determinate contains/contained relationship.
		                return ( addressOfThis.length addressOfOther.length ) ?
		                            CKEDITOR.POSITION_CONTAINS CKEDITOR.POSITION_PRECEDING :
		                            CKEDITOR.POSITION_IS_CONTAINED CKEDITOR.POSITION_FOLLOWING;
		        },
	        /**
	         * Gets the closes ancestor node of a specified node name.
	         * @param {String} name Node name of ancestor node.
	         * @param {Boolean} includeSelf (Optional) Whether to include the current
	         * node in the calculation or not.
	         * @returns {CKEDITOR.dom.node} Ancestor node.
	         */
	        getAscendant : function( nameincludeSelf )
	        {
		            var $ = this.$;
		            if ( !includeSelf )
		                $ = $.parentNode;
		            while ( $ )
		            {
			                if ( $.nodeName && $.nodeName.toLowerCase() == name )
			                    return new CKEDITOR.dom.node( $ );
			                $ = $.parentNode;
			            }
		            return null;
		        },
	        hasAscendant : function( nameincludeSelf )
	        {
		            var $ = this.$;
		            if ( !includeSelf )
		                $ = $.parentNode;
		            while ( $ )
		            {
			                if ( $.nodeName && $.nodeName.toLowerCase() == name )
			                    return true;
			                $ = $.parentNode;
			            }
		            return false;
		        },
	        move : function( targettoStart )
	        {
		            target.appendthis.remove(), toStart );
		        },
	        /**
	         * Removes this node from the document DOM.
	         * @param {Boolean} [preserveChildren] Indicates that the children
	         *        elements must remain in the document, removing only the outer
	         *        tags.
	         * @example
	         * var element = CKEDITOR.dom.element.getById( 'MyElement' );
	         * <b>element.remove()</b>;
	         */
	        remove : function( preserveChildren )
	        {
		            var $ = this.$;
		            var parent = $.parentNode;
		            if ( parent )
		            {
			                if ( preserveChildren )
			                {
				                    // Move all children before the node.
				                    for ( var child ;
				 ( child = $.firstChild ) ;
				 )
				                    {
					                        parent.insertBefore( $.removeChildchild ), $ );
					                    }
				                }
			                parent.removeChild( $ );
			            }
		            return this;
		        },
	        replace : function( nodeToReplace )
	        {
		            this.insertBeforenodeToReplace );
		            nodeToReplace.remove();
		        },
	        trim : function()
	        {
		            this.ltrim();
		            this.rtrim();
		        },
	        ltrim : function()
	        {
		            var child;
		            while ( this.getFirst && ( child this.getFirst() ) )
		            {
			                if ( child.type == CKEDITOR.NODE_TEXT )
			                {
				                    var trimmed CKEDITOR.tools.ltrimchild.getText() ),
				                        originalLength child.getLength();
				                    if ( !trimmed )
				                    {
					                        child.remove();
					                        continue;
					                    }
				                    else if ( trimmed.length originalLength )
				                    {
					                        child.splitoriginalLength trimmed.length );
					                        // IE BUG: child.remove() may raise JavaScript errors here. (#81)
					                        this.$.removeChildthis.$.firstChild );
					                    }
				                }
			                break;
			            }
		        },
	        rtrim : function()
	        {
		            var child;
		            while ( this.getLast && ( child this.getLast() ) )
		            {
			                if ( child.type == CKEDITOR.NODE_TEXT )
			                {
				                    var trimmed CKEDITOR.tools.rtrimchild.getText() ),
				                        originalLength child.getLength();
				                    if ( !trimmed )
				                    {
					                        child.remove();
					                        continue;
					                    }
				                    else if ( trimmed.length originalLength )
				                    {
					                        child.splittrimmed.length );
					                        // IE BUG: child.getNext().remove() may raise JavaScript errors here.
					                        // (#81)
					                        this.$.lastChild.parentNode.removeChildthis.$.lastChild );
					                    }
				                }
			                break;
			            }
		            if ( !CKEDITOR.env.ie && !CKEDITOR.env.opera )
		            {
			                child this.$.lastChild;
			                if ( child && child.type == && child.nodeName.toLowerCase() == 'br' )
			                {
				                    // Use "eChildNode.parentNode" instead of "node" to avoid IE bug (#324).
				                    child.parentNode.removeChildchild ) ;
				                }
			            }
		        },
	        isReadOnly : function()
	        {
		            var current this;
		            while( current )
		            {
			                if ( current.type == CKEDITOR.NODE_ELEMENT )
			                {
				                    if ( current.is'body' ) || current.getCustomData'_cke_notReadOnly' ) )
				                        break;
				                    if ( current.getAttribute'contentEditable' ) == 'false' )
				                        return current;
				                    else if ( current.getAttribute'contentEditable' ) == 'true' )
				                        break;
				                }
			                current current.getParent();
			            }
		            return false;
		        }
	    }
);





PHP Demo Source Code Index