diff options
Diffstat (limited to 'rt/share/html/NoAuth/RichText/FCKeditor/editor/_source/classes/fckstyle.js')
| -rw-r--r-- | rt/share/html/NoAuth/RichText/FCKeditor/editor/_source/classes/fckstyle.js | 1500 |
1 files changed, 1500 insertions, 0 deletions
diff --git a/rt/share/html/NoAuth/RichText/FCKeditor/editor/_source/classes/fckstyle.js b/rt/share/html/NoAuth/RichText/FCKeditor/editor/_source/classes/fckstyle.js new file mode 100644 index 0000000..540f70e --- /dev/null +++ b/rt/share/html/NoAuth/RichText/FCKeditor/editor/_source/classes/fckstyle.js @@ -0,0 +1,1500 @@ +/*
+ * FCKeditor - The text editor for Internet - http://www.fckeditor.net
+ * Copyright (C) 2003-2009 Frederico Caldeira Knabben
+ *
+ * == BEGIN LICENSE ==
+ *
+ * Licensed under the terms of any of the following licenses at your
+ * choice:
+ *
+ * - GNU General Public License Version 2 or later (the "GPL")
+ * http://www.gnu.org/licenses/gpl.html
+ *
+ * - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * - Mozilla Public License Version 1.1 or later (the "MPL")
+ * http://www.mozilla.org/MPL/MPL-1.1.html
+ *
+ * == END LICENSE ==
+ *
+ * FCKStyle Class: contains a style definition, and all methods to work with
+ * the style in a document.
+ */
+
+/**
+ * @param {Object} styleDesc A "style descriptor" object, containing the raw
+ * style definition in the following format:
+ * '<style name>' : {
+ * Element : '<element name>',
+ * Attributes : {
+ * '<att name>' : '<att value>',
+ * ...
+ * },
+ * Styles : {
+ * '<style name>' : '<style value>',
+ * ...
+ * },
+ * Overrides : '<element name>'|{
+ * Element : '<element name>',
+ * Attributes : {
+ * '<att name>' : '<att value>'|/<att regex>/
+ * },
+ * Styles : {
+ * '<style name>' : '<style value>'|/<style regex>/
+ * },
+ * }
+ * }
+ */
+var FCKStyle = function( styleDesc )
+{
+ this.Element = ( styleDesc.Element || 'span' ).toLowerCase() ;
+ this._StyleDesc = styleDesc ;
+}
+
+FCKStyle.prototype =
+{
+ /**
+ * Get the style type, based on its element name:
+ * - FCK_STYLE_BLOCK (0): Block Style
+ * - FCK_STYLE_INLINE (1): Inline Style
+ * - FCK_STYLE_OBJECT (2): Object Style
+ */
+ GetType : function()
+ {
+ var type = this.GetType_$ ;
+
+ if ( type != undefined )
+ return type ;
+
+ var elementName = this.Element ;
+
+ if ( elementName == '#' || FCKListsLib.StyleBlockElements[ elementName ] )
+ type = FCK_STYLE_BLOCK ;
+ else if ( FCKListsLib.StyleObjectElements[ elementName ] )
+ type = FCK_STYLE_OBJECT ;
+ else
+ type = FCK_STYLE_INLINE ;
+
+ return ( this.GetType_$ = type ) ;
+ },
+
+ /**
+ * Apply the style to the current selection.
+ */
+ ApplyToSelection : function( targetWindow )
+ {
+ // Create a range for the current selection.
+ var range = new FCKDomRange( targetWindow ) ;
+ range.MoveToSelection() ;
+
+ this.ApplyToRange( range, true ) ;
+ },
+
+ /**
+ * Apply the style to a FCKDomRange.
+ */
+ ApplyToRange : function( range, selectIt, updateRange )
+ {
+ // ApplyToRange is not valid for FCK_STYLE_OBJECT types.
+ // Use ApplyToObject instead.
+
+ switch ( this.GetType() )
+ {
+ case FCK_STYLE_BLOCK :
+ this.ApplyToRange = this._ApplyBlockStyle ;
+ break ;
+ case FCK_STYLE_INLINE :
+ this.ApplyToRange = this._ApplyInlineStyle ;
+ break ;
+ default :
+ return ;
+ }
+
+ this.ApplyToRange( range, selectIt, updateRange ) ;
+ },
+
+ /**
+ * Apply the style to an object. Valid for FCK_STYLE_BLOCK types only.
+ */
+ ApplyToObject : function( objectElement )
+ {
+ if ( !objectElement )
+ return ;
+
+ this.BuildElement( null, objectElement ) ;
+ },
+
+ /**
+ * Remove the style from the current selection.
+ */
+ RemoveFromSelection : function( targetWindow )
+ {
+ // Create a range for the current selection.
+ var range = new FCKDomRange( targetWindow ) ;
+ range.MoveToSelection() ;
+
+ this.RemoveFromRange( range, true ) ;
+ },
+
+ /**
+ * Remove the style from a FCKDomRange. Block type styles will have no
+ * effect.
+ */
+ RemoveFromRange : function( range, selectIt, updateRange )
+ {
+ var bookmark ;
+
+ // Create the attribute list to be used later for element comparisons.
+ var styleAttribs = this._GetAttribsForComparison() ;
+ var styleOverrides = this._GetOverridesForComparison() ;
+
+ // If collapsed, we are removing all conflicting styles from the range
+ // parent tree.
+ if ( range.CheckIsCollapsed() )
+ {
+ // Bookmark the range so we can re-select it after processing.
+ var bookmark = range.CreateBookmark( true ) ;
+
+ // Let's start from the bookmark <span> parent.
+ var bookmarkStart = range.GetBookmarkNode( bookmark, true ) ;
+
+ var path = new FCKElementPath( bookmarkStart.parentNode ) ;
+
+ // While looping through the path, we'll be saving references to
+ // parent elements if the range is in one of their boundaries. In
+ // this way, we are able to create a copy of those elements when
+ // removing a style if the range is in a boundary limit (see #1270).
+ var boundaryElements = [] ;
+
+ // Check if the range is in the boundary limits of an element
+ // (related to #1270).
+ var isBoundaryRight = !FCKDomTools.GetNextSibling( bookmarkStart ) ;
+ var isBoundary = isBoundaryRight || !FCKDomTools.GetPreviousSibling( bookmarkStart ) ;
+
+ // This is the last element to be removed in the boundary situation
+ // described at #1270.
+ var lastBoundaryElement ;
+ var boundaryLimitIndex = -1 ;
+
+ for ( var i = 0 ; i < path.Elements.length ; i++ )
+ {
+ var pathElement = path.Elements[i] ;
+ if ( this.CheckElementRemovable( pathElement ) )
+ {
+ if ( isBoundary
+ && !FCKDomTools.CheckIsEmptyElement( pathElement,
+ function( el )
+ {
+ return ( el != bookmarkStart ) ;
+ } )
+ )
+ {
+ lastBoundaryElement = pathElement ;
+
+ // We'll be continuously including elements in the
+ // boundaryElements array, but only those added before
+ // setting lastBoundaryElement must be used later, so
+ // let's mark the current index here.
+ boundaryLimitIndex = boundaryElements.length - 1 ;
+ }
+ else
+ {
+ var pathElementName = pathElement.nodeName.toLowerCase() ;
+
+ if ( pathElementName == this.Element )
+ {
+ // Remove any attribute that conflict with this style, no
+ // matter their values.
+ for ( var att in styleAttribs )
+ {
+ if ( FCKDomTools.HasAttribute( pathElement, att ) )
+ {
+ switch ( att )
+ {
+ case 'style' :
+ this._RemoveStylesFromElement( pathElement ) ;
+ break ;
+
+ case 'class' :
+ // The 'class' element value must match (#1318).
+ if ( FCKDomTools.GetAttributeValue( pathElement, att ) != this.GetFinalAttributeValue( att ) )
+ continue ;
+
+ /*jsl:fallthru*/
+
+ default :
+ FCKDomTools.RemoveAttribute( pathElement, att ) ;
+ }
+ }
+ }
+ }
+
+ // Remove overrides defined to the same element name.
+ this._RemoveOverrides( pathElement, styleOverrides[ pathElementName ] ) ;
+
+ // Remove the element if no more attributes are available and it's an inline style element
+ if ( this.GetType() == FCK_STYLE_INLINE)
+ this._RemoveNoAttribElement( pathElement ) ;
+ }
+ }
+ else if ( isBoundary )
+ boundaryElements.push( pathElement ) ;
+
+ // Check if we are still in a boundary (at the same side).
+ isBoundary = isBoundary && ( ( isBoundaryRight && !FCKDomTools.GetNextSibling( pathElement ) ) || ( !isBoundaryRight && !FCKDomTools.GetPreviousSibling( pathElement ) ) ) ;
+
+ // If we are in an element that is not anymore a boundary, or
+ // we are at the last element, let's move things outside the
+ // boundary (if available).
+ if ( lastBoundaryElement && ( !isBoundary || ( i == path.Elements.length - 1 ) ) )
+ {
+ // Remove the bookmark node from the DOM.
+ var currentElement = FCKDomTools.RemoveNode( bookmarkStart ) ;
+
+ // Build the collapsed group of elements that are not
+ // removed by this style, but share the boundary.
+ // (see comment 1 and 2 at #1270)
+ for ( var j = 0 ; j <= boundaryLimitIndex ; j++ )
+ {
+ var newElement = FCKDomTools.CloneElement( boundaryElements[j] ) ;
+ newElement.appendChild( currentElement ) ;
+ currentElement = newElement ;
+ }
+
+ // Re-insert the bookmark node (and the collapsed elements)
+ // in the DOM, in the new position next to the styled element.
+ if ( isBoundaryRight )
+ FCKDomTools.InsertAfterNode( lastBoundaryElement, currentElement ) ;
+ else
+ lastBoundaryElement.parentNode.insertBefore( currentElement, lastBoundaryElement ) ;
+
+ isBoundary = false ;
+ lastBoundaryElement = null ;
+ }
+ }
+
+ // Re-select the original range.
+ if ( selectIt )
+ range.SelectBookmark( bookmark ) ;
+
+ if ( updateRange )
+ range.MoveToBookmark( bookmark ) ;
+
+ return ;
+ }
+
+ // Expand the range, if inside inline element boundaries.
+ range.Expand( 'inline_elements' ) ;
+
+ // Bookmark the range so we can re-select it after processing.
+ bookmark = range.CreateBookmark( true ) ;
+
+ // The style will be applied within the bookmark boundaries.
+ var startNode = range.GetBookmarkNode( bookmark, true ) ;
+ var endNode = range.GetBookmarkNode( bookmark, false ) ;
+
+ range.Release( true ) ;
+
+ // We need to check the selection boundaries (bookmark spans) to break
+ // the code in a way that we can properly remove partially selected nodes.
+ // For example, removing a <b> style from
+ // <b>This is [some text</b> to show <b>the] problem</b>
+ // ... where [ and ] represent the selection, must result:
+ // <b>This is </b>[some text to show the]<b> problem</b>
+ // The strategy is simple, we just break the partial nodes before the
+ // removal logic, having something that could be represented this way:
+ // <b>This is </b>[<b>some text</b> to show <b>the</b>]<b> problem</b>
+
+ // Let's start checking the start boundary.
+ var path = new FCKElementPath( startNode ) ;
+ var pathElements = path.Elements ;
+ var pathElement ;
+
+ for ( var i = 1 ; i < pathElements.length ; i++ )
+ {
+ pathElement = pathElements[i] ;
+
+ if ( pathElement == path.Block || pathElement == path.BlockLimit )
+ break ;
+
+ // If this element can be removed (even partially).
+ if ( this.CheckElementRemovable( pathElement ) )
+ FCKDomTools.BreakParent( startNode, pathElement, range ) ;
+ }
+
+ // Now the end boundary.
+ path = new FCKElementPath( endNode ) ;
+ pathElements = path.Elements ;
+
+ for ( var i = 1 ; i < pathElements.length ; i++ )
+ {
+ pathElement = pathElements[i] ;
+
+ if ( pathElement == path.Block || pathElement == path.BlockLimit )
+ break ;
+
+ elementName = pathElement.nodeName.toLowerCase() ;
+
+ // If this element can be removed (even partially).
+ if ( this.CheckElementRemovable( pathElement ) )
+ FCKDomTools.BreakParent( endNode, pathElement, range ) ;
+ }
+
+ // Navigate through all nodes between the bookmarks.
+ var currentNode = FCKDomTools.GetNextSourceNode( startNode, true ) ;
+
+ while ( currentNode )
+ {
+ // Cache the next node to be processed. Do it now, because
+ // currentNode may be removed.
+ var nextNode = FCKDomTools.GetNextSourceNode( currentNode ) ;
+
+ // Remove elements nodes that match with this style rules.
+ if ( currentNode.nodeType == 1 )
+ {
+ var elementName = currentNode.nodeName.toLowerCase() ;
+
+ var mayRemove = ( elementName == this.Element ) ;
+ if ( mayRemove )
+ {
+ // Remove any attribute that conflict with this style, no matter
+ // their values.
+ for ( var att in styleAttribs )
+ {
+ if ( FCKDomTools.HasAttribute( currentNode, att ) )
+ {
+ switch ( att )
+ {
+ case 'style' :
+ this._RemoveStylesFromElement( currentNode ) ;
+ break ;
+
+ case 'class' :
+ // The 'class' element value must match (#1318).
+ if ( FCKDomTools.GetAttributeValue( currentNode, att ) != this.GetFinalAttributeValue( att ) )
+ continue ;
+
+ /*jsl:fallthru*/
+
+ default :
+ FCKDomTools.RemoveAttribute( currentNode, att ) ;
+ }
+ }
+ }
+ }
+ else
+ mayRemove = !!styleOverrides[ elementName ] ;
+
+ if ( mayRemove )
+ {
+ // Remove overrides defined to the same element name.
+ this._RemoveOverrides( currentNode, styleOverrides[ elementName ] ) ;
+
+ // Remove the element if no more attributes are available.
+ this._RemoveNoAttribElement( currentNode ) ;
+ }
+ }
+
+ // If we have reached the end of the selection, stop looping.
+ if ( nextNode == endNode )
+ break ;
+
+ currentNode = nextNode ;
+ }
+
+ this._FixBookmarkStart( startNode ) ;
+
+ // Re-select the original range.
+ if ( selectIt )
+ range.SelectBookmark( bookmark ) ;
+
+ if ( updateRange )
+ range.MoveToBookmark( bookmark ) ;
+ },
+
+ /**
+ * Checks if an element, or any of its attributes, is removable by the
+ * current style definition.
+ */
+ CheckElementRemovable : function( element, fullMatch )
+ {
+ if ( !element )
+ return false ;
+
+ var elementName = element.nodeName.toLowerCase() ;
+
+ // If the element name is the same as the style name.
+ if ( elementName == this.Element )
+ {
+ // If no attributes are defined in the element.
+ if ( !fullMatch && !FCKDomTools.HasAttributes( element ) )
+ return true ;
+
+ // If any attribute conflicts with the style attributes.
+ var attribs = this._GetAttribsForComparison() ;
+ var allMatched = ( attribs._length == 0 ) ;
+ for ( var att in attribs )
+ {
+ if ( att == '_length' )
+ continue ;
+
+ if ( this._CompareAttributeValues( att, FCKDomTools.GetAttributeValue( element, att ), ( this.GetFinalAttributeValue( att ) || '' ) ) )
+ {
+ allMatched = true ;
+ if ( !fullMatch )
+ break ;
+ }
+ else
+ {
+ allMatched = false ;
+ if ( fullMatch )
+ return false ;
+ }
+ }
+ if ( allMatched )
+ return true ;
+ }
+
+ // Check if the element can be somehow overriden.
+ var override = this._GetOverridesForComparison()[ elementName ] ;
+ if ( override )
+ {
+ // If no attributes have been defined, remove the element.
+ if ( !( attribs = override.Attributes ) ) // Only one "="
+ return true ;
+
+ for ( var i = 0 ; i < attribs.length ; i++ )
+ {
+ var attName = attribs[i][0] ;
+ if ( FCKDomTools.HasAttribute( element, attName ) )
+ {
+ var attValue = attribs[i][1] ;
+
+ // Remove the attribute if:
+ // - The override definition value is null ;
+ // - The override definition valie is a string that
+ // matches the attribute value exactly.
+ // - The override definition value is a regex that
+ // has matches in the attribute value.
+ if ( attValue == null ||
+ ( typeof attValue == 'string' && FCKDomTools.GetAttributeValue( element, attName ) == attValue ) ||
+ attValue.test( FCKDomTools.GetAttributeValue( element, attName ) ) )
+ return true ;
+ }
+ }
+ }
+
+ return false ;
+ },
+
+ /**
+ * Get the style state for an element path. Returns "true" if the element
+ * is active in the path.
+ */
+ CheckActive : function( elementPath )
+ {
+ switch ( this.GetType() )
+ {
+ case FCK_STYLE_BLOCK :
+ return this.CheckElementRemovable( elementPath.Block || elementPath.BlockLimit, true ) ;
+
+ case FCK_STYLE_INLINE :
+
+ var elements = elementPath.Elements ;
+
+ for ( var i = 0 ; i < elements.length ; i++ )
+ {
+ var element = elements[i] ;
+
+ if ( element == elementPath.Block || element == elementPath.BlockLimit )
+ continue ;
+
+ if ( this.CheckElementRemovable( element, true ) )
+ return true ;
+ }
+ }
+ return false ;
+ },
+
+ /**
+ * Removes an inline style from inside an element tree. The element node
+ * itself is not checked or removed, only the child tree inside of it.
+ */
+ RemoveFromElement : function( element )
+ {
+ var attribs = this._GetAttribsForComparison() ;
+ var overrides = this._GetOverridesForComparison() ;
+
+ // Get all elements with the same name.
+ var innerElements = element.getElementsByTagName( this.Element ) ;
+
+ for ( var i = innerElements.length - 1 ; i >= 0 ; i-- )
+ {
+ var innerElement = innerElements[i] ;
+
+ // Remove any attribute that conflict with this style, no matter
+ // their values.
+ for ( var att in attribs )
+ {
+ if ( FCKDomTools.HasAttribute( innerElement, att ) )
+ {
+ switch ( att )
+ {
+ case 'style' :
+ this._RemoveStylesFromElement( innerElement ) ;
+ break ;
+
+ case 'class' :
+ // The 'class' element value must match (#1318).
+ if ( FCKDomTools.GetAttributeValue( innerElement, att ) != this.GetFinalAttributeValue( att ) )
+ continue ;
+
+ /*jsl:fallthru*/
+
+ default :
+ FCKDomTools.RemoveAttribute( innerElement, att ) ;
+ }
+ }
+ }
+
+ // Remove overrides defined to the same element name.
+ this._RemoveOverrides( innerElement, overrides[ this.Element ] ) ;
+
+ // Remove the element if no more attributes are available.
+ this._RemoveNoAttribElement( innerElement ) ;
+ }
+
+ // Now remove any other element with different name that is
+ // defined to be overriden.
+ for ( var overrideElement in overrides )
+ {
+ if ( overrideElement != this.Element )
+ {
+ // Get all elements.
+ innerElements = element.getElementsByTagName( overrideElement ) ;
+
+ for ( var i = innerElements.length - 1 ; i >= 0 ; i-- )
+ {
+ var innerElement = innerElements[i] ;
+ this._RemoveOverrides( innerElement, overrides[ overrideElement ] ) ;
+ this._RemoveNoAttribElement( innerElement ) ;
+ }
+ }
+ }
+ },
+
+ _RemoveStylesFromElement : function( element )
+ {
+ var elementStyle = element.style.cssText ;
+ var pattern = this.GetFinalStyleValue() ;
+
+ if ( elementStyle.length > 0 && pattern.length == 0 )
+ return ;
+
+ pattern = '(^|;)\\s*(' +
+ pattern.replace( /\s*([^ ]+):.*?(;|$)/g, '$1|' ).replace( /\|$/, '' ) +
+ '):[^;]+' ;
+
+ var regex = new RegExp( pattern, 'gi' ) ;
+
+ elementStyle = elementStyle.replace( regex, '' ).Trim() ;
+
+ if ( elementStyle.length == 0 || elementStyle == ';' )
+ FCKDomTools.RemoveAttribute( element, 'style' ) ;
+ else
+ element.style.cssText = elementStyle.replace( regex, '' ) ;
+ },
+
+ /**
+ * Remove all attributes that are defined to be overriden,
+ */
+ _RemoveOverrides : function( element, override )
+ {
+ var attributes = override && override.Attributes ;
+
+ if ( attributes )
+ {
+ for ( var i = 0 ; i < attributes.length ; i++ )
+ {
+ var attName = attributes[i][0] ;
+
+ if ( FCKDomTools.HasAttribute( element, attName ) )
+ {
+ var attValue = attributes[i][1] ;
+
+ // Remove the attribute if:
+ // - The override definition value is null ;
+ // - The override definition valie is a string that
+ // matches the attribute value exactly.
+ // - The override definition value is a regex that
+ // has matches in the attribute value.
+ if ( attValue == null ||
+ ( attValue.test && attValue.test( FCKDomTools.GetAttributeValue( element, attName ) ) ) ||
+ ( typeof attValue == 'string' && FCKDomTools.GetAttributeValue( element, attName ) == attValue ) )
+ FCKDomTools.RemoveAttribute( element, attName ) ;
+ }
+ }
+ }
+ },
+
+ /**
+ * If the element has no more attributes, remove it.
+ */
+ _RemoveNoAttribElement : function( element )
+ {
+ // If no more attributes remained in the element, remove it,
+ // leaving its children.
+ if ( !FCKDomTools.HasAttributes( element ) )
+ {
+ // Removing elements may open points where merging is possible,
+ // so let's cache the first and last nodes for later checking.
+ var firstChild = element.firstChild ;
+ var lastChild = element.lastChild ;
+
+ FCKDomTools.RemoveNode( element, true ) ;
+
+ // Check the cached nodes for merging.
+ this._MergeSiblings( firstChild ) ;
+
+ if ( firstChild != lastChild )
+ this._MergeSiblings( lastChild ) ;
+ }
+ },
+
+ /**
+ * Creates a DOM element for this style object.
+ */
+ BuildElement : function( targetDoc, element )
+ {
+ // Create the element.
+ var el = element || targetDoc.createElement( this.Element ) ;
+
+ // Assign all defined attributes.
+ var attribs = this._StyleDesc.Attributes ;
+ var attValue ;
+ if ( attribs )
+ {
+ for ( var att in attribs )
+ {
+ attValue = this.GetFinalAttributeValue( att ) ;
+
+ if ( att.toLowerCase() == 'class' )
+ el.className = attValue ;
+ else
+ el.setAttribute( att, attValue ) ;
+ }
+ }
+
+ // Assign the style attribute.
+ if ( this._GetStyleText().length > 0 )
+ el.style.cssText = this.GetFinalStyleValue() ;
+
+ return el ;
+ },
+
+ _CompareAttributeValues : function( attName, valueA, valueB )
+ {
+ if ( attName == 'style' && valueA && valueB )
+ {
+ valueA = valueA.replace( /;$/, '' ).toLowerCase() ;
+ valueB = valueB.replace( /;$/, '' ).toLowerCase() ;
+ }
+
+ // Return true if they match or if valueA is null and valueB is an empty string
+ return ( valueA == valueB || ( ( valueA === null || valueA === '' ) && ( valueB === null || valueB === '' ) ) )
+ },
+
+ GetFinalAttributeValue : function( attName )
+ {
+ var attValue = this._StyleDesc.Attributes ;
+ var attValue = attValue ? attValue[ attName ] : null ;
+
+ if ( !attValue && attName == 'style' )
+ return this.GetFinalStyleValue() ;
+
+ if ( attValue && this._Variables )
+ // Using custom Replace() to guarantee the correct scope.
+ attValue = attValue.Replace( FCKRegexLib.StyleVariableAttName, this._GetVariableReplace, this ) ;
+
+ return attValue ;
+ },
+
+ GetFinalStyleValue : function()
+ {
+ var attValue = this._GetStyleText() ;
+
+ if ( attValue.length > 0 && this._Variables )
+ {
+ // Using custom Replace() to guarantee the correct scope.
+ attValue = attValue.Replace( FCKRegexLib.StyleVariableAttName, this._GetVariableReplace, this ) ;
+ attValue = FCKTools.NormalizeCssText( attValue ) ;
+ }
+
+ return attValue ;
+ },
+
+ _GetVariableReplace : function()
+ {
+ // The second group in the regex is the variable name.
+ return this._Variables[ arguments[2] ] || arguments[0] ;
+ },
+
+ /**
+ * Set the value of a variable attribute or style, to be used when
+ * appliying the style.
+ */
+ SetVariable : function( name, value )
+ {
+ var variables = this._Variables ;
+
+ if ( !variables )
+ variables = this._Variables = {} ;
+
+ this._Variables[ name ] = value ;
+ },
+
+ /**
+ * Converting from a PRE block to a non-PRE block in formatting operations.
+ */
+ _FromPre : function( doc, block, newBlock )
+ {
+ var innerHTML = block.innerHTML ;
+
+ // Trim the first and last linebreaks immediately after and before <pre>, </pre>,
+ // if they exist.
+ // This is done because the linebreaks are not rendered.
+ innerHTML = innerHTML.replace( /(\r\n|\r)/g, '\n' ) ;
+ innerHTML = innerHTML.replace( /^[ \t]*\n/, '' ) ;
+ innerHTML = innerHTML.replace( /\n$/, '' ) ;
+
+ // 1. Convert spaces or tabs at the beginning or at the end to
+ innerHTML = innerHTML.replace( /^[ \t]+|[ \t]+$/g, function( match, offset, s )
+ {
+ if ( match.length == 1 ) // one space, preserve it
+ return ' ' ;
+ else if ( offset == 0 ) // beginning of block
+ return new Array( match.length ).join( ' ' ) + ' ' ;
+ else // end of block
+ return ' ' + new Array( match.length ).join( ' ' ) ;
+ } ) ;
+
+ // 2. Convert \n to <BR>.
+ // 3. Convert contiguous (i.e. non-singular) spaces or tabs to
+ var htmlIterator = new FCKHtmlIterator( innerHTML ) ;
+ var results = [] ;
+ htmlIterator.Each( function( isTag, value )
+ {
+ if ( !isTag )
+ {
+ value = value.replace( /\n/g, '<br>' ) ;
+ value = value.replace( /[ \t]{2,}/g,
+ function ( match )
+ {
+ return new Array( match.length ).join( ' ' ) + ' ' ;
+ } ) ;
+ }
+ results.push( value ) ;
+ } ) ;
+ newBlock.innerHTML = results.join( '' ) ;
+ return newBlock ;
+ },
+
+ /**
+ * Converting from a non-PRE block to a PRE block in formatting operations.
+ */
+ _ToPre : function( doc, block, newBlock )
+ {
+ // Handle converting from a regular block to a <pre> block.
+ var innerHTML = block.innerHTML.Trim() ;
+
+ // 1. Delete ANSI whitespaces immediately before and after <BR> because
+ // they are not visible.
+ // 2. Mark down any <BR /> nodes here so they can be turned into \n in
+ // the next step and avoid being compressed.
+ innerHTML = innerHTML.replace( /[ \t\r\n]*(<br[^>]*>)[ \t\r\n]*/gi, '<br />' ) ;
+
+ // 3. Compress other ANSI whitespaces since they're only visible as one
+ // single space previously.
+ // 4. Convert to spaces since is no longer needed in <PRE>.
+ // 5. Convert any <BR /> to \n. This must not be done earlier because
+ // the \n would then get compressed.
+ var htmlIterator = new FCKHtmlIterator( innerHTML ) ;
+ var results = [] ;
+ htmlIterator.Each( function( isTag, value )
+ {
+ if ( !isTag )
+ value = value.replace( /([ \t\n\r]+| )/g, ' ' ) ;
+ else if ( isTag && value == '<br />' )
+ value = '\n' ;
+ results.push( value ) ;
+ } ) ;
+
+ // Assigning innerHTML to <PRE> in IE causes all linebreaks to be
+ // reduced to spaces.
+ // Assigning outerHTML to <PRE> in IE doesn't work if the <PRE> isn't
+ // contained in another node since the node reference is changed after
+ // outerHTML assignment.
+ // So, we need some hacks to workaround IE bugs here.
+ if ( FCKBrowserInfo.IsIE )
+ {
+ var temp = doc.createElement( 'div' ) ;
+ temp.appendChild( newBlock ) ;
+ newBlock.outerHTML = '<pre>\n' + results.join( '' ) + '</pre>' ;
+ newBlock = temp.removeChild( temp.firstChild ) ;
+ }
+ else
+ newBlock.innerHTML = results.join( '' ) ;
+
+ return newBlock ;
+ },
+
+ /**
+ * Merge a <pre> block with a previous <pre> block, if available.
+ */
+ _CheckAndMergePre : function( previousBlock, preBlock )
+ {
+ // Check if the previous block and the current block are next
+ // to each other.
+ if ( previousBlock != FCKDomTools.GetPreviousSourceElement( preBlock, true ) )
+ return ;
+
+ // Merge the previous <pre> block contents into the current <pre>
+ // block.
+ //
+ // Another thing to be careful here is that currentBlock might contain
+ // a '\n' at the beginning, and previousBlock might contain a '\n'
+ // towards the end. These new lines are not normally displayed but they
+ // become visible after merging.
+ var innerHTML = previousBlock.innerHTML.replace( /\n$/, '' ) + '\n\n' +
+ preBlock.innerHTML.replace( /^\n/, '' ) ;
+
+ // Buggy IE normalizes innerHTML from <pre>, breaking whitespaces.
+ if ( FCKBrowserInfo.IsIE )
+ preBlock.outerHTML = '<pre>' + innerHTML + '</pre>' ;
+ else
+ preBlock.innerHTML = innerHTML ;
+
+ // Remove the previous <pre> block.
+ //
+ // The preBlock must not be moved or deleted from the DOM tree. This
+ // guarantees the FCKDomRangeIterator in _ApplyBlockStyle would not
+ // get lost at the next iteration.
+ FCKDomTools.RemoveNode( previousBlock ) ;
+ },
+
+ _CheckAndSplitPre : function( newBlock )
+ {
+ var lastNewBlock ;
+
+ var cursor = newBlock.firstChild ;
+
+ // We are not splitting <br><br> at the beginning of the block, so
+ // we'll start from the second child.
+ cursor = cursor && cursor.nextSibling ;
+
+ while ( cursor )
+ {
+ var next = cursor.nextSibling ;
+
+ // If we have two <BR>s, and they're not at the beginning or the end,
+ // then we'll split up the contents following them into another block.
+ // Stop processing if we are at the last child couple.
+ if ( next && next.nextSibling && cursor.nodeName.IEquals( 'br' ) && next.nodeName.IEquals( 'br' ) )
+ {
+ // Remove the first <br>.
+ FCKDomTools.RemoveNode( cursor ) ;
+
+ // Move to the node after the second <br>.
+ cursor = next.nextSibling ;
+
+ // Remove the second <br>.
+ FCKDomTools.RemoveNode( next ) ;
+
+ // Create the block that will hold the child nodes from now on.
+ lastNewBlock = FCKDomTools.InsertAfterNode( lastNewBlock || newBlock, FCKDomTools.CloneElement( newBlock ) ) ;
+
+ continue ;
+ }
+
+ // If we split it, then start moving the nodes to the new block.
+ if ( lastNewBlock )
+ {
+ cursor = cursor.previousSibling ;
+ FCKDomTools.MoveNode(cursor.nextSibling, lastNewBlock ) ;
+ }
+
+ cursor = cursor.nextSibling ;
+ }
+ },
+
+ /**
+ * Apply an inline style to a FCKDomRange.
+ *
+ * TODO
+ * - Implement the "#" style handling.
+ * - Properly handle block containers like <div> and <blockquote>.
+ */
+ _ApplyBlockStyle : function( range, selectIt, updateRange )
+ {
+ // Bookmark the range so we can re-select it after processing.
+ var bookmark ;
+
+ if ( selectIt )
+ bookmark = range.CreateBookmark() ;
+
+ var iterator = new FCKDomRangeIterator( range ) ;
+ iterator.EnforceRealBlocks = true ;
+
+ var block ;
+ var doc = range.Window.document ;
+ var previousPreBlock ;
+
+ while( ( block = iterator.GetNextParagraph() ) ) // Only one =
+ {
+ // Create the new node right before the current one.
+ var newBlock = this.BuildElement( doc ) ;
+
+ // Check if we are changing from/to <pre>.
+ var newBlockIsPre = newBlock.nodeName.IEquals( 'pre' ) ;
+ var blockIsPre = block.nodeName.IEquals( 'pre' ) ;
+
+ var toPre = newBlockIsPre && !blockIsPre ;
+ var fromPre = !newBlockIsPre && blockIsPre ;
+
+ // Move everything from the current node to the new one.
+ if ( toPre )
+ newBlock = this._ToPre( doc, block, newBlock ) ;
+ else if ( fromPre )
+ newBlock = this._FromPre( doc, block, newBlock ) ;
+ else // Convering from a regular block to another regular block.
+ FCKDomTools.MoveChildren( block, newBlock ) ;
+
+ // Replace the current block.
+ block.parentNode.insertBefore( newBlock, block ) ;
+ FCKDomTools.RemoveNode( block ) ;
+
+ // Complete other tasks after inserting the node in the DOM.
+ if ( newBlockIsPre )
+ {
+ if ( previousPreBlock )
+ this._CheckAndMergePre( previousPreBlock, newBlock ) ; // Merge successive <pre> blocks.
+ previousPreBlock = newBlock ;
+ }
+ else if ( fromPre )
+ this._CheckAndSplitPre( newBlock ) ; // Split <br><br> in successive <pre>s.
+ }
+
+ // Re-select the original range.
+ if ( selectIt )
+ range.SelectBookmark( bookmark ) ;
+
+ if ( updateRange )
+ range.MoveToBookmark( bookmark ) ;
+ },
+
+ /**
+ * Apply an inline style to a FCKDomRange.
+ *
+ * TODO
+ * - Merge elements, when applying styles to similar elements that enclose
+ * the entire selection, outputing:
+ * <span style="color: #ff0000; background-color: #ffffff">XYZ</span>
+ * instead of:
+ * <span style="color: #ff0000;"><span style="background-color: #ffffff">XYZ</span></span>
+ */
+ _ApplyInlineStyle : function( range, selectIt, updateRange )
+ {
+ var doc = range.Window.document ;
+
+ if ( range.CheckIsCollapsed() )
+ {
+ // Create the element to be inserted in the DOM.
+ var collapsedElement = this.BuildElement( doc ) ;
+ range.InsertNode( collapsedElement ) ;
+ range.MoveToPosition( collapsedElement, 2 ) ;
+ range.Select() ;
+
+ return ;
+ }
+
+ // The general idea here is navigating through all nodes inside the
+ // current selection, working on distinct range blocks, defined by the
+ // DTD compatibility between the style element and the nodes inside the
+ // ranges.
+ //
+ // For example, suppose we have the following selection (where [ and ]
+ // are the boundaries), and we apply a <b> style there:
+ //
+ // <p>Here we [have <b>some</b> text.<p>
+ // <p>And some here] here.</p>
+ //
+ // Two different ranges will be detected:
+ //
+ // "have <b>some</b> text."
+ // "And some here"
+ //
+ // Both ranges will be extracted, moved to a <b> element, and
+ // re-inserted, resulting in the following output:
+ //
+ // <p>Here we [<b>have some text.</b><p>
+ // <p><b>And some here</b>] here.</p>
+ //
+ // Note that the <b> element at <b>some</b> is also removed because it
+ // is not needed anymore.
+
+ var elementName = this.Element ;
+
+ // Get the DTD definition for the element. Defaults to "span".
+ var elementDTD = FCK.DTD[ elementName ] || FCK.DTD.span ;
+
+ // Create the attribute list to be used later for element comparisons.
+ var styleAttribs = this._GetAttribsForComparison() ;
+ var styleNode ;
+
+ // Expand the range, if inside inline element boundaries.
+ range.Expand( 'inline_elements' ) ;
+
+ // Bookmark the range so we can re-select it after processing.
+ var bookmark = range.CreateBookmark( true ) ;
+
+ // The style will be applied within the bookmark boundaries.
+ var startNode = range.GetBookmarkNode( bookmark, true ) ;
+ var endNode = range.GetBookmarkNode( bookmark, false ) ;
+
+ // We'll be reusing the range to apply the styles. So, release it here
+ // to indicate that it has not been initialized.
+ range.Release( true ) ;
+
+ // Let's start the nodes lookup from the node right after the bookmark
+ // span.
+ var currentNode = FCKDomTools.GetNextSourceNode( startNode, true ) ;
+
+ while ( currentNode )
+ {
+ var applyStyle = false ;
+
+ var nodeType = currentNode.nodeType ;
+ var nodeName = nodeType == 1 ? currentNode.nodeName.toLowerCase() : null ;
+
+ // Check if the current node can be a child of the style element.
+ if ( !nodeName || elementDTD[ nodeName ] )
+ {
+ // Check if the style element can be a child of the current
+ // node parent or if the element is not defined in the DTD.
+ if ( ( FCK.DTD[ currentNode.parentNode.nodeName.toLowerCase() ] || FCK.DTD.span )[ elementName ] || !FCK.DTD[ elementName ] )
+ {
+ // This node will be part of our range, so if it has not
+ // been started, place its start right before the node.
+ if ( !range.CheckHasRange() )
+ range.SetStart( currentNode, 3 ) ;
+
+ // Non element nodes, or empty elements can be added
+ // completely to the range.
+ if ( nodeType != 1 || currentNode.childNodes.length == 0 )
+ {
+ var includedNode = currentNode ;
+ var parentNode = includedNode.parentNode ;
+
+ // This node is about to be included completelly, but,
+ // if this is the last node in its parent, we must also
+ // check if the parent itself can be added completelly
+ // to the range.
+ while ( includedNode == parentNode.lastChild
+ && elementDTD[ parentNode.nodeName.toLowerCase() ] )
+ {
+ includedNode = parentNode ;
+ }
+
+ range.SetEnd( includedNode, 4 ) ;
+
+ // If the included node is the last node in its parent
+ // and its parent can't be inside the style node, apply
+ // the style immediately.
+ if ( includedNode == includedNode.parentNode.lastChild && !elementDTD[ includedNode.parentNode.nodeName.toLowerCase() ] )
+ applyStyle = true ;
+ }
+ else
+ {
+ // Element nodes will not be added directly. We need to
+ // check their children because the selection could end
+ // inside the node, so let's place the range end right
+ // before the element.
+ range.SetEnd( currentNode, 3 ) ;
+ }
+ }
+ else
+ applyStyle = true ;
+ }
+ else
+ applyStyle = true ;
+
+ // Get the next node to be processed.
+ currentNode = FCKDomTools.GetNextSourceNode( currentNode ) ;
+
+ // If we have reached the end of the selection, just apply the
+ // style ot the range, and stop looping.
+ if ( currentNode == endNode )
+ {
+ currentNode = null ;
+ applyStyle = true ;
+ }
+
+ // Apply the style if we have something to which apply it.
+ if ( applyStyle && range.CheckHasRange() && !range.CheckIsCollapsed() )
+ {
+ // Build the style element, based on the style object definition.
+ styleNode = this.BuildElement( doc ) ;
+
+ // Move the contents of the range to the style element.
+ range.ExtractContents().AppendTo( styleNode ) ;
+
+ // If it is not empty.
+ if ( styleNode.innerHTML.RTrim().length > 0 )
+ {
+ // Insert it in the range position (it is collapsed after
+ // ExtractContents.
+ range.InsertNode( styleNode ) ;
+
+ // Here we do some cleanup, removing all duplicated
+ // elements from the style element.
+ this.RemoveFromElement( styleNode ) ;
+
+ // Let's merge our new style with its neighbors, if possible.
+ this._MergeSiblings( styleNode, this._GetAttribsForComparison() ) ;
+
+ // As the style system breaks text nodes constantly, let's normalize
+ // things for performance.
+ // With IE, some paragraphs get broken when calling normalize()
+ // repeatedly. Also, for IE, we must normalize body, not documentElement.
+ // IE is also known for having a "crash effect" with normalize().
+ // We should try to normalize with IE too in some way, somewhere.
+ if ( !FCKBrowserInfo.IsIE )
+ styleNode.normalize() ;
+ }
+
+ // Style applied, let's release the range, so it gets marked to
+ // re-initialization in the next loop.
+ range.Release( true ) ;
+ }
+ }
+
+ this._FixBookmarkStart( startNode ) ;
+
+ // Re-select the original range.
+ if ( selectIt )
+ range.SelectBookmark( bookmark ) ;
+
+ if ( updateRange )
+ range.MoveToBookmark( bookmark ) ;
+ },
+
+ _FixBookmarkStart : function( startNode )
+ {
+ // After appliying or removing an inline style, the start boundary of
+ // the selection must be placed inside all inline elements it is
+ // bordering.
+ var startSibling ;
+ while ( ( startSibling = startNode.nextSibling ) ) // Only one "=".
+ {
+ if ( startSibling.nodeType == 1
+ && FCKListsLib.InlineNonEmptyElements[ startSibling.nodeName.toLowerCase() ] )
+ {
+ // If it is an empty inline element, we can safely remove it.
+ if ( !startSibling.firstChild )
+ FCKDomTools.RemoveNode( startSibling ) ;
+ else
+ FCKDomTools.MoveNode( startNode, startSibling, true ) ;
+ continue ;
+ }
+
+ // Empty text nodes can be safely removed to not disturb.
+ if ( startSibling.nodeType == 3 && startSibling.length == 0 )
+ {
+ FCKDomTools.RemoveNode( startSibling ) ;
+ continue ;
+ }
+
+ break ;
+ }
+ },
+
+ /**
+ * Merge an element with its similar siblings.
+ * "attribs" is and object computed with _CreateAttribsForComparison.
+ */
+ _MergeSiblings : function( element, attribs )
+ {
+ if ( !element || element.nodeType != 1 || !FCKListsLib.InlineNonEmptyElements[ element.nodeName.toLowerCase() ] )
+ return ;
+
+ this._MergeNextSibling( element, attribs ) ;
+ this._MergePreviousSibling( element, attribs ) ;
+ },
+
+ /**
+ * Merge an element with its similar siblings after it.
+ * "attribs" is and object computed with _CreateAttribsForComparison.
+ */
+ _MergeNextSibling : function( element, attribs )
+ {
+ // Check the next sibling.
+ var sibling = element.nextSibling ;
+
+ // Check if the next sibling is a bookmark element. In this case, jump it.
+ var hasBookmark = ( sibling && sibling.nodeType == 1 && sibling.getAttribute( '_fck_bookmark' ) ) ;
+ if ( hasBookmark )
+ sibling = sibling.nextSibling ;
+
+ if ( sibling && sibling.nodeType == 1 && sibling.nodeName == element.nodeName )
+ {
+ if ( !attribs )
+ attribs = this._CreateElementAttribsForComparison( element ) ;
+
+ if ( this._CheckAttributesMatch( sibling, attribs ) )
+ {
+ // Save the last child to be checked too (to merge things like <b><i></i></b><b><i></i></b>).
+ var innerSibling = element.lastChild ;
+
+ if ( hasBookmark )
+ FCKDomTools.MoveNode( element.nextSibling, element ) ;
+
+ // Move contents from the sibling.
+ FCKDomTools.MoveChildren( sibling, element ) ;
+ FCKDomTools.RemoveNode( sibling ) ;
+
+ // Now check the last inner child (see two comments above).
+ if ( innerSibling )
+ this._MergeNextSibling( innerSibling ) ;
+ }
+ }
+ },
+
+ /**
+ * Merge an element with its similar siblings before it.
+ * "attribs" is and object computed with _CreateAttribsForComparison.
+ */
+ _MergePreviousSibling : function( element, attribs )
+ {
+ // Check the previous sibling.
+ var sibling = element.previousSibling ;
+
+ // Check if the previous sibling is a bookmark element. In this case, jump it.
+ var hasBookmark = ( sibling && sibling.nodeType == 1 && sibling.getAttribute( '_fck_bookmark' ) ) ;
+ if ( hasBookmark )
+ sibling = sibling.previousSibling ;
+
+ if ( sibling && sibling.nodeType == 1 && sibling.nodeName == element.nodeName )
+ {
+ if ( !attribs )
+ attribs = this._CreateElementAttribsForComparison( element ) ;
+
+ if ( this._CheckAttributesMatch( sibling, attribs ) )
+ {
+ // Save the first child to be checked too (to merge things like <b><i></i></b><b><i></i></b>).
+ var innerSibling = element.firstChild ;
+
+ if ( hasBookmark )
+ FCKDomTools.MoveNode( element.previousSibling, element, true ) ;
+
+ // Move contents to the sibling.
+ FCKDomTools.MoveChildren( sibling, element, true ) ;
+ FCKDomTools.RemoveNode( sibling ) ;
+
+ // Now check the first inner child (see two comments above).
+ if ( innerSibling )
+ this._MergePreviousSibling( innerSibling ) ;
+ }
+ }
+ },
+
+ /**
+ * Build the cssText based on the styles definition.
+ */
+ _GetStyleText : function()
+ {
+ var stylesDef = this._StyleDesc.Styles ;
+
+ // Builds the StyleText.
+ var stylesText = ( this._StyleDesc.Attributes ? this._StyleDesc.Attributes['style'] || '' : '' ) ;
+
+ if ( stylesText.length > 0 )
+ stylesText += ';' ;
+
+ for ( var style in stylesDef )
+ stylesText += style + ':' + stylesDef[style] + ';' ;
+
+ // Browsers make some changes to the style when applying them. So, here
+ // we normalize it to the browser format. We'll not do that if there
+ // are variables inside the style.
+ if ( stylesText.length > 0 && !( /#\(/.test( stylesText ) ) )
+ {
+ stylesText = FCKTools.NormalizeCssText( stylesText ) ;
+ }
+
+ return (this._GetStyleText = function() { return stylesText ; })() ;
+ },
+
+ /**
+ * Get the the collection used to compare the attributes defined in this
+ * style with attributes in an element. All information in it is lowercased.
+ */
+ _GetAttribsForComparison : function()
+ {
+ // If we have already computed it, just return it.
+ var attribs = this._GetAttribsForComparison_$ ;
+ if ( attribs )
+ return attribs ;
+
+ attribs = new Object() ;
+
+ // Loop through all defined attributes.
+ var styleAttribs = this._StyleDesc.Attributes ;
+ if ( styleAttribs )
+ {
+ for ( var styleAtt in styleAttribs )
+ {
+ attribs[ styleAtt.toLowerCase() ] = styleAttribs[ styleAtt ].toLowerCase() ;
+ }
+ }
+
+ // Includes the style definitions.
+ if ( this._GetStyleText().length > 0 )
+ {
+ attribs['style'] = this._GetStyleText().toLowerCase() ;
+ }
+
+ // Appends the "length" information to the object.
+ FCKTools.AppendLengthProperty( attribs, '_length' ) ;
+
+ // Return it, saving it to the next request.
+ return ( this._GetAttribsForComparison_$ = attribs ) ;
+ },
+
+ /**
+ * Get the the collection used to compare the elements and attributes,
+ * defined in this style overrides, with other element. All information in
+ * it is lowercased.
+ */
+ _GetOverridesForComparison : function()
+ {
+ // If we have already computed it, just return it.
+ var overrides = this._GetOverridesForComparison_$ ;
+ if ( overrides )
+ return overrides ;
+
+ overrides = new Object() ;
+
+ var overridesDesc = this._StyleDesc.Overrides ;
+
+ if ( overridesDesc )
+ {
+ // The override description can be a string, object or array.
+ // Internally, well handle arrays only, so transform it if needed.
+ if ( !FCKTools.IsArray( overridesDesc ) )
+ overridesDesc = [ overridesDesc ] ;
+
+ // Loop through all override definitions.
+ for ( var i = 0 ; i < overridesDesc.length ; i++ )
+ {
+ var override = overridesDesc[i] ;
+ var elementName ;
+ var overrideEl ;
+ var attrs ;
+
+ // If can be a string with the element name.
+ if ( typeof override == 'string' )
+ elementName = override.toLowerCase() ;
+ // Or an object.
+ else
+ {
+ elementName = override.Element ? override.Element.toLowerCase() : this.Element ;
+ attrs = override.Attributes ;
+ }
+
+ // We can have more than one override definition for the same
+ // element name, so we attempt to simply append information to
+ // it if it already exists.
+ overrideEl = overrides[ elementName ] || ( overrides[ elementName ] = {} ) ;
+
+ if ( attrs )
+ {
+ // The returning attributes list is an array, because we
+ // could have different override definitions for the same
+ // attribute name.
+ var overrideAttrs = ( overrideEl.Attributes = overrideEl.Attributes || new Array() ) ;
+ for ( var attName in attrs )
+ {
+ // Each item in the attributes array is also an array,
+ // where [0] is the attribute name and [1] is the
+ // override value.
+ overrideAttrs.push( [ attName.toLowerCase(), attrs[ attName ] ] ) ;
+ }
+ }
+ }
+ }
+
+ return ( this._GetOverridesForComparison_$ = overrides ) ;
+ },
+
+ /*
+ * Create and object containing all attributes specified in an element,
+ * added by a "_length" property. All values are lowercased.
+ */
+ _CreateElementAttribsForComparison : function( element )
+ {
+ var attribs = new Object() ;
+ var attribsCount = 0 ;
+
+ for ( var i = 0 ; i < element.attributes.length ; i++ )
+ {
+ var att = element.attributes[i] ;
+
+ if ( att.specified )
+ {
+ attribs[ att.nodeName.toLowerCase() ] = FCKDomTools.GetAttributeValue( element, att ).toLowerCase() ;
+ attribsCount++ ;
+ }
+ }
+
+ attribs._length = attribsCount ;
+
+ return attribs ;
+ },
+
+ /**
+ * Checks is the element attributes have a perfect match with the style
+ * attributes.
+ */
+ _CheckAttributesMatch : function( element, styleAttribs )
+ {
+ // Loop through all specified attributes. The same number of
+ // attributes must be found and their values must match to
+ // declare them as equal.
+
+ var elementAttrbs = element.attributes ;
+ var matchCount = 0 ;
+
+ for ( var i = 0 ; i < elementAttrbs.length ; i++ )
+ {
+ var att = elementAttrbs[i] ;
+ if ( att.specified )
+ {
+ var attName = att.nodeName.toLowerCase() ;
+ var styleAtt = styleAttribs[ attName ] ;
+
+ // The attribute is not defined in the style.
+ if ( !styleAtt )
+ break ;
+
+ // The values are different.
+ if ( styleAtt != FCKDomTools.GetAttributeValue( element, att ).toLowerCase() )
+ break ;
+
+ matchCount++ ;
+ }
+ }
+
+ return ( matchCount == styleAttribs._length ) ;
+ }
+} ;
|