Datenstand V1.0
This commit is contained in:
145
ckeditor/_source/core/htmlparser/basicwriter.js
Normal file
145
ckeditor/_source/core/htmlparser/basicwriter.js
Normal file
@@ -0,0 +1,145 @@
|
||||
/*
|
||||
Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
|
||||
For licensing, see LICENSE.html or http://ckeditor.com/license
|
||||
*/
|
||||
|
||||
CKEDITOR.htmlParser.basicWriter = CKEDITOR.tools.createClass(
|
||||
{
|
||||
$ : function()
|
||||
{
|
||||
this._ =
|
||||
{
|
||||
output : []
|
||||
};
|
||||
},
|
||||
|
||||
proto :
|
||||
{
|
||||
/**
|
||||
* Writes the tag opening part for a opener tag.
|
||||
* @param {String} tagName The element name for this tag.
|
||||
* @param {Object} attributes The attributes defined for this tag. The
|
||||
* attributes could be used to inspect the tag.
|
||||
* @example
|
||||
* // Writes "<p".
|
||||
* writer.openTag( 'p', { class : 'MyClass', id : 'MyId' } );
|
||||
*/
|
||||
openTag : function( tagName, attributes )
|
||||
{
|
||||
this._.output.push( '<', tagName );
|
||||
},
|
||||
|
||||
/**
|
||||
* Writes the tag closing part for a opener tag.
|
||||
* @param {String} tagName The element name for this tag.
|
||||
* @param {Boolean} isSelfClose Indicates that this is a self-closing tag,
|
||||
* like "br" or "img".
|
||||
* @example
|
||||
* // Writes ">".
|
||||
* writer.openTagClose( 'p', false );
|
||||
* @example
|
||||
* // Writes " />".
|
||||
* writer.openTagClose( 'br', true );
|
||||
*/
|
||||
openTagClose : function( tagName, isSelfClose )
|
||||
{
|
||||
if ( isSelfClose )
|
||||
this._.output.push( ' />' );
|
||||
else
|
||||
this._.output.push( '>' );
|
||||
},
|
||||
|
||||
/**
|
||||
* Writes an attribute. This function should be called after opening the
|
||||
* tag with {@link #openTagClose}.
|
||||
* @param {String} attName The attribute name.
|
||||
* @param {String} attValue The attribute value.
|
||||
* @example
|
||||
* // Writes ' class="MyClass"'.
|
||||
* writer.attribute( 'class', 'MyClass' );
|
||||
*/
|
||||
attribute : function( attName, attValue )
|
||||
{
|
||||
// Browsers don't always escape special character in attribute values. (#4683, #4719).
|
||||
if ( typeof attValue == 'string' )
|
||||
attValue = CKEDITOR.tools.htmlEncodeAttr( attValue );
|
||||
|
||||
this._.output.push( ' ', attName, '="', attValue, '"' );
|
||||
},
|
||||
|
||||
/**
|
||||
* Writes a closer tag.
|
||||
* @param {String} tagName The element name for this tag.
|
||||
* @example
|
||||
* // Writes "</p>".
|
||||
* writer.closeTag( 'p' );
|
||||
*/
|
||||
closeTag : function( tagName )
|
||||
{
|
||||
this._.output.push( '</', tagName, '>' );
|
||||
},
|
||||
|
||||
/**
|
||||
* Writes text.
|
||||
* @param {String} text The text value
|
||||
* @example
|
||||
* // Writes "Hello Word".
|
||||
* writer.text( 'Hello Word' );
|
||||
*/
|
||||
text : function( text )
|
||||
{
|
||||
this._.output.push( text );
|
||||
},
|
||||
|
||||
/**
|
||||
* Writes a comment.
|
||||
* @param {String} comment The comment text.
|
||||
* @example
|
||||
* // Writes "<!-- My comment -->".
|
||||
* writer.comment( ' My comment ' );
|
||||
*/
|
||||
comment : function( comment )
|
||||
{
|
||||
this._.output.push( '<!--', comment, '-->' );
|
||||
},
|
||||
|
||||
/**
|
||||
* Writes any kind of data to the ouput.
|
||||
* @example
|
||||
* writer.write( 'This is an <b>example</b>.' );
|
||||
*/
|
||||
write : function( data )
|
||||
{
|
||||
this._.output.push( data );
|
||||
},
|
||||
|
||||
/**
|
||||
* Empties the current output buffer.
|
||||
* @example
|
||||
* writer.reset();
|
||||
*/
|
||||
reset : function()
|
||||
{
|
||||
this._.output = [];
|
||||
this._.indent = false;
|
||||
},
|
||||
|
||||
/**
|
||||
* Empties the current output buffer.
|
||||
* @param {Boolean} reset Indicates that the {@link reset} function is to
|
||||
* be automatically called after retrieving the HTML.
|
||||
* @returns {String} The HTML written to the writer so far.
|
||||
* @example
|
||||
* var html = writer.getHtml();
|
||||
*/
|
||||
getHtml : function( reset )
|
||||
{
|
||||
var html = this._.output.join( '' );
|
||||
|
||||
if ( reset )
|
||||
this.reset();
|
||||
|
||||
return html;
|
||||
}
|
||||
}
|
||||
});
|
||||
43
ckeditor/_source/core/htmlparser/cdata.js
Normal file
43
ckeditor/_source/core/htmlparser/cdata.js
Normal file
@@ -0,0 +1,43 @@
|
||||
/*
|
||||
Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
|
||||
For licensing, see LICENSE.html or http://ckeditor.com/license
|
||||
*/
|
||||
|
||||
(function()
|
||||
{
|
||||
|
||||
/**
|
||||
* A lightweight representation of HTML text.
|
||||
* @constructor
|
||||
* @example
|
||||
*/
|
||||
CKEDITOR.htmlParser.cdata = function( value )
|
||||
{
|
||||
/**
|
||||
* The CDATA value.
|
||||
* @type String
|
||||
* @example
|
||||
*/
|
||||
this.value = value;
|
||||
};
|
||||
|
||||
CKEDITOR.htmlParser.cdata.prototype =
|
||||
{
|
||||
/**
|
||||
* CDATA has the same type as {@link CKEDITOR.htmlParser.text} This is
|
||||
* a constant value set to {@link CKEDITOR.NODE_TEXT}.
|
||||
* @type Number
|
||||
* @example
|
||||
*/
|
||||
type : CKEDITOR.NODE_TEXT,
|
||||
|
||||
/**
|
||||
* Writes write the CDATA with no special manipulations.
|
||||
* @param {CKEDITOR.htmlWriter} writer The writer to which write the HTML.
|
||||
*/
|
||||
writeHtml : function( writer )
|
||||
{
|
||||
writer.write( this.value );
|
||||
}
|
||||
};
|
||||
})();
|
||||
60
ckeditor/_source/core/htmlparser/comment.js
Normal file
60
ckeditor/_source/core/htmlparser/comment.js
Normal file
@@ -0,0 +1,60 @@
|
||||
/*
|
||||
Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
|
||||
For licensing, see LICENSE.html or http://ckeditor.com/license
|
||||
*/
|
||||
|
||||
/**
|
||||
* A lightweight representation of an HTML comment.
|
||||
* @constructor
|
||||
* @example
|
||||
*/
|
||||
CKEDITOR.htmlParser.comment = function( value )
|
||||
{
|
||||
/**
|
||||
* The comment text.
|
||||
* @type String
|
||||
* @example
|
||||
*/
|
||||
this.value = value;
|
||||
|
||||
/** @private */
|
||||
this._ =
|
||||
{
|
||||
isBlockLike : false
|
||||
};
|
||||
};
|
||||
|
||||
CKEDITOR.htmlParser.comment.prototype =
|
||||
{
|
||||
/**
|
||||
* The node type. This is a constant value set to {@link CKEDITOR.NODE_COMMENT}.
|
||||
* @type Number
|
||||
* @example
|
||||
*/
|
||||
type : CKEDITOR.NODE_COMMENT,
|
||||
|
||||
/**
|
||||
* Writes the HTML representation of this comment to a CKEDITOR.htmlWriter.
|
||||
* @param {CKEDITOR.htmlWriter} writer The writer to which write the HTML.
|
||||
* @example
|
||||
*/
|
||||
writeHtml : function( writer, filter )
|
||||
{
|
||||
var comment = this.value;
|
||||
|
||||
if ( filter )
|
||||
{
|
||||
if ( !( comment = filter.onComment( comment, this ) ) )
|
||||
return;
|
||||
|
||||
if ( typeof comment != 'string' )
|
||||
{
|
||||
comment.parent = this.parent;
|
||||
comment.writeHtml( writer, filter );
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
writer.comment( comment );
|
||||
}
|
||||
};
|
||||
240
ckeditor/_source/core/htmlparser/element.js
Normal file
240
ckeditor/_source/core/htmlparser/element.js
Normal file
@@ -0,0 +1,240 @@
|
||||
/*
|
||||
Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
|
||||
For licensing, see LICENSE.html or http://ckeditor.com/license
|
||||
*/
|
||||
|
||||
/**
|
||||
* A lightweight representation of an HTML element.
|
||||
* @param {String} name The element name.
|
||||
* @param {Object} attributes And object holding all attributes defined for
|
||||
* this element.
|
||||
* @constructor
|
||||
* @example
|
||||
*/
|
||||
CKEDITOR.htmlParser.element = function( name, attributes )
|
||||
{
|
||||
/**
|
||||
* The element name.
|
||||
* @type String
|
||||
* @example
|
||||
*/
|
||||
this.name = name;
|
||||
|
||||
/**
|
||||
* Holds the attributes defined for this element.
|
||||
* @type Object
|
||||
* @example
|
||||
*/
|
||||
this.attributes = attributes || ( attributes = {} );
|
||||
|
||||
/**
|
||||
* The nodes that are direct children of this element.
|
||||
* @type Array
|
||||
* @example
|
||||
*/
|
||||
this.children = [];
|
||||
|
||||
var tagName = attributes._cke_real_element_type || name;
|
||||
|
||||
var dtd = CKEDITOR.dtd,
|
||||
isBlockLike = !!( dtd.$nonBodyContent[ tagName ] || dtd.$block[ tagName ] || dtd.$listItem[ tagName ] || dtd.$tableContent[ tagName ] || dtd.$nonEditable[ tagName ] || tagName == 'br' ),
|
||||
isEmpty = !!dtd.$empty[ name ];
|
||||
|
||||
this.isEmpty = isEmpty;
|
||||
this.isUnknown = !dtd[ name ];
|
||||
|
||||
/** @private */
|
||||
this._ =
|
||||
{
|
||||
isBlockLike : isBlockLike,
|
||||
hasInlineStarted : isEmpty || !isBlockLike
|
||||
};
|
||||
};
|
||||
|
||||
(function()
|
||||
{
|
||||
// Used to sort attribute entries in an array, where the first element of
|
||||
// each object is the attribute name.
|
||||
var sortAttribs = function( a, b )
|
||||
{
|
||||
a = a[0];
|
||||
b = b[0];
|
||||
return a < b ? -1 : a > b ? 1 : 0;
|
||||
};
|
||||
|
||||
CKEDITOR.htmlParser.element.prototype =
|
||||
{
|
||||
/**
|
||||
* The node type. This is a constant value set to {@link CKEDITOR.NODE_ELEMENT}.
|
||||
* @type Number
|
||||
* @example
|
||||
*/
|
||||
type : CKEDITOR.NODE_ELEMENT,
|
||||
|
||||
/**
|
||||
* Adds a node to the element children list.
|
||||
* @param {Object} node The node to be added. It can be any of of the
|
||||
* following types: {@link CKEDITOR.htmlParser.element},
|
||||
* {@link CKEDITOR.htmlParser.text} and
|
||||
* {@link CKEDITOR.htmlParser.comment}.
|
||||
* @function
|
||||
* @example
|
||||
*/
|
||||
add : CKEDITOR.htmlParser.fragment.prototype.add,
|
||||
|
||||
/**
|
||||
* Clone this element.
|
||||
* @returns {CKEDITOR.htmlParser.element} The element clone.
|
||||
* @example
|
||||
*/
|
||||
clone : function()
|
||||
{
|
||||
return new CKEDITOR.htmlParser.element( this.name, this.attributes );
|
||||
},
|
||||
|
||||
/**
|
||||
* Writes the element HTML to a CKEDITOR.htmlWriter.
|
||||
* @param {CKEDITOR.htmlWriter} writer The writer to which write the HTML.
|
||||
* @example
|
||||
*/
|
||||
writeHtml : function( writer, filter )
|
||||
{
|
||||
var attributes = this.attributes;
|
||||
|
||||
// Ignore cke: prefixes when writing HTML.
|
||||
var element = this,
|
||||
writeName = element.name,
|
||||
a, newAttrName, value;
|
||||
|
||||
var isChildrenFiltered;
|
||||
|
||||
/**
|
||||
* Providing an option for bottom-up filtering order ( element
|
||||
* children to be pre-filtered before the element itself ).
|
||||
*/
|
||||
element.filterChildren = function()
|
||||
{
|
||||
if ( !isChildrenFiltered )
|
||||
{
|
||||
var writer = new CKEDITOR.htmlParser.basicWriter();
|
||||
CKEDITOR.htmlParser.fragment.prototype.writeChildrenHtml.call( element, writer, filter );
|
||||
element.children = new CKEDITOR.htmlParser.fragment.fromHtml( writer.getHtml() ).children;
|
||||
isChildrenFiltered = 1;
|
||||
}
|
||||
};
|
||||
|
||||
if ( filter )
|
||||
{
|
||||
while ( true )
|
||||
{
|
||||
if ( !( writeName = filter.onElementName( writeName ) ) )
|
||||
return;
|
||||
|
||||
element.name = writeName;
|
||||
|
||||
if ( !( element = filter.onElement( element ) ) )
|
||||
return;
|
||||
|
||||
element.parent = this.parent;
|
||||
|
||||
if ( element.name == writeName )
|
||||
break;
|
||||
|
||||
// If the element has been replaced with something of a
|
||||
// different type, then make the replacement write itself.
|
||||
if ( element.type != CKEDITOR.NODE_ELEMENT )
|
||||
{
|
||||
element.writeHtml( writer, filter );
|
||||
return;
|
||||
}
|
||||
|
||||
writeName = element.name;
|
||||
|
||||
// This indicate that the element has been dropped by
|
||||
// filter but not the children.
|
||||
if ( !writeName )
|
||||
{
|
||||
this.writeChildrenHtml.call( element, writer, isChildrenFiltered ? null : filter );
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// The element may have been changed, so update the local
|
||||
// references.
|
||||
attributes = element.attributes;
|
||||
}
|
||||
|
||||
// Open element tag.
|
||||
writer.openTag( writeName, attributes );
|
||||
|
||||
// Copy all attributes to an array.
|
||||
var attribsArray = [];
|
||||
// Iterate over the attributes twice since filters may alter
|
||||
// other attributes.
|
||||
for ( var i = 0 ; i < 2; i++ )
|
||||
{
|
||||
for ( a in attributes )
|
||||
{
|
||||
newAttrName = a;
|
||||
value = attributes[ a ];
|
||||
if ( i == 1 )
|
||||
attribsArray.push( [ a, value ] );
|
||||
else if ( filter )
|
||||
{
|
||||
while ( true )
|
||||
{
|
||||
if ( !( newAttrName = filter.onAttributeName( a ) ) )
|
||||
{
|
||||
delete attributes[ a ];
|
||||
break;
|
||||
}
|
||||
else if ( newAttrName != a )
|
||||
{
|
||||
delete attributes[ a ];
|
||||
a = newAttrName;
|
||||
continue;
|
||||
}
|
||||
else
|
||||
break;
|
||||
}
|
||||
if ( newAttrName )
|
||||
{
|
||||
if ( ( value = filter.onAttribute( element, newAttrName, value ) ) === false )
|
||||
delete attributes[ newAttrName ];
|
||||
else
|
||||
attributes [ newAttrName ] = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Sort the attributes by name.
|
||||
if ( writer.sortAttributes )
|
||||
attribsArray.sort( sortAttribs );
|
||||
|
||||
// Send the attributes.
|
||||
var len = attribsArray.length;
|
||||
for ( i = 0 ; i < len ; i++ )
|
||||
{
|
||||
var attrib = attribsArray[ i ];
|
||||
writer.attribute( attrib[0], attrib[1] );
|
||||
}
|
||||
|
||||
// Close the tag.
|
||||
writer.openTagClose( writeName, element.isEmpty );
|
||||
|
||||
if ( !element.isEmpty )
|
||||
{
|
||||
this.writeChildrenHtml.call( element, writer, isChildrenFiltered ? null : filter );
|
||||
// Close the element.
|
||||
writer.closeTag( writeName );
|
||||
}
|
||||
},
|
||||
|
||||
writeChildrenHtml : function( writer, filter )
|
||||
{
|
||||
// Send children.
|
||||
CKEDITOR.htmlParser.fragment.prototype.writeChildrenHtml.apply( this, arguments );
|
||||
|
||||
}
|
||||
};
|
||||
})();
|
||||
288
ckeditor/_source/core/htmlparser/filter.js
Normal file
288
ckeditor/_source/core/htmlparser/filter.js
Normal file
@@ -0,0 +1,288 @@
|
||||
/*
|
||||
Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
|
||||
For licensing, see LICENSE.html or http://ckeditor.com/license
|
||||
*/
|
||||
|
||||
(function()
|
||||
{
|
||||
CKEDITOR.htmlParser.filter = CKEDITOR.tools.createClass(
|
||||
{
|
||||
$ : function( rules )
|
||||
{
|
||||
this._ =
|
||||
{
|
||||
elementNames : [],
|
||||
attributeNames : [],
|
||||
elements : { $length : 0 },
|
||||
attributes : { $length : 0 }
|
||||
};
|
||||
|
||||
if ( rules )
|
||||
this.addRules( rules, 10 );
|
||||
},
|
||||
|
||||
proto :
|
||||
{
|
||||
addRules : function( rules, priority )
|
||||
{
|
||||
if ( typeof priority != 'number' )
|
||||
priority = 10;
|
||||
|
||||
// Add the elementNames.
|
||||
addItemsToList( this._.elementNames, rules.elementNames, priority );
|
||||
|
||||
// Add the attributeNames.
|
||||
addItemsToList( this._.attributeNames, rules.attributeNames, priority );
|
||||
|
||||
// Add the elements.
|
||||
addNamedItems( this._.elements, rules.elements, priority );
|
||||
|
||||
// Add the attributes.
|
||||
addNamedItems( this._.attributes, rules.attributes, priority );
|
||||
|
||||
// Add the text.
|
||||
this._.text = transformNamedItem( this._.text, rules.text, priority ) || this._.text;
|
||||
|
||||
// Add the comment.
|
||||
this._.comment = transformNamedItem( this._.comment, rules.comment, priority ) || this._.comment;
|
||||
|
||||
// Add root fragment.
|
||||
this._.root = transformNamedItem( this._.root, rules.root, priority ) || this._.root;
|
||||
},
|
||||
|
||||
onElementName : function( name )
|
||||
{
|
||||
return filterName( name, this._.elementNames );
|
||||
},
|
||||
|
||||
onAttributeName : function( name )
|
||||
{
|
||||
return filterName( name, this._.attributeNames );
|
||||
},
|
||||
|
||||
onText : function( text )
|
||||
{
|
||||
var textFilter = this._.text;
|
||||
return textFilter ? textFilter.filter( text ) : text;
|
||||
},
|
||||
|
||||
onComment : function( commentText, comment )
|
||||
{
|
||||
var textFilter = this._.comment;
|
||||
return textFilter ? textFilter.filter( commentText, comment ) : commentText;
|
||||
},
|
||||
|
||||
onFragment : function( element )
|
||||
{
|
||||
var rootFilter = this._.root;
|
||||
return rootFilter ? rootFilter.filter( element ) : element;
|
||||
},
|
||||
|
||||
onElement : function( element )
|
||||
{
|
||||
// We must apply filters set to the specific element name as
|
||||
// well as those set to the generic $ name. So, add both to an
|
||||
// array and process them in a small loop.
|
||||
var filters = [ this._.elements[ '^' ], this._.elements[ element.name ], this._.elements.$ ],
|
||||
filter, ret;
|
||||
|
||||
for ( var i = 0 ; i < 3 ; i++ )
|
||||
{
|
||||
filter = filters[ i ];
|
||||
if ( filter )
|
||||
{
|
||||
ret = filter.filter( element, this );
|
||||
|
||||
if ( ret === false )
|
||||
return null;
|
||||
|
||||
if ( ret && ret != element )
|
||||
return this.onNode( ret );
|
||||
|
||||
// The non-root element has been dismissed by one of the filters.
|
||||
if ( element.parent && !element.name )
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return element;
|
||||
},
|
||||
|
||||
onNode : function( node )
|
||||
{
|
||||
var type = node.type;
|
||||
|
||||
return type == CKEDITOR.NODE_ELEMENT ? this.onElement( node ) :
|
||||
type == CKEDITOR.NODE_TEXT ? new CKEDITOR.htmlParser.text( this.onText( node.value ) ) :
|
||||
type == CKEDITOR.NODE_COMMENT ? new CKEDITOR.htmlParser.comment( this.onComment( node.value ) ):
|
||||
null;
|
||||
},
|
||||
|
||||
onAttribute : function( element, name, value )
|
||||
{
|
||||
var filter = this._.attributes[ name ];
|
||||
|
||||
if ( filter )
|
||||
{
|
||||
var ret = filter.filter( value, element, this );
|
||||
|
||||
if ( ret === false )
|
||||
return false;
|
||||
|
||||
if ( typeof ret != 'undefined' )
|
||||
return ret;
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
function filterName( name, filters )
|
||||
{
|
||||
for ( var i = 0 ; name && i < filters.length ; i++ )
|
||||
{
|
||||
var filter = filters[ i ];
|
||||
name = name.replace( filter[ 0 ], filter[ 1 ] );
|
||||
}
|
||||
return name;
|
||||
}
|
||||
|
||||
function addItemsToList( list, items, priority )
|
||||
{
|
||||
if ( typeof items == 'function' )
|
||||
items = [ items ];
|
||||
|
||||
var i, j,
|
||||
listLength = list.length,
|
||||
itemsLength = items && items.length;
|
||||
|
||||
if ( itemsLength )
|
||||
{
|
||||
// Find the index to insert the items at.
|
||||
for ( i = 0 ; i < listLength && list[ i ].pri < priority ; i++ )
|
||||
{ /*jsl:pass*/ }
|
||||
|
||||
// Add all new items to the list at the specific index.
|
||||
for ( j = itemsLength - 1 ; j >= 0 ; j-- )
|
||||
{
|
||||
var item = items[ j ];
|
||||
if ( item )
|
||||
{
|
||||
item.pri = priority;
|
||||
list.splice( i, 0, item );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function addNamedItems( hashTable, items, priority )
|
||||
{
|
||||
if ( items )
|
||||
{
|
||||
for ( var name in items )
|
||||
{
|
||||
var current = hashTable[ name ];
|
||||
|
||||
hashTable[ name ] =
|
||||
transformNamedItem(
|
||||
current,
|
||||
items[ name ],
|
||||
priority );
|
||||
|
||||
if ( !current )
|
||||
hashTable.$length++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function transformNamedItem( current, item, priority )
|
||||
{
|
||||
if ( item )
|
||||
{
|
||||
item.pri = priority;
|
||||
|
||||
if ( current )
|
||||
{
|
||||
// If the current item is not an Array, transform it.
|
||||
if ( !current.splice )
|
||||
{
|
||||
if ( current.pri > priority )
|
||||
current = [ item, current ];
|
||||
else
|
||||
current = [ current, item ];
|
||||
|
||||
current.filter = callItems;
|
||||
}
|
||||
else
|
||||
addItemsToList( current, item, priority );
|
||||
|
||||
return current;
|
||||
}
|
||||
else
|
||||
{
|
||||
item.filter = item;
|
||||
return item;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Invoke filters sequentially on the array, break the iteration
|
||||
// when it doesn't make sense to continue anymore.
|
||||
function callItems( currentEntry )
|
||||
{
|
||||
var isNode = currentEntry.type
|
||||
|| currentEntry instanceof CKEDITOR.htmlParser.fragment;
|
||||
|
||||
for ( var i = 0 ; i < this.length ; i++ )
|
||||
{
|
||||
// Backup the node info before filtering.
|
||||
if ( isNode )
|
||||
{
|
||||
var orgType = currentEntry.type,
|
||||
orgName = currentEntry.name;
|
||||
}
|
||||
|
||||
var item = this[ i ],
|
||||
ret = item.apply( window, arguments );
|
||||
|
||||
if ( ret === false )
|
||||
return ret;
|
||||
|
||||
// We're filtering node (element/fragment).
|
||||
if ( isNode )
|
||||
{
|
||||
// No further filtering if it's not anymore
|
||||
// fitable for the subsequent filters.
|
||||
if ( ret && ( ret.name != orgName
|
||||
|| ret.type != orgType ) )
|
||||
{
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
// Filtering value (nodeName/textValue/attrValue).
|
||||
else
|
||||
{
|
||||
// No further filtering if it's not
|
||||
// any more values.
|
||||
if ( typeof ret != 'string' )
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret != undefined && ( currentEntry = ret );
|
||||
}
|
||||
|
||||
return currentEntry;
|
||||
}
|
||||
})();
|
||||
|
||||
// "entities" plugin
|
||||
/*
|
||||
{
|
||||
text : function( text )
|
||||
{
|
||||
// TODO : Process entities.
|
||||
return text.toUpperCase();
|
||||
}
|
||||
};
|
||||
*/
|
||||
497
ckeditor/_source/core/htmlparser/fragment.js
Normal file
497
ckeditor/_source/core/htmlparser/fragment.js
Normal file
@@ -0,0 +1,497 @@
|
||||
/*
|
||||
Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
|
||||
For licensing, see LICENSE.html or http://ckeditor.com/license
|
||||
*/
|
||||
|
||||
/**
|
||||
* A lightweight representation of an HTML DOM structure.
|
||||
* @constructor
|
||||
* @example
|
||||
*/
|
||||
CKEDITOR.htmlParser.fragment = function()
|
||||
{
|
||||
/**
|
||||
* The nodes contained in the root of this fragment.
|
||||
* @type Array
|
||||
* @example
|
||||
* var fragment = CKEDITOR.htmlParser.fragment.fromHtml( '<b>Sample</b> Text' );
|
||||
* alert( fragment.children.length ); "2"
|
||||
*/
|
||||
this.children = [];
|
||||
|
||||
/**
|
||||
* Get the fragment parent. Should always be null.
|
||||
* @type Object
|
||||
* @default null
|
||||
* @example
|
||||
*/
|
||||
this.parent = null;
|
||||
|
||||
/** @private */
|
||||
this._ =
|
||||
{
|
||||
isBlockLike : true,
|
||||
hasInlineStarted : false
|
||||
};
|
||||
};
|
||||
|
||||
(function()
|
||||
{
|
||||
// Elements which the end tag is marked as optional in the HTML 4.01 DTD
|
||||
// (expect empty elements).
|
||||
var optionalClose = {colgroup:1,dd:1,dt:1,li:1,option:1,p:1,td:1,tfoot:1,th:1,thead:1,tr:1};
|
||||
|
||||
// Block-level elements whose internal structure should be respected during
|
||||
// parser fixing.
|
||||
var nonBreakingBlocks = CKEDITOR.tools.extend(
|
||||
{table:1,ul:1,ol:1,dl:1},
|
||||
CKEDITOR.dtd.table, CKEDITOR.dtd.ul, CKEDITOR.dtd.ol, CKEDITOR.dtd.dl ),
|
||||
listBlocks = CKEDITOR.dtd.$list, listItems = CKEDITOR.dtd.$listItem;
|
||||
|
||||
/**
|
||||
* Creates a {@link CKEDITOR.htmlParser.fragment} from an HTML string.
|
||||
* @param {String} fragmentHtml The HTML to be parsed, filling the fragment.
|
||||
* @param {Number} [fixForBody=false] Wrap body with specified element if needed.
|
||||
* @returns CKEDITOR.htmlParser.fragment The fragment created.
|
||||
* @example
|
||||
* var fragment = CKEDITOR.htmlParser.fragment.fromHtml( '<b>Sample</b> Text' );
|
||||
* alert( fragment.children[0].name ); "b"
|
||||
* alert( fragment.children[1].value ); " Text"
|
||||
*/
|
||||
CKEDITOR.htmlParser.fragment.fromHtml = function( fragmentHtml, fixForBody )
|
||||
{
|
||||
var parser = new CKEDITOR.htmlParser(),
|
||||
html = [],
|
||||
fragment = new CKEDITOR.htmlParser.fragment(),
|
||||
pendingInline = [],
|
||||
pendingBRs = [],
|
||||
currentNode = fragment,
|
||||
// Indicate we're inside a <pre> element, spaces should be touched differently.
|
||||
inPre = false,
|
||||
returnPoint;
|
||||
|
||||
function checkPending( newTagName )
|
||||
{
|
||||
var pendingBRsSent;
|
||||
|
||||
if ( pendingInline.length > 0 )
|
||||
{
|
||||
for ( var i = 0 ; i < pendingInline.length ; i++ )
|
||||
{
|
||||
var pendingElement = pendingInline[ i ],
|
||||
pendingName = pendingElement.name,
|
||||
pendingDtd = CKEDITOR.dtd[ pendingName ],
|
||||
currentDtd = currentNode.name && CKEDITOR.dtd[ currentNode.name ];
|
||||
|
||||
if ( ( !currentDtd || currentDtd[ pendingName ] ) && ( !newTagName || !pendingDtd || pendingDtd[ newTagName ] || !CKEDITOR.dtd[ newTagName ] ) )
|
||||
{
|
||||
if ( !pendingBRsSent )
|
||||
{
|
||||
sendPendingBRs();
|
||||
pendingBRsSent = 1;
|
||||
}
|
||||
|
||||
// Get a clone for the pending element.
|
||||
pendingElement = pendingElement.clone();
|
||||
|
||||
// Add it to the current node and make it the current,
|
||||
// so the new element will be added inside of it.
|
||||
pendingElement.parent = currentNode;
|
||||
currentNode = pendingElement;
|
||||
|
||||
// Remove the pending element (back the index by one
|
||||
// to properly process the next entry).
|
||||
pendingInline.splice( i, 1 );
|
||||
i--;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function sendPendingBRs( brsToIgnore )
|
||||
{
|
||||
while ( pendingBRs.length - ( brsToIgnore || 0 ) > 0 )
|
||||
currentNode.add( pendingBRs.shift() );
|
||||
}
|
||||
|
||||
function addElement( element, target, enforceCurrent )
|
||||
{
|
||||
target = target || currentNode || fragment;
|
||||
|
||||
// If the target is the fragment and this element can't go inside
|
||||
// body (if fixForBody).
|
||||
if ( fixForBody && !target.type )
|
||||
{
|
||||
var elementName, realElementName;
|
||||
if ( element.attributes
|
||||
&& ( realElementName =
|
||||
element.attributes[ '_cke_real_element_type' ] ) )
|
||||
elementName = realElementName;
|
||||
else
|
||||
elementName = element.name;
|
||||
if ( elementName
|
||||
&& !( elementName in CKEDITOR.dtd.$body )
|
||||
&& !( elementName in CKEDITOR.dtd.$nonBodyContent ) )
|
||||
{
|
||||
var savedCurrent = currentNode;
|
||||
|
||||
// Create a <p> in the fragment.
|
||||
currentNode = target;
|
||||
parser.onTagOpen( fixForBody, {} );
|
||||
|
||||
// The new target now is the <p>.
|
||||
target = currentNode;
|
||||
|
||||
if ( enforceCurrent )
|
||||
currentNode = savedCurrent;
|
||||
}
|
||||
}
|
||||
|
||||
// Rtrim empty spaces on block end boundary. (#3585)
|
||||
if ( element._.isBlockLike
|
||||
&& element.name != 'pre' )
|
||||
{
|
||||
|
||||
var length = element.children.length,
|
||||
lastChild = element.children[ length - 1 ],
|
||||
text;
|
||||
if ( lastChild && lastChild.type == CKEDITOR.NODE_TEXT )
|
||||
{
|
||||
if ( !( text = CKEDITOR.tools.rtrim( lastChild.value ) ) )
|
||||
element.children.length = length -1;
|
||||
else
|
||||
lastChild.value = text;
|
||||
}
|
||||
}
|
||||
|
||||
target.add( element );
|
||||
|
||||
if ( element.returnPoint )
|
||||
{
|
||||
currentNode = element.returnPoint;
|
||||
delete element.returnPoint;
|
||||
}
|
||||
}
|
||||
|
||||
parser.onTagOpen = function( tagName, attributes, selfClosing )
|
||||
{
|
||||
var element = new CKEDITOR.htmlParser.element( tagName, attributes );
|
||||
|
||||
// "isEmpty" will be always "false" for unknown elements, so we
|
||||
// must force it if the parser has identified it as a selfClosing tag.
|
||||
if ( element.isUnknown && selfClosing )
|
||||
element.isEmpty = true;
|
||||
|
||||
// This is a tag to be removed if empty, so do not add it immediately.
|
||||
if ( CKEDITOR.dtd.$removeEmpty[ tagName ] )
|
||||
{
|
||||
pendingInline.push( element );
|
||||
return;
|
||||
}
|
||||
else if ( tagName == 'pre' )
|
||||
inPre = true;
|
||||
else if ( tagName == 'br' && inPre )
|
||||
{
|
||||
currentNode.add( new CKEDITOR.htmlParser.text( '\n' ) );
|
||||
return;
|
||||
}
|
||||
|
||||
if ( tagName == 'br' )
|
||||
{
|
||||
pendingBRs.push( element );
|
||||
return;
|
||||
}
|
||||
|
||||
var currentName = currentNode.name;
|
||||
|
||||
var currentDtd = currentName
|
||||
&& ( CKEDITOR.dtd[ currentName ]
|
||||
|| ( currentNode._.isBlockLike ? CKEDITOR.dtd.div : CKEDITOR.dtd.span ) );
|
||||
|
||||
// If the element cannot be child of the current element.
|
||||
if ( currentDtd // Fragment could receive any elements.
|
||||
&& !element.isUnknown && !currentNode.isUnknown && !currentDtd[ tagName ] )
|
||||
{
|
||||
|
||||
var reApply = false,
|
||||
addPoint; // New position to start adding nodes.
|
||||
|
||||
// Fixing malformed nested lists by moving it into a previous list item. (#3828)
|
||||
if ( tagName in listBlocks
|
||||
&& currentName in listBlocks )
|
||||
{
|
||||
var children = currentNode.children,
|
||||
lastChild = children[ children.length - 1 ];
|
||||
|
||||
// Establish the list item if it's not existed.
|
||||
if ( !( lastChild && lastChild.name in listItems ) )
|
||||
addElement( ( lastChild = new CKEDITOR.htmlParser.element( 'li' ) ), currentNode );
|
||||
|
||||
returnPoint = currentNode, addPoint = lastChild;
|
||||
}
|
||||
// If the element name is the same as the current element name,
|
||||
// then just close the current one and append the new one to the
|
||||
// parent. This situation usually happens with <p>, <li>, <dt> and
|
||||
// <dd>, specially in IE. Do not enter in this if block in this case.
|
||||
else if ( tagName == currentName )
|
||||
{
|
||||
addElement( currentNode, currentNode.parent );
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( nonBreakingBlocks[ currentName ] )
|
||||
{
|
||||
if ( !returnPoint )
|
||||
returnPoint = currentNode;
|
||||
}
|
||||
else
|
||||
{
|
||||
addElement( currentNode, currentNode.parent, true );
|
||||
|
||||
if ( !optionalClose[ currentName ] )
|
||||
{
|
||||
// The current element is an inline element, which
|
||||
// cannot hold the new one. Put it in the pending list,
|
||||
// and try adding the new one after it.
|
||||
pendingInline.unshift( currentNode );
|
||||
}
|
||||
}
|
||||
|
||||
reApply = true;
|
||||
}
|
||||
|
||||
if ( addPoint )
|
||||
currentNode = addPoint;
|
||||
// Try adding it to the return point, or the parent element.
|
||||
else
|
||||
currentNode = currentNode.returnPoint || currentNode.parent;
|
||||
|
||||
if ( reApply )
|
||||
{
|
||||
parser.onTagOpen.apply( this, arguments );
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
checkPending( tagName );
|
||||
sendPendingBRs();
|
||||
|
||||
element.parent = currentNode;
|
||||
element.returnPoint = returnPoint;
|
||||
returnPoint = 0;
|
||||
|
||||
if ( element.isEmpty )
|
||||
addElement( element );
|
||||
else
|
||||
currentNode = element;
|
||||
};
|
||||
|
||||
parser.onTagClose = function( tagName )
|
||||
{
|
||||
// Check if there is any pending tag to be closed.
|
||||
for ( var i = pendingInline.length - 1 ; i >= 0 ; i-- )
|
||||
{
|
||||
// If found, just remove it from the list.
|
||||
if ( tagName == pendingInline[ i ].name )
|
||||
{
|
||||
pendingInline.splice( i, 1 );
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
var pendingAdd = [],
|
||||
newPendingInline = [],
|
||||
candidate = currentNode;
|
||||
|
||||
while ( candidate.type && candidate.name != tagName )
|
||||
{
|
||||
// If this is an inline element, add it to the pending list, if we're
|
||||
// really closing one of the parents element later, they will continue
|
||||
// after it.
|
||||
if ( !candidate._.isBlockLike )
|
||||
newPendingInline.unshift( candidate );
|
||||
|
||||
// This node should be added to it's parent at this point. But,
|
||||
// it should happen only if the closing tag is really closing
|
||||
// one of the nodes. So, for now, we just cache it.
|
||||
pendingAdd.push( candidate );
|
||||
|
||||
candidate = candidate.parent;
|
||||
}
|
||||
|
||||
if ( candidate.type )
|
||||
{
|
||||
// Add all elements that have been found in the above loop.
|
||||
for ( i = 0 ; i < pendingAdd.length ; i++ )
|
||||
{
|
||||
var node = pendingAdd[ i ];
|
||||
addElement( node, node.parent );
|
||||
}
|
||||
|
||||
currentNode = candidate;
|
||||
|
||||
if ( currentNode.name == 'pre' )
|
||||
inPre = false;
|
||||
|
||||
if ( candidate._.isBlockLike )
|
||||
sendPendingBRs();
|
||||
|
||||
addElement( candidate, candidate.parent );
|
||||
|
||||
// The parent should start receiving new nodes now, except if
|
||||
// addElement changed the currentNode.
|
||||
if ( candidate == currentNode )
|
||||
currentNode = currentNode.parent;
|
||||
|
||||
pendingInline = pendingInline.concat( newPendingInline );
|
||||
}
|
||||
|
||||
if ( tagName == 'body' )
|
||||
fixForBody = false;
|
||||
};
|
||||
|
||||
parser.onText = function( text )
|
||||
{
|
||||
// Trim empty spaces at beginning of element contents except <pre>.
|
||||
if ( !currentNode._.hasInlineStarted && !inPre )
|
||||
{
|
||||
text = CKEDITOR.tools.ltrim( text );
|
||||
|
||||
if ( text.length === 0 )
|
||||
return;
|
||||
}
|
||||
|
||||
sendPendingBRs();
|
||||
checkPending();
|
||||
|
||||
if ( fixForBody
|
||||
&& ( !currentNode.type || currentNode.name == 'body' )
|
||||
&& CKEDITOR.tools.trim( text ) )
|
||||
{
|
||||
this.onTagOpen( fixForBody, {} );
|
||||
}
|
||||
|
||||
// Shrinking consequential spaces into one single for all elements
|
||||
// text contents.
|
||||
if ( !inPre )
|
||||
text = text.replace( /[\t\r\n ]{2,}|[\t\r\n]/g, ' ' );
|
||||
|
||||
currentNode.add( new CKEDITOR.htmlParser.text( text ) );
|
||||
};
|
||||
|
||||
parser.onCDATA = function( cdata )
|
||||
{
|
||||
currentNode.add( new CKEDITOR.htmlParser.cdata( cdata ) );
|
||||
};
|
||||
|
||||
parser.onComment = function( comment )
|
||||
{
|
||||
currentNode.add( new CKEDITOR.htmlParser.comment( comment ) );
|
||||
};
|
||||
|
||||
// Parse it.
|
||||
parser.parse( fragmentHtml );
|
||||
|
||||
// Send all pending BRs except one, which we consider a unwanted bogus. (#5293)
|
||||
sendPendingBRs( !CKEDITOR.env.ie && 1 );
|
||||
|
||||
// Close all pending nodes.
|
||||
while ( currentNode.type )
|
||||
{
|
||||
var parent = currentNode.parent,
|
||||
node = currentNode;
|
||||
|
||||
if ( fixForBody
|
||||
&& ( !parent.type || parent.name == 'body' )
|
||||
&& !CKEDITOR.dtd.$body[ node.name ] )
|
||||
{
|
||||
currentNode = parent;
|
||||
parser.onTagOpen( fixForBody, {} );
|
||||
parent = currentNode;
|
||||
}
|
||||
|
||||
parent.add( node );
|
||||
currentNode = parent;
|
||||
}
|
||||
|
||||
return fragment;
|
||||
};
|
||||
|
||||
CKEDITOR.htmlParser.fragment.prototype =
|
||||
{
|
||||
/**
|
||||
* Adds a node to this fragment.
|
||||
* @param {Object} node The node to be added. It can be any of of the
|
||||
* following types: {@link CKEDITOR.htmlParser.element},
|
||||
* {@link CKEDITOR.htmlParser.text} and
|
||||
* {@link CKEDITOR.htmlParser.comment}.
|
||||
* @example
|
||||
*/
|
||||
add : function( node )
|
||||
{
|
||||
var len = this.children.length,
|
||||
previous = len > 0 && this.children[ len - 1 ] || null;
|
||||
|
||||
if ( previous )
|
||||
{
|
||||
// If the block to be appended is following text, trim spaces at
|
||||
// the right of it.
|
||||
if ( node._.isBlockLike && previous.type == CKEDITOR.NODE_TEXT )
|
||||
{
|
||||
previous.value = CKEDITOR.tools.rtrim( previous.value );
|
||||
|
||||
// If we have completely cleared the previous node.
|
||||
if ( previous.value.length === 0 )
|
||||
{
|
||||
// Remove it from the list and add the node again.
|
||||
this.children.pop();
|
||||
this.add( node );
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
previous.next = node;
|
||||
}
|
||||
|
||||
node.previous = previous;
|
||||
node.parent = this;
|
||||
|
||||
this.children.push( node );
|
||||
|
||||
this._.hasInlineStarted = node.type == CKEDITOR.NODE_TEXT || ( node.type == CKEDITOR.NODE_ELEMENT && !node._.isBlockLike );
|
||||
},
|
||||
|
||||
/**
|
||||
* Writes the fragment HTML to a CKEDITOR.htmlWriter.
|
||||
* @param {CKEDITOR.htmlWriter} writer The writer to which write the HTML.
|
||||
* @example
|
||||
* var writer = new CKEDITOR.htmlWriter();
|
||||
* var fragment = CKEDITOR.htmlParser.fragment.fromHtml( '<P><B>Example' );
|
||||
* fragment.writeHtml( writer )
|
||||
* alert( writer.getHtml() ); "<p><b>Example</b></p>"
|
||||
*/
|
||||
writeHtml : function( writer, filter )
|
||||
{
|
||||
var isChildrenFiltered;
|
||||
this.filterChildren = function()
|
||||
{
|
||||
var writer = new CKEDITOR.htmlParser.basicWriter();
|
||||
this.writeChildrenHtml.call( this, writer, filter, true );
|
||||
var html = writer.getHtml();
|
||||
this.children = new CKEDITOR.htmlParser.fragment.fromHtml( html ).children;
|
||||
isChildrenFiltered = 1;
|
||||
};
|
||||
|
||||
// Filtering the root fragment before anything else.
|
||||
!this.name && filter && filter.onFragment( this );
|
||||
|
||||
this.writeChildrenHtml( writer, isChildrenFiltered ? null : filter );
|
||||
},
|
||||
|
||||
writeChildrenHtml : function( writer, filter )
|
||||
{
|
||||
for ( var i = 0 ; i < this.children.length ; i++ )
|
||||
this.children[i].writeHtml( writer, filter );
|
||||
}
|
||||
};
|
||||
})();
|
||||
55
ckeditor/_source/core/htmlparser/text.js
Normal file
55
ckeditor/_source/core/htmlparser/text.js
Normal file
@@ -0,0 +1,55 @@
|
||||
/*
|
||||
Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
|
||||
For licensing, see LICENSE.html or http://ckeditor.com/license
|
||||
*/
|
||||
|
||||
(function()
|
||||
{
|
||||
var spacesRegex = /[\t\r\n ]{2,}|[\t\r\n]/g;
|
||||
|
||||
/**
|
||||
* A lightweight representation of HTML text.
|
||||
* @constructor
|
||||
* @example
|
||||
*/
|
||||
CKEDITOR.htmlParser.text = function( value )
|
||||
{
|
||||
/**
|
||||
* The text value.
|
||||
* @type String
|
||||
* @example
|
||||
*/
|
||||
this.value = value;
|
||||
|
||||
/** @private */
|
||||
this._ =
|
||||
{
|
||||
isBlockLike : false
|
||||
};
|
||||
};
|
||||
|
||||
CKEDITOR.htmlParser.text.prototype =
|
||||
{
|
||||
/**
|
||||
* The node type. This is a constant value set to {@link CKEDITOR.NODE_TEXT}.
|
||||
* @type Number
|
||||
* @example
|
||||
*/
|
||||
type : CKEDITOR.NODE_TEXT,
|
||||
|
||||
/**
|
||||
* Writes the HTML representation of this text to a CKEDITOR.htmlWriter.
|
||||
* @param {CKEDITOR.htmlWriter} writer The writer to which write the HTML.
|
||||
* @example
|
||||
*/
|
||||
writeHtml : function( writer, filter )
|
||||
{
|
||||
var text = this.value;
|
||||
|
||||
if ( filter && !( text = filter.onText( text, this ) ) )
|
||||
return;
|
||||
|
||||
writer.text( text );
|
||||
}
|
||||
};
|
||||
})();
|
||||
Reference in New Issue
Block a user