← Back to branch summary

~ubuntu-branches/ubuntu/natty/moin/natty-updates

« back to all changes in this revision

Viewing changes to MoinMoin/web/static/htdocs/applets/FCKeditor/editor/_source/classes/fckstyle.js

  • Committer: Bazaar Package Importer
  • Author(s): Jonas Smedegaard
  • Date: 2008-06-22 21:17:13 UTC
  • mto: This revision was merged to the branch mainline in revision 18.
  • Revision ID: james.westby@ubuntu.com-20080622211713-inlv5k4eifxckelr
ImportĀ upstreamĀ versionĀ 1.7.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
MoinMoin/web/static/htdocs/applets/FCKeditor/editor/_source/classes/fckstyle.js
1
 
ļ»æ/*
2
 
 * FCKeditor - The text editor for Internet - http://www.fckeditor.net
3
 
 * Copyright (C) 2003-2010 Frederico Caldeira Knabben
4
 
 *
5
 
 * == BEGIN LICENSE ==
6
 
 *
7
 
 * Licensed under the terms of any of the following licenses at your
8
 
 * choice:
9
 
 *
10
 
 *  - GNU General Public License Version 2 or later (the "GPL")
11
 
 *    http://www.gnu.org/licenses/gpl.html
12
 
 *
13
 
 *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
14
 
 *    http://www.gnu.org/licenses/lgpl.html
15
 
 *
16
 
 *  - Mozilla Public License Version 1.1 or later (the "MPL")
17
 
 *    http://www.mozilla.org/MPL/MPL-1.1.html
18
 
 *
19
 
 * == END LICENSE ==
20
 
 *
21
 
 * FCKStyle Class: contains a style definition, and all methods to work with
22
 
 * the style in a document.
23
 
 */
24
 
 
25
 
/**
26
 
 * @param {Object} styleDesc A "style descriptor" object, containing the raw
27
 
 * style definition in the following format:
28
 
 *              '<style name>' : {
29
 
 *                      Element : '<element name>',
30
 
 *                      Attributes : {
31
 
 *                              '<att name>' : '<att value>',
32
 
 *                              ...
33
 
 *                      },
34
 
 *                      Styles : {
35
 
 *                              '<style name>' : '<style value>',
36
 
 *                              ...
37
 
 *                      },
38
 
 *                      Overrides : '<element name>'|{
39
 
 *                              Element : '<element name>',
40
 
 *                              Attributes : {
41
 
 *                                      '<att name>' : '<att value>'|/<att regex>/
42
 
 *                              },
43
 
 *                              Styles : {
44
 
 *                                      '<style name>' : '<style value>'|/<style regex>/
45
 
 *                              },
46
 
 *                      }
47
 
 *              }
48
 
 */
49
 
var FCKStyle = function( styleDesc )
50
 
{
51
 
        this.Element = ( styleDesc.Element || 'span' ).toLowerCase() ;
52
 
        this._StyleDesc = styleDesc ;
53
 
}
54
 
 
55
 
FCKStyle.prototype =
56
 
{
57
 
        /**
58
 
         * Get the style type, based on its element name:
59
 
         *              - FCK_STYLE_BLOCK  (0): Block Style
60
 
         *              - FCK_STYLE_INLINE (1): Inline Style
61
 
         *              - FCK_STYLE_OBJECT (2): Object Style
62
 
         */
63
 
        GetType : function()
64
 
        {
65
 
                var type = this.GetType_$ ;
66
 
 
67
 
                if ( type != undefined )
68
 
                        return type ;
69
 
 
70
 
                var elementName = this.Element ;
71
 
 
72
 
                if ( elementName == '#' || FCKListsLib.StyleBlockElements[ elementName ] )
73
 
                        type = FCK_STYLE_BLOCK ;
74
 
                else if ( FCKListsLib.StyleObjectElements[ elementName ] )
75
 
                        type = FCK_STYLE_OBJECT ;
76
 
                else
77
 
                        type = FCK_STYLE_INLINE ;
78
 
 
79
 
                return ( this.GetType_$ = type ) ;
80
 
        },
81
 
 
82
 
        /**
83
 
         * Apply the style to the current selection.
84
 
         */
85
 
        ApplyToSelection : function( targetWindow )
86
 
        {
87
 
                // Create a range for the current selection.
88
 
                var range = new FCKDomRange( targetWindow ) ;
89
 
                range.MoveToSelection() ;
90
 
 
91
 
                this.ApplyToRange( range, true ) ;
92
 
        },
93
 
 
94
 
        /**
95
 
         * Apply the style to a FCKDomRange.
96
 
         */
97
 
        ApplyToRange : function( range, selectIt, updateRange )
98
 
        {
99
 
                // ApplyToRange is not valid for FCK_STYLE_OBJECT types.
100
 
                // Use ApplyToObject instead.
101
 
 
102
 
                switch ( this.GetType() )
103
 
                {
104
 
                        case FCK_STYLE_BLOCK :
105
 
                                this.ApplyToRange = this._ApplyBlockStyle ;
106
 
                                break ;
107
 
                        case FCK_STYLE_INLINE :
108
 
                                this.ApplyToRange = this._ApplyInlineStyle ;
109
 
                                break ;
110
 
                        default :
111
 
                                return ;
112
 
                }
113
 
 
114
 
                this.ApplyToRange( range, selectIt, updateRange ) ;
115
 
        },
116
 
 
117
 
        /**
118
 
         * Apply the style to an object. Valid for FCK_STYLE_BLOCK types only.
119
 
         */
120
 
        ApplyToObject : function( objectElement )
121
 
        {
122
 
                if ( !objectElement )
123
 
                        return ;
124
 
 
125
 
                this.BuildElement( null, objectElement ) ;
126
 
        },
127
 
 
128
 
        /**
129
 
         * Remove the style from the current selection.
130
 
         */
131
 
        RemoveFromSelection : function( targetWindow )
132
 
        {
133
 
                // Create a range for the current selection.
134
 
                var range = new FCKDomRange( targetWindow ) ;
135
 
                range.MoveToSelection() ;
136
 
 
137
 
                this.RemoveFromRange( range, true ) ;
138
 
        },
139
 
 
140
 
        /**
141
 
         * Remove the style from a FCKDomRange. Block type styles will have no
142
 
         * effect.
143
 
         */
144
 
        RemoveFromRange : function( range, selectIt, updateRange )
145
 
        {
146
 
                var bookmark ;
147
 
 
148
 
                // Create the attribute list to be used later for element comparisons.
149
 
                var styleAttribs = this._GetAttribsForComparison() ;
150
 
                var styleOverrides = this._GetOverridesForComparison() ;
151
 
 
152
 
                // If collapsed, we are removing all conflicting styles from the range
153
 
                // parent tree.
154
 
                if ( range.CheckIsCollapsed() )
155
 
                {
156
 
                        // Bookmark the range so we can re-select it after processing.
157
 
                        var bookmark = range.CreateBookmark( true ) ;
158
 
 
159
 
                        // Let's start from the bookmark <span> parent.
160
 
                        var bookmarkStart = range.GetBookmarkNode( bookmark, true ) ;
161
 
 
162
 
                        var path = new FCKElementPath( bookmarkStart.parentNode ) ;
163
 
 
164
 
                        // While looping through the path, we'll be saving references to
165
 
                        // parent elements if the range is in one of their boundaries. In
166
 
                        // this way, we are able to create a copy of those elements when
167
 
                        // removing a style if the range is in a boundary limit (see #1270).
168
 
                        var boundaryElements = [] ;
169
 
 
170
 
                        // Check if the range is in the boundary limits of an element
171
 
                        // (related to #1270).
172
 
                        var isBoundaryRight = !FCKDomTools.GetNextSibling( bookmarkStart ) ;
173
 
                        var isBoundary = isBoundaryRight || !FCKDomTools.GetPreviousSibling( bookmarkStart ) ;
174
 
 
175
 
                        // This is the last element to be removed in the boundary situation
176
 
                        // described at #1270.
177
 
                        var lastBoundaryElement ;
178
 
                        var boundaryLimitIndex = -1 ;
179
 
 
180
 
                        for ( var i = 0 ; i < path.Elements.length ; i++ )
181
 
                        {
182
 
                                var pathElement = path.Elements[i] ;
183
 
                                if ( this.CheckElementRemovable( pathElement ) )
184
 
                                {
185
 
                                        if ( isBoundary
186
 
                                                && !FCKDomTools.CheckIsEmptyElement( pathElement,
187
 
                                                                function( el )
188
 
                                                                {
189
 
                                                                        return ( el != bookmarkStart ) ;
190
 
                                                                } )
191
 
                                                )
192
 
                                        {
193
 
                                                lastBoundaryElement = pathElement ;
194
 
 
195
 
                                                // We'll be continuously including elements in the
196
 
                                                // boundaryElements array, but only those added before
197
 
                                                // setting lastBoundaryElement must be used later, so
198
 
                                                // let's mark the current index here.
199
 
                                                boundaryLimitIndex = boundaryElements.length - 1 ;
200
 
                                        }
201
 
                                        else
202
 
                                        {
203
 
                                                var pathElementName = pathElement.nodeName.toLowerCase() ;
204
 
 
205
 
                                                if ( pathElementName == this.Element )
206
 
                                                {
207
 
                                                        // Remove any attribute that conflict with this style, no
208
 
                                                        // matter their values.
209
 
                                                        for ( var att in styleAttribs )
210
 
                                                        {
211
 
                                                                if ( FCKDomTools.HasAttribute( pathElement, att ) )
212
 
                                                                {
213
 
                                                                        switch ( att )
214
 
                                                                        {
215
 
                                                                                case 'style' :
216
 
                                                                                        this._RemoveStylesFromElement( pathElement ) ;
217
 
                                                                                        break ;
218
 
 
219
 
                                                                                case 'class' :
220
 
                                                                                        // The 'class' element value must match (#1318).
221
 
                                                                                        if ( FCKDomTools.GetAttributeValue( pathElement, att ) != this.GetFinalAttributeValue( att ) )
222
 
                                                                                                continue ;
223
 
 
224
 
                                                                                        /*jsl:fallthru*/
225
 
 
226
 
                                                                                default :
227
 
                                                                                        FCKDomTools.RemoveAttribute( pathElement, att ) ;
228
 
                                                                        }
229
 
                                                                }
230
 
                                                        }
231
 
                                                }
232
 
 
233
 
                                                // Remove overrides defined to the same element name.
234
 
                                                this._RemoveOverrides( pathElement, styleOverrides[ pathElementName ] ) ;
235
 
 
236
 
                                                // Remove the element if no more attributes are available and it's an inline style element
237
 
                                                if ( this.GetType() == FCK_STYLE_INLINE)
238
 
                                                        this._RemoveNoAttribElement( pathElement ) ;
239
 
                                        }
240
 
                                }
241
 
                                else if ( isBoundary )
242
 
                                        boundaryElements.push( pathElement ) ;
243
 
 
244
 
                                // Check if we are still in a boundary (at the same side).
245
 
                                isBoundary = isBoundary && ( ( isBoundaryRight && !FCKDomTools.GetNextSibling( pathElement ) ) || ( !isBoundaryRight && !FCKDomTools.GetPreviousSibling( pathElement ) ) ) ;
246
 
 
247
 
                                // If we are in an element that is not anymore a boundary, or
248
 
                                // we are at the last element, let's move things outside the
249
 
                                // boundary (if available).
250
 
                                if ( lastBoundaryElement && ( !isBoundary || ( i == path.Elements.length - 1 ) ) )
251
 
                                {
252
 
                                        // Remove the bookmark node from the DOM.
253
 
                                        var currentElement = FCKDomTools.RemoveNode( bookmarkStart ) ;
254
 
 
255
 
                                        // Build the collapsed group of elements that are not
256
 
                                        // removed by this style, but share the boundary.
257
 
                                        // (see comment 1 and 2 at #1270)
258
 
                                        for ( var j = 0 ; j <= boundaryLimitIndex ; j++ )
259
 
                                        {
260
 
                                                var newElement = FCKDomTools.CloneElement( boundaryElements[j] ) ;
261
 
                                                newElement.appendChild( currentElement ) ;
262
 
                                                currentElement = newElement ;
263
 
                                        }
264
 
 
265
 
                                        // Re-insert the bookmark node (and the collapsed elements)
266
 
                                        // in the DOM, in the new position next to the styled element.
267
 
                                        if ( isBoundaryRight )
268
 
                                                FCKDomTools.InsertAfterNode( lastBoundaryElement, currentElement ) ;
269
 
                                        else
270
 
                                                lastBoundaryElement.parentNode.insertBefore( currentElement, lastBoundaryElement ) ;
271
 
 
272
 
                                        isBoundary = false ;
273
 
                                        lastBoundaryElement = null ;
274
 
                                }
275
 
                        }
276
 
 
277
 
                                // Re-select the original range.
278
 
                        if ( selectIt )
279
 
                                range.SelectBookmark( bookmark ) ;
280
 
 
281
 
                        if ( updateRange )
282
 
                                range.MoveToBookmark( bookmark ) ;
283
 
 
284
 
                        return ;
285
 
                }
286
 
 
287
 
                // Expand the range, if inside inline element boundaries.
288
 
                range.Expand( 'inline_elements' ) ;
289
 
 
290
 
                // Bookmark the range so we can re-select it after processing.
291
 
                bookmark = range.CreateBookmark( true ) ;
292
 
 
293
 
                // The style will be applied within the bookmark boundaries.
294
 
                var startNode   = range.GetBookmarkNode( bookmark, true ) ;
295
 
                var endNode             = range.GetBookmarkNode( bookmark, false ) ;
296
 
 
297
 
                range.Release( true ) ;
298
 
 
299
 
                // We need to check the selection boundaries (bookmark spans) to break
300
 
                // the code in a way that we can properly remove partially selected nodes.
301
 
                // For example, removing a <b> style from
302
 
                //              <b>This is [some text</b> to show <b>the] problem</b>
303
 
                // ... where [ and ] represent the selection, must result:
304
 
                //              <b>This is </b>[some text to show the]<b> problem</b>
305
 
                // The strategy is simple, we just break the partial nodes before the
306
 
                // removal logic, having something that could be represented this way:
307
 
                //              <b>This is </b>[<b>some text</b> to show <b>the</b>]<b> problem</b>
308
 
 
309
 
                // Let's start checking the start boundary.
310
 
                var path = new FCKElementPath( startNode ) ;
311
 
                var pathElements = path.Elements ;
312
 
                var pathElement ;
313
 
 
314
 
                for ( var i = 1 ; i < pathElements.length ; i++ )
315
 
                {
316
 
                        pathElement = pathElements[i] ;
317
 
 
318
 
                        if ( pathElement == path.Block || pathElement == path.BlockLimit )
319
 
                                break ;
320
 
 
321
 
                        // If this element can be removed (even partially).
322
 
                        if ( this.CheckElementRemovable( pathElement ) )
323
 
                                FCKDomTools.BreakParent( startNode, pathElement, range ) ;
324
 
                }
325
 
 
326
 
                // Now the end boundary.
327
 
                path = new FCKElementPath( endNode ) ;
328
 
                pathElements = path.Elements ;
329
 
 
330
 
                for ( var i = 1 ; i < pathElements.length ; i++ )
331
 
                {
332
 
                        pathElement = pathElements[i] ;
333
 
 
334
 
                        if ( pathElement == path.Block || pathElement == path.BlockLimit )
335
 
                                break ;
336
 
 
337
 
                        elementName = pathElement.nodeName.toLowerCase() ;
338
 
 
339
 
                        // If this element can be removed (even partially).
340
 
                        if ( this.CheckElementRemovable( pathElement ) )
341
 
                                FCKDomTools.BreakParent( endNode, pathElement, range ) ;
342
 
                }
343
 
 
344
 
                // Navigate through all nodes between the bookmarks.
345
 
                var currentNode = FCKDomTools.GetNextSourceNode( startNode, true ) ;
346
 
 
347
 
                while ( currentNode )
348
 
                {
349
 
                        // Cache the next node to be processed. Do it now, because
350
 
                        // currentNode may be removed.
351
 
                        var nextNode = FCKDomTools.GetNextSourceNode( currentNode ) ;
352
 
 
353
 
                        // Remove elements nodes that match with this style rules.
354
 
                        if ( currentNode.nodeType == 1 )
355
 
                        {
356
 
                                var elementName = currentNode.nodeName.toLowerCase() ;
357
 
 
358
 
                                var mayRemove = ( elementName == this.Element ) ;
359
 
                                if ( mayRemove )
360
 
                                {
361
 
                                        // Remove any attribute that conflict with this style, no matter
362
 
                                        // their values.
363
 
                                        for ( var att in styleAttribs )
364
 
                                        {
365
 
                                                if ( FCKDomTools.HasAttribute( currentNode, att ) )
366
 
                                                {
367
 
                                                        switch ( att )
368
 
                                                        {
369
 
                                                                case 'style' :
370
 
                                                                        this._RemoveStylesFromElement( currentNode ) ;
371
 
                                                                        break ;
372
 
 
373
 
                                                                case 'class' :
374
 
                                                                        // The 'class' element value must match (#1318).
375
 
                                                                        if ( FCKDomTools.GetAttributeValue( currentNode, att ) != this.GetFinalAttributeValue( att ) )
376
 
                                                                                continue ;
377
 
 
378
 
                                                                        /*jsl:fallthru*/
379
 
 
380
 
                                                                default :
381
 
                                                                        FCKDomTools.RemoveAttribute( currentNode, att ) ;
382
 
                                                        }
383
 
                                                }
384
 
                                        }
385
 
                                }
386
 
                                else
387
 
                                        mayRemove = !!styleOverrides[ elementName ] ;
388
 
 
389
 
                                if ( mayRemove )
390
 
                                {
391
 
                                        // Remove overrides defined to the same element name.
392
 
                                        this._RemoveOverrides( currentNode, styleOverrides[ elementName ] ) ;
393
 
 
394
 
                                        // Remove the element if no more attributes are available.
395
 
                                        this._RemoveNoAttribElement( currentNode ) ;
396
 
                                }
397
 
                        }
398
 
 
399
 
                        // If we have reached the end of the selection, stop looping.
400
 
                        if ( nextNode == endNode )
401
 
                                break ;
402
 
 
403
 
                        currentNode = nextNode ;
404
 
                }
405
 
 
406
 
                this._FixBookmarkStart( startNode ) ;
407
 
 
408
 
                // Re-select the original range.
409
 
                if ( selectIt )
410
 
                        range.SelectBookmark( bookmark ) ;
411
 
 
412
 
                if ( updateRange )
413
 
                        range.MoveToBookmark( bookmark ) ;
414
 
        },
415
 
 
416
 
        /**
417
 
         * Checks if an element, or any of its attributes, is removable by the
418
 
         * current style definition.
419
 
         */
420
 
        CheckElementRemovable : function( element, fullMatch )
421
 
        {
422
 
                if ( !element )
423
 
                        return false ;
424
 
 
425
 
                var elementName = element.nodeName.toLowerCase() ;
426
 
 
427
 
                // If the element name is the same as the style name.
428
 
                if ( elementName == this.Element )
429
 
                {
430
 
                        // If no attributes are defined in the element.
431
 
                        if ( !fullMatch && !FCKDomTools.HasAttributes( element ) )
432
 
                                return true ;
433
 
 
434
 
                        // If any attribute conflicts with the style attributes.
435
 
                        var attribs = this._GetAttribsForComparison() ;
436
 
                        var allMatched = ( attribs._length == 0 ) ;
437
 
                        for ( var att in attribs )
438
 
                        {
439
 
                                if ( att == '_length' )
440
 
                                        continue ;
441
 
 
442
 
                                if ( this._CompareAttributeValues( att, FCKDomTools.GetAttributeValue( element, att ), ( this.GetFinalAttributeValue( att ) || '' ) ) )
443
 
                                {
444
 
                                        allMatched = true ;
445
 
                                        if ( !fullMatch )
446
 
                                                break ;
447
 
                                }
448
 
                                else
449
 
                                {
450
 
                                        allMatched = false ;
451
 
                                        if ( fullMatch )
452
 
                                                return false ;
453
 
                                }
454
 
                        }
455
 
                        if ( allMatched )
456
 
                                return true ;
457
 
                }
458
 
 
459
 
                // Check if the element can be somehow overriden.
460
 
                var override = this._GetOverridesForComparison()[ elementName ] ;
461
 
                if ( override )
462
 
                {
463
 
                        // If no attributes have been defined, remove the element.
464
 
                        if ( !( attribs = override.Attributes ) ) // Only one "="
465
 
                                return true ;
466
 
 
467
 
                        for ( var i = 0 ; i < attribs.length ; i++ )
468
 
                        {
469
 
                                var attName = attribs[i][0] ;
470
 
                                if ( FCKDomTools.HasAttribute( element, attName ) )
471
 
                                {
472
 
                                        var attValue = attribs[i][1] ;
473
 
 
474
 
                                        // Remove the attribute if:
475
 
                                        //    - The override definition value is null ;
476
 
                                        //    - The override definition valie is a string that
477
 
                                        //      matches the attribute value exactly.
478
 
                                        //    - The override definition value is a regex that
479
 
                                        //      has matches in the attribute value.
480
 
                                        if ( attValue == null ||
481
 
                                                        ( typeof attValue == 'string' && FCKDomTools.GetAttributeValue( element, attName ) == attValue ) ||
482
 
                                                        attValue.test( FCKDomTools.GetAttributeValue( element, attName ) ) )
483
 
                                                return true ;
484
 
                                }
485
 
                        }
486
 
                }
487
 
 
488
 
                return false ;
489
 
        },
490
 
 
491
 
        /**
492
 
         * Get the style state for an element path. Returns "true" if the element
493
 
         * is active in the path.
494
 
         */
495
 
        CheckActive : function( elementPath )
496
 
        {
497
 
                switch ( this.GetType() )
498
 
                {
499
 
                        case FCK_STYLE_BLOCK :
500
 
                                return this.CheckElementRemovable( elementPath.Block || elementPath.BlockLimit, true ) ;
501
 
 
502
 
                        case FCK_STYLE_INLINE :
503
 
 
504
 
                                var elements = elementPath.Elements ;
505
 
 
506
 
                                for ( var i = 0 ; i < elements.length ; i++ )
507
 
                                {
508
 
                                        var element = elements[i] ;
509
 
 
510
 
                                        if ( element == elementPath.Block || element == elementPath.BlockLimit )
511
 
                                                continue ;
512
 
 
513
 
                                        if ( this.CheckElementRemovable( element, true ) )
514
 
                                                return true ;
515
 
                                }
516
 
                }
517
 
                return false ;
518
 
        },
519
 
 
520
 
        /**
521
 
         * Removes an inline style from inside an element tree. The element node
522
 
         * itself is not checked or removed, only the child tree inside of it.
523
 
         */
524
 
        RemoveFromElement : function( element )
525
 
        {
526
 
                var attribs = this._GetAttribsForComparison() ;
527
 
                var overrides = this._GetOverridesForComparison() ;
528
 
 
529
 
                // Get all elements with the same name.
530
 
                var innerElements = element.getElementsByTagName( this.Element ) ;
531
 
 
532
 
                for ( var i = innerElements.length - 1 ; i >= 0 ; i-- )
533
 
                {
534
 
                        var innerElement = innerElements[i] ;
535
 
 
536
 
                        // Remove any attribute that conflict with this style, no matter
537
 
                        // their values.
538
 
                        for ( var att in attribs )
539
 
                        {
540
 
                                if ( FCKDomTools.HasAttribute( innerElement, att ) )
541
 
                                {
542
 
                                        switch ( att )
543
 
                                        {
544
 
                                                case 'style' :
545
 
                                                        this._RemoveStylesFromElement( innerElement ) ;
546
 
                                                        break ;
547
 
 
548
 
                                                case 'class' :
549
 
                                                        // The 'class' element value must match (#1318).
550
 
                                                        if ( FCKDomTools.GetAttributeValue( innerElement, att ) != this.GetFinalAttributeValue( att ) )
551
 
                                                                continue ;
552
 
 
553
 
                                                        /*jsl:fallthru*/
554
 
 
555
 
                                                default :
556
 
                                                        FCKDomTools.RemoveAttribute( innerElement, att ) ;
557
 
                                        }
558
 
                                }
559
 
                        }
560
 
 
561
 
                        // Remove overrides defined to the same element name.
562
 
                        this._RemoveOverrides( innerElement, overrides[ this.Element ] ) ;
563
 
 
564
 
                        // Remove the element if no more attributes are available.
565
 
                        this._RemoveNoAttribElement( innerElement ) ;
566
 
                }
567
 
 
568
 
                // Now remove any other element with different name that is
569
 
                // defined to be overriden.
570
 
                for ( var overrideElement in overrides )
571
 
                {
572
 
                        if ( overrideElement != this.Element )
573
 
                        {
574
 
                                // Get all elements.
575
 
                                innerElements = element.getElementsByTagName( overrideElement ) ;
576
 
 
577
 
                                for ( var i = innerElements.length - 1 ; i >= 0 ; i-- )
578
 
                                {
579
 
                                        var innerElement = innerElements[i] ;
580
 
                                        this._RemoveOverrides( innerElement, overrides[ overrideElement ] ) ;
581
 
                                        this._RemoveNoAttribElement( innerElement ) ;
582
 
                                }
583
 
                        }
584
 
                }
585
 
        },
586
 
 
587
 
        _RemoveStylesFromElement : function( element )
588
 
        {
589
 
                var elementStyle = element.style.cssText ;
590
 
                var pattern = this.GetFinalStyleValue() ;
591
 
 
592
 
                if ( elementStyle.length > 0 && pattern.length == 0 )
593
 
                        return ;
594
 
 
595
 
                pattern = '(^|;)\\s*(' +
596
 
                        pattern.replace( /\s*([^ ]+):.*?(;|$)/g, '$1|' ).replace( /\|$/, '' ) +
597
 
                        '):[^;]+' ;
598
 
 
599
 
                var regex = new RegExp( pattern, 'gi' ) ;
600
 
 
601
 
                elementStyle = elementStyle.replace( regex, '' ).Trim() ;
602
 
 
603
 
                if ( elementStyle.length == 0 || elementStyle == ';' )
604
 
                        FCKDomTools.RemoveAttribute( element, 'style' ) ;
605
 
                else
606
 
                        element.style.cssText = elementStyle.replace( regex, '' ) ;
607
 
        },
608
 
 
609
 
        /**
610
 
         * Remove all attributes that are defined to be overriden,
611
 
         */
612
 
        _RemoveOverrides : function( element, override )
613
 
        {
614
 
                var attributes = override && override.Attributes ;
615
 
 
616
 
                if ( attributes )
617
 
                {
618
 
                        for ( var i = 0 ; i < attributes.length ; i++ )
619
 
                        {
620
 
                                var attName = attributes[i][0] ;
621
 
 
622
 
                                if ( FCKDomTools.HasAttribute( element, attName ) )
623
 
                                {
624
 
                                        var attValue    = attributes[i][1] ;
625
 
 
626
 
                                        // Remove the attribute if:
627
 
                                        //    - The override definition value is null ;
628
 
                                        //    - The override definition valie is a string that
629
 
                                        //      matches the attribute value exactly.
630
 
                                        //    - The override definition value is a regex that
631
 
                                        //      has matches in the attribute value.
632
 
                                        if ( attValue == null ||
633
 
                                                        ( attValue.test && attValue.test( FCKDomTools.GetAttributeValue( element, attName ) ) ) ||
634
 
                                                        ( typeof attValue == 'string' && FCKDomTools.GetAttributeValue( element, attName ) == attValue ) )
635
 
                                                FCKDomTools.RemoveAttribute( element, attName ) ;
636
 
                                }
637
 
                        }
638
 
                }
639
 
        },
640
 
 
641
 
        /**
642
 
         * If the element has no more attributes, remove it.
643
 
         */
644
 
        _RemoveNoAttribElement : function( element )
645
 
        {
646
 
                // If no more attributes remained in the element, remove it,
647
 
                // leaving its children.
648
 
                if ( !FCKDomTools.HasAttributes( element ) )
649
 
                {
650
 
                        // Removing elements may open points where merging is possible,
651
 
                        // so let's cache the first and last nodes for later checking.
652
 
                        var firstChild  = element.firstChild ;
653
 
                        var lastChild   = element.lastChild ;
654
 
 
655
 
                        FCKDomTools.RemoveNode( element, true ) ;
656
 
 
657
 
                        // Check the cached nodes for merging.
658
 
                        this._MergeSiblings( firstChild ) ;
659
 
 
660
 
                        if ( firstChild != lastChild )
661
 
                                this._MergeSiblings( lastChild ) ;
662
 
                }
663
 
        },
664
 
 
665
 
        /**
666
 
         * Creates a DOM element for this style object.
667
 
         */
668
 
        BuildElement : function( targetDoc, element )
669
 
        {
670
 
                // Create the element.
671
 
                var el = element || targetDoc.createElement( this.Element ) ;
672
 
 
673
 
                // Assign all defined attributes.
674
 
                var attribs     = this._StyleDesc.Attributes ;
675
 
                var attValue ;
676
 
                if ( attribs )
677
 
                {
678
 
                        for ( var att in attribs )
679
 
                        {
680
 
                                attValue = this.GetFinalAttributeValue( att ) ;
681
 
 
682
 
                                if ( att.toLowerCase() == 'class' )
683
 
                                        el.className = attValue ;
684
 
                                else
685
 
                                        el.setAttribute( att, attValue ) ;
686
 
                        }
687
 
                }
688
 
 
689
 
                // Assign the style attribute.
690
 
                if ( this._GetStyleText().length > 0 )
691
 
                        el.style.cssText = this.GetFinalStyleValue() ;
692
 
 
693
 
                return el ;
694
 
        },
695
 
 
696
 
        _CompareAttributeValues : function( attName, valueA, valueB )
697
 
        {
698
 
                if ( attName == 'style' && valueA && valueB )
699
 
                {
700
 
                        valueA = valueA.replace( /;$/, '' ).toLowerCase() ;
701
 
                        valueB = valueB.replace( /;$/, '' ).toLowerCase() ;
702
 
                }
703
 
 
704
 
                // Return true if they match or if valueA is null and valueB is an empty string
705
 
                return ( valueA == valueB || ( ( valueA === null || valueA === '' ) && ( valueB === null || valueB === '' ) ) )
706
 
        },
707
 
 
708
 
        GetFinalAttributeValue : function( attName )
709
 
        {
710
 
                var attValue = this._StyleDesc.Attributes ;
711
 
                var attValue = attValue ? attValue[ attName ] : null ;
712
 
 
713
 
                if ( !attValue && attName == 'style' )
714
 
                        return this.GetFinalStyleValue() ;
715
 
 
716
 
                if ( attValue && this._Variables )
717
 
                        // Using custom Replace() to guarantee the correct scope.
718
 
                        attValue = attValue.Replace( FCKRegexLib.StyleVariableAttName, this._GetVariableReplace, this ) ;
719
 
 
720
 
                return attValue ;
721
 
        },
722
 
 
723
 
        GetFinalStyleValue : function()
724
 
        {
725
 
                var attValue = this._GetStyleText() ;
726
 
 
727
 
                if ( attValue.length > 0 && this._Variables )
728
 
                {
729
 
                        // Using custom Replace() to guarantee the correct scope.
730
 
                        attValue = attValue.Replace( FCKRegexLib.StyleVariableAttName, this._GetVariableReplace, this ) ;
731
 
                        attValue = FCKTools.NormalizeCssText( attValue ) ;
732
 
                }
733
 
 
734
 
                return attValue ;
735
 
        },
736
 
 
737
 
        _GetVariableReplace : function()
738
 
        {
739
 
                // The second group in the regex is the variable name.
740
 
                return this._Variables[ arguments[2] ] || arguments[0] ;
741
 
        },
742
 
 
743
 
        /**
744
 
         * Set the value of a variable attribute or style, to be used when
745
 
         * appliying the style.
746
 
         */
747
 
        SetVariable : function( name, value )
748
 
        {
749
 
                var variables = this._Variables ;
750
 
 
751
 
                if ( !variables )
752
 
                        variables = this._Variables = {} ;
753
 
 
754
 
                this._Variables[ name ] = value ;
755
 
        },
756
 
 
757
 
        /**
758
 
         * Converting from a PRE block to a non-PRE block in formatting operations.
759
 
         */
760
 
        _FromPre : function( doc, block, newBlock )
761
 
        {
762
 
                var innerHTML = block.innerHTML ;
763
 
 
764
 
                // Trim the first and last linebreaks immediately after and before <pre>, </pre>,
765
 
                // if they exist.
766
 
                // This is done because the linebreaks are not rendered.
767
 
                innerHTML = innerHTML.replace( /(\r\n|\r)/g, '\n' ) ;
768
 
                innerHTML = innerHTML.replace( /^[ \t]*\n/, '' ) ;
769
 
                innerHTML = innerHTML.replace( /\n$/, '' ) ;
770
 
 
771
 
                // 1. Convert spaces or tabs at the beginning or at the end to &nbsp;
772
 
                innerHTML = innerHTML.replace( /^[ \t]+|[ \t]+$/g, function( match, offset, s )
773
 
                                {
774
 
                                        if ( match.length == 1 )        // one space, preserve it
775
 
                                                return '&nbsp;' ;
776
 
                                        else if ( offset == 0 )         // beginning of block
777
 
                                                return new Array( match.length ).join( '&nbsp;' ) + ' ' ;
778
 
                                        else                            // end of block
779
 
                                                return ' ' + new Array( match.length ).join( '&nbsp;' ) ;
780
 
                                } ) ;
781
 
 
782
 
                // 2. Convert \n to <BR>.
783
 
                // 3. Convert contiguous (i.e. non-singular) spaces or tabs to &nbsp;
784
 
                var htmlIterator = new FCKHtmlIterator( innerHTML ) ;
785
 
                var results = [] ;
786
 
                htmlIterator.Each( function( isTag, value )
787
 
                        {
788
 
                                if ( !isTag )
789
 
                                {
790
 
                                        value = value.replace( /\n/g, '<br>' ) ;
791
 
                                        value = value.replace( /[ \t]{2,}/g,
792
 
                                                        function ( match )
793
 
                                                        {
794
 
                                                                return new Array( match.length ).join( '&nbsp;' ) + ' ' ;
795
 
                                                        } ) ;
796
 
                                }
797
 
                                results.push( value ) ;
798
 
                        } ) ;
799
 
                newBlock.innerHTML = results.join( '' ) ;
800
 
                return newBlock ;
801
 
        },
802
 
 
803
 
        /**
804
 
         * Converting from a non-PRE block to a PRE block in formatting operations.
805
 
         */
806
 
        _ToPre : function( doc, block, newBlock )
807
 
        {
808
 
                // Handle converting from a regular block to a <pre> block.
809
 
                var innerHTML = block.innerHTML.Trim() ;
810
 
 
811
 
                // 1. Delete ANSI whitespaces immediately before and after <BR> because
812
 
                //    they are not visible.
813
 
                // 2. Mark down any <BR /> nodes here so they can be turned into \n in
814
 
                //    the next step and avoid being compressed.
815
 
                innerHTML = innerHTML.replace( /[ \t\r\n]*(<br[^>]*>)[ \t\r\n]*/gi, '<br />' ) ;
816
 
 
817
 
                // 3. Compress other ANSI whitespaces since they're only visible as one
818
 
                //    single space previously.
819
 
                // 4. Convert &nbsp; to spaces since &nbsp; is no longer needed in <PRE>.
820
 
                // 5. Convert any <BR /> to \n. This must not be done earlier because
821
 
                //    the \n would then get compressed.
822
 
                var htmlIterator = new FCKHtmlIterator( innerHTML ) ;
823
 
                var results = [] ;
824
 
                htmlIterator.Each( function( isTag, value )
825
 
                        {
826
 
                                if ( !isTag )
827
 
                                        value = value.replace( /([ \t\n\r]+|&nbsp;)/g, ' ' ) ;
828
 
                                else if ( isTag && value == '<br />' )
829
 
                                        value = '\n' ;
830
 
                                results.push( value ) ;
831
 
                        } ) ;
832
 
 
833
 
                // Assigning innerHTML to <PRE> in IE causes all linebreaks to be
834
 
                // reduced to spaces.
835
 
                // Assigning outerHTML to <PRE> in IE doesn't work if the <PRE> isn't
836
 
                // contained in another node since the node reference is changed after
837
 
                // outerHTML assignment.
838
 
                // So, we need some hacks to workaround IE bugs here.
839
 
                if ( FCKBrowserInfo.IsIE )
840
 
                {
841
 
                        var temp = doc.createElement( 'div' ) ;
842
 
                        temp.appendChild( newBlock ) ;
843
 
                        newBlock.outerHTML = '<pre>\n' + results.join( '' ) + '</pre>' ;
844
 
                        newBlock = temp.removeChild( temp.firstChild ) ;
845
 
                }
846
 
                else
847
 
                        newBlock.innerHTML = results.join( '' ) ;
848
 
 
849
 
                return newBlock ;
850
 
        },
851
 
 
852
 
        /**
853
 
         * Merge a <pre> block with a previous <pre> block, if available.
854
 
         */
855
 
        _CheckAndMergePre : function( previousBlock, preBlock )
856
 
        {
857
 
                // Check if the previous block and the current block are next
858
 
                // to each other.
859
 
                if ( previousBlock != FCKDomTools.GetPreviousSourceElement( preBlock, true ) )
860
 
                        return ;
861
 
 
862
 
                // Merge the previous <pre> block contents into the current <pre>
863
 
                // block.
864
 
                //
865
 
                // Another thing to be careful here is that currentBlock might contain
866
 
                // a '\n' at the beginning, and previousBlock might contain a '\n'
867
 
                // towards the end. These new lines are not normally displayed but they
868
 
                // become visible after merging.
869
 
                var innerHTML = previousBlock.innerHTML.replace( /\n$/, '' ) + '\n\n' +
870
 
                                preBlock.innerHTML.replace( /^\n/, '' ) ;
871
 
 
872
 
                // Buggy IE normalizes innerHTML from <pre>, breaking whitespaces.
873
 
                if ( FCKBrowserInfo.IsIE )
874
 
                        preBlock.outerHTML = '<pre>' + innerHTML + '</pre>' ;
875
 
                else
876
 
                        preBlock.innerHTML = innerHTML ;
877
 
 
878
 
                // Remove the previous <pre> block.
879
 
                //
880
 
                // The preBlock must not be moved or deleted from the DOM tree. This
881
 
                // guarantees the FCKDomRangeIterator in _ApplyBlockStyle would not
882
 
                // get lost at the next iteration.
883
 
                FCKDomTools.RemoveNode( previousBlock ) ;
884
 
        },
885
 
 
886
 
        _CheckAndSplitPre : function( newBlock )
887
 
        {
888
 
                var lastNewBlock ;
889
 
 
890
 
                var cursor = newBlock.firstChild ;
891
 
 
892
 
                // We are not splitting <br><br> at the beginning of the block, so
893
 
                // we'll start from the second child.
894
 
                cursor = cursor && cursor.nextSibling ;
895
 
 
896
 
                while ( cursor )
897
 
                {
898
 
                        var next = cursor.nextSibling ;
899
 
 
900
 
                        // If we have two <BR>s, and they're not at the beginning or the end,
901
 
                        // then we'll split up the contents following them into another block.
902
 
                        // Stop processing if we are at the last child couple.
903
 
                        if ( next && next.nextSibling && cursor.nodeName.IEquals( 'br' ) && next.nodeName.IEquals( 'br' ) )
904
 
                        {
905
 
                                // Remove the first <br>.
906
 
                                FCKDomTools.RemoveNode( cursor ) ;
907
 
 
908
 
                                // Move to the node after the second <br>.
909
 
                                cursor = next.nextSibling ;
910
 
 
911
 
                                // Remove the second <br>.
912
 
                                FCKDomTools.RemoveNode( next ) ;
913
 
 
914
 
                                // Create the block that will hold the child nodes from now on.
915
 
                                lastNewBlock = FCKDomTools.InsertAfterNode( lastNewBlock || newBlock, FCKDomTools.CloneElement( newBlock ) ) ;
916
 
 
917
 
                                continue ;
918
 
                        }
919
 
 
920
 
                        // If we split it, then start moving the nodes to the new block.
921
 
                        if ( lastNewBlock )
922
 
                        {
923
 
                                cursor = cursor.previousSibling ;
924
 
                                FCKDomTools.MoveNode(cursor.nextSibling, lastNewBlock ) ;
925
 
                        }
926
 
 
927
 
                        cursor = cursor.nextSibling ;
928
 
                }
929
 
        },
930
 
 
931
 
        /**
932
 
         * Apply an inline style to a FCKDomRange.
933
 
         *
934
 
         * TODO
935
 
         *      - Implement the "#" style handling.
936
 
         *      - Properly handle block containers like <div> and <blockquote>.
937
 
         */
938
 
        _ApplyBlockStyle : function( range, selectIt, updateRange )
939
 
        {
940
 
                // Bookmark the range so we can re-select it after processing.
941
 
                var bookmark ;
942
 
 
943
 
                if ( selectIt )
944
 
                        bookmark = range.CreateBookmark() ;
945
 
 
946
 
                var iterator = new FCKDomRangeIterator( range ) ;
947
 
                iterator.EnforceRealBlocks = true ;
948
 
 
949
 
                var block ;
950
 
                var doc = range.Window.document ;
951
 
                var previousPreBlock ;
952
 
 
953
 
                while( ( block = iterator.GetNextParagraph() ) )                // Only one =
954
 
                {
955
 
                        // Create the new node right before the current one.
956
 
                        var newBlock = this.BuildElement( doc ) ;
957
 
 
958
 
                        // Check if we are changing from/to <pre>.
959
 
                        var newBlockIsPre       = newBlock.nodeName.IEquals( 'pre' ) ;
960
 
                        var blockIsPre          = block.nodeName.IEquals( 'pre' ) ;
961
 
 
962
 
                        var toPre       = newBlockIsPre && !blockIsPre ;
963
 
                        var fromPre     = !newBlockIsPre && blockIsPre ;
964
 
 
965
 
                        // Move everything from the current node to the new one.
966
 
                        if ( toPre )
967
 
                                newBlock = this._ToPre( doc, block, newBlock ) ;
968
 
                        else if ( fromPre )
969
 
                                newBlock = this._FromPre( doc, block, newBlock ) ;
970
 
                        else    // Convering from a regular block to another regular block.
971
 
                                FCKDomTools.MoveChildren( block, newBlock ) ;
972
 
 
973
 
                        // Replace the current block.
974
 
                        block.parentNode.insertBefore( newBlock, block ) ;
975
 
                        FCKDomTools.RemoveNode( block ) ;
976
 
 
977
 
                        // Complete other tasks after inserting the node in the DOM.
978
 
                        if ( newBlockIsPre )
979
 
                        {
980
 
                                if ( previousPreBlock )
981
 
                                        this._CheckAndMergePre( previousPreBlock, newBlock ) ;  // Merge successive <pre> blocks.
982
 
                                previousPreBlock = newBlock ;
983
 
                        }
984
 
                        else if ( fromPre )
985
 
                                this._CheckAndSplitPre( newBlock ) ;    // Split <br><br> in successive <pre>s.
986
 
                }
987
 
 
988
 
                // Re-select the original range.
989
 
                if ( selectIt )
990
 
                        range.SelectBookmark( bookmark ) ;
991
 
 
992
 
                if ( updateRange )
993
 
                        range.MoveToBookmark( bookmark ) ;
994
 
        },
995
 
 
996
 
        /**
997
 
         * Apply an inline style to a FCKDomRange.
998
 
         *
999
 
         * TODO
1000
 
         *      - Merge elements, when applying styles to similar elements that enclose
1001
 
         *    the entire selection, outputing:
1002
 
         *        <span style="color: #ff0000; background-color: #ffffff">XYZ</span>
1003
 
         *    instead of:
1004
 
         *        <span style="color: #ff0000;"><span style="background-color: #ffffff">XYZ</span></span>
1005
 
         */
1006
 
        _ApplyInlineStyle : function( range, selectIt, updateRange )
1007
 
        {
1008
 
                var doc = range.Window.document ;
1009
 
 
1010
 
                if ( range.CheckIsCollapsed() )
1011
 
                {
1012
 
                        // Create the element to be inserted in the DOM.
1013
 
                        var collapsedElement = this.BuildElement( doc ) ;
1014
 
                        range.InsertNode( collapsedElement ) ;
1015
 
                        range.MoveToPosition( collapsedElement, 2 ) ;
1016
 
                        range.Select() ;
1017
 
 
1018
 
                        return ;
1019
 
                }
1020
 
 
1021
 
                // The general idea here is navigating through all nodes inside the
1022
 
                // current selection, working on distinct range blocks, defined by the
1023
 
                // DTD compatibility between the style element and the nodes inside the
1024
 
                // ranges.
1025
 
                //
1026
 
                // For example, suppose we have the following selection (where [ and ]
1027
 
                // are the boundaries), and we apply a <b> style there:
1028
 
                //
1029
 
                //              <p>Here we [have <b>some</b> text.<p>
1030
 
                //              <p>And some here] here.</p>
1031
 
                //
1032
 
                // Two different ranges will be detected:
1033
 
                //
1034
 
                //              "have <b>some</b> text."
1035
 
                //              "And some here"
1036
 
                //
1037
 
                // Both ranges will be extracted, moved to a <b> element, and
1038
 
                // re-inserted, resulting in the following output:
1039
 
                //
1040
 
                //              <p>Here we [<b>have some text.</b><p>
1041
 
                //              <p><b>And some here</b>] here.</p>
1042
 
                //
1043
 
                // Note that the <b> element at <b>some</b> is also removed because it
1044
 
                // is not needed anymore.
1045
 
 
1046
 
                var elementName = this.Element ;
1047
 
 
1048
 
                // Get the DTD definition for the element. Defaults to "span".
1049
 
                var elementDTD = FCK.DTD[ elementName ] || FCK.DTD.span ;
1050
 
 
1051
 
                // Create the attribute list to be used later for element comparisons.
1052
 
                var styleAttribs = this._GetAttribsForComparison() ;
1053
 
                var styleNode ;
1054
 
 
1055
 
                // Expand the range, if inside inline element boundaries.
1056
 
                range.Expand( 'inline_elements' ) ;
1057
 
 
1058
 
                // Bookmark the range so we can re-select it after processing.
1059
 
                var bookmark = range.CreateBookmark( true ) ;
1060
 
 
1061
 
                // The style will be applied within the bookmark boundaries.
1062
 
                var startNode   = range.GetBookmarkNode( bookmark, true ) ;
1063
 
                var endNode             = range.GetBookmarkNode( bookmark, false ) ;
1064
 
 
1065
 
                // We'll be reusing the range to apply the styles. So, release it here
1066
 
                // to indicate that it has not been initialized.
1067
 
                range.Release( true ) ;
1068
 
 
1069
 
                // Let's start the nodes lookup from the node right after the bookmark
1070
 
                // span.
1071
 
                var currentNode = FCKDomTools.GetNextSourceNode( startNode, true ) ;
1072
 
 
1073
 
                while ( currentNode )
1074
 
                {
1075
 
                        var applyStyle = false ;
1076
 
 
1077
 
                        var nodeType = currentNode.nodeType ;
1078
 
                        var nodeName = nodeType == 1 ? currentNode.nodeName.toLowerCase() : null ;
1079
 
 
1080
 
                        // Check if the current node can be a child of the style element.
1081
 
                        if ( !nodeName || elementDTD[ nodeName ] )
1082
 
                        {
1083
 
                                // Check if the style element can be a child of the current
1084
 
                                // node parent or if the element is not defined in the DTD.
1085
 
                                if ( ( FCK.DTD[ currentNode.parentNode.nodeName.toLowerCase() ] || FCK.DTD.span )[ elementName ] || !FCK.DTD[ elementName ] )
1086
 
                                {
1087
 
                                        // This node will be part of our range, so if it has not
1088
 
                                        // been started, place its start right before the node.
1089
 
                                        if ( !range.CheckHasRange() )
1090
 
                                                range.SetStart( currentNode, 3 ) ;
1091
 
 
1092
 
                                        // Non element nodes, or empty elements can be added
1093
 
                                        // completely to the range.
1094
 
                                        if ( nodeType != 1 || currentNode.childNodes.length == 0 )
1095
 
                                        {
1096
 
                                                var includedNode = currentNode ;
1097
 
                                                var parentNode = includedNode.parentNode ;
1098
 
 
1099
 
                                                // This node is about to be included completelly, but,
1100
 
                                                // if this is the last node in its parent, we must also
1101
 
                                                // check if the parent itself can be added completelly
1102
 
                                                // to the range.
1103
 
                                                while ( includedNode == parentNode.lastChild
1104
 
                                                        && elementDTD[ parentNode.nodeName.toLowerCase() ] )
1105
 
                                                {
1106
 
                                                        includedNode = parentNode ;
1107
 
                                                }
1108
 
 
1109
 
                                                range.SetEnd( includedNode, 4 ) ;
1110
 
 
1111
 
                                                // If the included node is the last node in its parent
1112
 
                                                // and its parent can't be inside the style node, apply
1113
 
                                                // the style immediately.
1114
 
                                                if ( includedNode == includedNode.parentNode.lastChild && !elementDTD[ includedNode.parentNode.nodeName.toLowerCase() ] )
1115
 
                                                        applyStyle = true ;
1116
 
                                        }
1117
 
                                        else
1118
 
                                        {
1119
 
                                                // Element nodes will not be added directly. We need to
1120
 
                                                // check their children because the selection could end
1121
 
                                                // inside the node, so let's place the range end right
1122
 
                                                // before the element.
1123
 
                                                range.SetEnd( currentNode, 3 ) ;
1124
 
                                        }
1125
 
                                }
1126
 
                                else
1127
 
                                        applyStyle = true ;
1128
 
                        }
1129
 
                        else
1130
 
                                applyStyle = true ;
1131
 
 
1132
 
                        // Get the next node to be processed.
1133
 
                        currentNode = FCKDomTools.GetNextSourceNode( currentNode ) ;
1134
 
 
1135
 
                        // If we have reached the end of the selection, just apply the
1136
 
                        // style ot the range, and stop looping.
1137
 
                        if ( currentNode == endNode )
1138
 
                        {
1139
 
                                currentNode = null ;
1140
 
                                applyStyle = true ;
1141
 
                        }
1142
 
 
1143
 
                        // Apply the style if we have something to which apply it.
1144
 
                        if ( applyStyle && range.CheckHasRange() && !range.CheckIsCollapsed() )
1145
 
                        {
1146
 
                                // Build the style element, based on the style object definition.
1147
 
                                styleNode = this.BuildElement( doc ) ;
1148
 
 
1149
 
                                // Move the contents of the range to the style element.
1150
 
                                range.ExtractContents().AppendTo( styleNode ) ;
1151
 
 
1152
 
                                // If it is not empty.
1153
 
                                if ( styleNode.innerHTML.RTrim().length > 0 )
1154
 
                                {
1155
 
                                        // Insert it in the range position (it is collapsed after
1156
 
                                        // ExtractContents.
1157
 
                                        range.InsertNode( styleNode ) ;
1158
 
 
1159
 
                                        // Here we do some cleanup, removing all duplicated
1160
 
                                        // elements from the style element.
1161
 
                                        this.RemoveFromElement( styleNode ) ;
1162
 
 
1163
 
                                        // Let's merge our new style with its neighbors, if possible.
1164
 
                                        this._MergeSiblings( styleNode, this._GetAttribsForComparison() ) ;
1165
 
 
1166
 
                                        // As the style system breaks text nodes constantly, let's normalize
1167
 
                                        // things for performance.
1168
 
                                        // With IE, some paragraphs get broken when calling normalize()
1169
 
                                        // repeatedly. Also, for IE, we must normalize body, not documentElement.
1170
 
                                        // IE is also known for having a "crash effect" with normalize().
1171
 
                                        // We should try to normalize with IE too in some way, somewhere.
1172
 
                                        if ( !FCKBrowserInfo.IsIE )
1173
 
                                                styleNode.normalize() ;
1174
 
                                }
1175
 
 
1176
 
                                // Style applied, let's release the range, so it gets marked to
1177
 
                                // re-initialization in the next loop.
1178
 
                                range.Release( true ) ;
1179
 
                        }
1180
 
                }
1181
 
 
1182
 
                this._FixBookmarkStart( startNode ) ;
1183
 
 
1184
 
                // Re-select the original range.
1185
 
                if ( selectIt )
1186
 
                        range.SelectBookmark( bookmark ) ;
1187
 
 
1188
 
                if ( updateRange )
1189
 
                        range.MoveToBookmark( bookmark ) ;
1190
 
        },
1191
 
 
1192
 
        _FixBookmarkStart : function( startNode )
1193
 
        {
1194
 
                // After appliying or removing an inline style, the start boundary of
1195
 
                // the selection must be placed inside all inline elements it is
1196
 
                // bordering.
1197
 
                var startSibling ;
1198
 
                while ( ( startSibling = startNode.nextSibling ) )      // Only one "=".
1199
 
                {
1200
 
                        if ( startSibling.nodeType == 1
1201
 
                                && FCKListsLib.InlineNonEmptyElements[ startSibling.nodeName.toLowerCase() ] )
1202
 
                        {
1203
 
                                // If it is an empty inline element, we can safely remove it.
1204
 
                                if ( !startSibling.firstChild )
1205
 
                                        FCKDomTools.RemoveNode( startSibling ) ;
1206
 
                                else
1207
 
                                        FCKDomTools.MoveNode( startNode, startSibling, true ) ;
1208
 
                                continue ;
1209
 
                        }
1210
 
 
1211
 
                        // Empty text nodes can be safely removed to not disturb.
1212
 
                        if ( startSibling.nodeType == 3 && startSibling.length == 0 )
1213
 
                        {
1214
 
                                FCKDomTools.RemoveNode( startSibling ) ;
1215
 
                                continue ;
1216
 
                        }
1217
 
 
1218
 
                        break ;
1219
 
                }
1220
 
        },
1221
 
 
1222
 
        /**
1223
 
         * Merge an element with its similar siblings.
1224
 
         * "attribs" is and object computed with _CreateAttribsForComparison.
1225
 
         */
1226
 
        _MergeSiblings : function( element, attribs )
1227
 
        {
1228
 
                if ( !element || element.nodeType != 1 || !FCKListsLib.InlineNonEmptyElements[ element.nodeName.toLowerCase() ] )
1229
 
                        return ;
1230
 
 
1231
 
                this._MergeNextSibling( element, attribs ) ;
1232
 
                this._MergePreviousSibling( element, attribs ) ;
1233
 
        },
1234
 
 
1235
 
        /**
1236
 
         * Merge an element with its similar siblings after it.
1237
 
         * "attribs" is and object computed with _CreateAttribsForComparison.
1238
 
         */
1239
 
        _MergeNextSibling : function( element, attribs )
1240
 
        {
1241
 
                // Check the next sibling.
1242
 
                var sibling = element.nextSibling ;
1243
 
 
1244
 
                // Check if the next sibling is a bookmark element. In this case, jump it.
1245
 
                var hasBookmark = ( sibling && sibling.nodeType == 1 && sibling.getAttribute( '_fck_bookmark' ) ) ;
1246
 
                if ( hasBookmark )
1247
 
                        sibling = sibling.nextSibling ;
1248
 
 
1249
 
                if ( sibling && sibling.nodeType == 1 && sibling.nodeName == element.nodeName )
1250
 
                {
1251
 
                        if ( !attribs )
1252
 
                                attribs = this._CreateElementAttribsForComparison( element ) ;
1253
 
 
1254
 
                        if ( this._CheckAttributesMatch( sibling, attribs ) )
1255
 
                        {
1256
 
                                // Save the last child to be checked too (to merge things like <b><i></i></b><b><i></i></b>).
1257
 
                                var innerSibling = element.lastChild ;
1258
 
 
1259
 
                                if ( hasBookmark )
1260
 
                                        FCKDomTools.MoveNode( element.nextSibling, element ) ;
1261
 
 
1262
 
                                // Move contents from the sibling.
1263
 
                                FCKDomTools.MoveChildren( sibling, element ) ;
1264
 
                                FCKDomTools.RemoveNode( sibling ) ;
1265
 
 
1266
 
                                // Now check the last inner child (see two comments above).
1267
 
                                if ( innerSibling )
1268
 
                                        this._MergeNextSibling( innerSibling ) ;
1269
 
                        }
1270
 
                }
1271
 
        },
1272
 
 
1273
 
        /**
1274
 
         * Merge an element with its similar siblings before it.
1275
 
         * "attribs" is and object computed with _CreateAttribsForComparison.
1276
 
         */
1277
 
        _MergePreviousSibling : function( element, attribs )
1278
 
        {
1279
 
                // Check the previous sibling.
1280
 
                var sibling = element.previousSibling ;
1281
 
 
1282
 
                // Check if the previous sibling is a bookmark element. In this case, jump it.
1283
 
                var hasBookmark = ( sibling && sibling.nodeType == 1 && sibling.getAttribute( '_fck_bookmark' ) ) ;
1284
 
                if ( hasBookmark )
1285
 
                        sibling = sibling.previousSibling ;
1286
 
 
1287
 
                if ( sibling && sibling.nodeType == 1 && sibling.nodeName == element.nodeName )
1288
 
                {
1289
 
                        if ( !attribs )
1290
 
                                attribs = this._CreateElementAttribsForComparison( element ) ;
1291
 
 
1292
 
                        if ( this._CheckAttributesMatch( sibling, attribs ) )
1293
 
                        {
1294
 
                                // Save the first child to be checked too (to merge things like <b><i></i></b><b><i></i></b>).
1295
 
                                var innerSibling = element.firstChild ;
1296
 
 
1297
 
                                if ( hasBookmark )
1298
 
                                        FCKDomTools.MoveNode( element.previousSibling, element, true ) ;
1299
 
 
1300
 
                                // Move contents to the sibling.
1301
 
                                FCKDomTools.MoveChildren( sibling, element, true ) ;
1302
 
                                FCKDomTools.RemoveNode( sibling ) ;
1303
 
 
1304
 
                                // Now check the first inner child (see two comments above).
1305
 
                                if ( innerSibling )
1306
 
                                        this._MergePreviousSibling( innerSibling ) ;
1307
 
                        }
1308
 
                }
1309
 
        },
1310
 
 
1311
 
        /**
1312
 
         * Build the cssText based on the styles definition.
1313
 
         */
1314
 
        _GetStyleText : function()
1315
 
        {
1316
 
                var stylesDef = this._StyleDesc.Styles ;
1317
 
 
1318
 
                // Builds the StyleText.
1319
 
                var stylesText = ( this._StyleDesc.Attributes ? this._StyleDesc.Attributes['style'] || '' : '' ) ;
1320
 
 
1321
 
                if ( stylesText.length > 0 )
1322
 
                        stylesText += ';' ;
1323
 
 
1324
 
                for ( var style in stylesDef )
1325
 
                        stylesText += style + ':' + stylesDef[style] + ';' ;
1326
 
 
1327
 
                // Browsers make some changes to the style when applying them. So, here
1328
 
                // we normalize it to the browser format. We'll not do that if there
1329
 
                // are variables inside the style.
1330
 
                if ( stylesText.length > 0 && !( /#\(/.test( stylesText ) ) )
1331
 
                {
1332
 
                        stylesText = FCKTools.NormalizeCssText( stylesText ) ;
1333
 
                }
1334
 
 
1335
 
                return (this._GetStyleText = function() { return stylesText ; })() ;
1336
 
        },
1337
 
 
1338
 
        /**
1339
 
         * Get the the collection used to compare the attributes defined in this
1340
 
         * style with attributes in an element. All information in it is lowercased.
1341
 
         */
1342
 
        _GetAttribsForComparison : function()
1343
 
        {
1344
 
                // If we have already computed it, just return it.
1345
 
                var attribs = this._GetAttribsForComparison_$ ;
1346
 
                if ( attribs )
1347
 
                        return attribs ;
1348
 
 
1349
 
                attribs = new Object() ;
1350
 
 
1351
 
                // Loop through all defined attributes.
1352
 
                var styleAttribs = this._StyleDesc.Attributes ;
1353
 
                if ( styleAttribs )
1354
 
                {
1355
 
                        for ( var styleAtt in styleAttribs )
1356
 
                        {
1357
 
                                attribs[ styleAtt.toLowerCase() ] = styleAttribs[ styleAtt ].toLowerCase() ;
1358
 
                        }
1359
 
                }
1360
 
 
1361
 
                // Includes the style definitions.
1362
 
                if ( this._GetStyleText().length > 0 )
1363
 
                {
1364
 
                        attribs['style'] = this._GetStyleText().toLowerCase() ;
1365
 
                }
1366
 
 
1367
 
                // Appends the "length" information to the object.
1368
 
                FCKTools.AppendLengthProperty( attribs, '_length' ) ;
1369
 
 
1370
 
                // Return it, saving it to the next request.
1371
 
                return ( this._GetAttribsForComparison_$ = attribs ) ;
1372
 
        },
1373
 
 
1374
 
        /**
1375
 
         * Get the the collection used to compare the elements and attributes,
1376
 
         * defined in this style overrides, with other element. All information in
1377
 
         * it is lowercased.
1378
 
         */
1379
 
        _GetOverridesForComparison : function()
1380
 
        {
1381
 
                // If we have already computed it, just return it.
1382
 
                var overrides = this._GetOverridesForComparison_$ ;
1383
 
                if ( overrides )
1384
 
                        return overrides ;
1385
 
 
1386
 
                overrides = new Object() ;
1387
 
 
1388
 
                var overridesDesc = this._StyleDesc.Overrides ;
1389
 
 
1390
 
                if ( overridesDesc )
1391
 
                {
1392
 
                        // The override description can be a string, object or array.
1393
 
                        // Internally, well handle arrays only, so transform it if needed.
1394
 
                        if ( !FCKTools.IsArray( overridesDesc ) )
1395
 
                                overridesDesc = [ overridesDesc ] ;
1396
 
 
1397
 
                        // Loop through all override definitions.
1398
 
                        for ( var i = 0 ; i < overridesDesc.length ; i++ )
1399
 
                        {
1400
 
                                var override = overridesDesc[i] ;
1401
 
                                var elementName ;
1402
 
                                var overrideEl ;
1403
 
                                var attrs ;
1404
 
 
1405
 
                                // If can be a string with the element name.
1406
 
                                if ( typeof override == 'string' )
1407
 
                                        elementName = override.toLowerCase() ;
1408
 
                                // Or an object.
1409
 
                                else
1410
 
                                {
1411
 
                                        elementName = override.Element ? override.Element.toLowerCase() : this.Element ;
1412
 
                                        attrs = override.Attributes ;
1413
 
                                }
1414
 
 
1415
 
                                // We can have more than one override definition for the same
1416
 
                                // element name, so we attempt to simply append information to
1417
 
                                // it if it already exists.
1418
 
                                overrideEl = overrides[ elementName ] || ( overrides[ elementName ] = {} ) ;
1419
 
 
1420
 
                                if ( attrs )
1421
 
                                {
1422
 
                                        // The returning attributes list is an array, because we
1423
 
                                        // could have different override definitions for the same
1424
 
                                        // attribute name.
1425
 
                                        var overrideAttrs = ( overrideEl.Attributes = overrideEl.Attributes || new Array() ) ;
1426
 
                                        for ( var attName in attrs )
1427
 
                                        {
1428
 
                                                // Each item in the attributes array is also an array,
1429
 
                                                // where [0] is the attribute name and [1] is the
1430
 
                                                // override value.
1431
 
                                                overrideAttrs.push( [ attName.toLowerCase(), attrs[ attName ] ] ) ;
1432
 
                                        }
1433
 
                                }
1434
 
                        }
1435
 
                }
1436
 
 
1437
 
                return ( this._GetOverridesForComparison_$ = overrides ) ;
1438
 
        },
1439
 
 
1440
 
        /*
1441
 
         * Create and object containing all attributes specified in an element,
1442
 
         * added by a "_length" property. All values are lowercased.
1443
 
         */
1444
 
        _CreateElementAttribsForComparison : function( element )
1445
 
        {
1446
 
                var attribs = new Object() ;
1447
 
                var attribsCount = 0 ;
1448
 
 
1449
 
                for ( var i = 0 ; i < element.attributes.length ; i++ )
1450
 
                {
1451
 
                        var att = element.attributes[i] ;
1452
 
 
1453
 
                        if ( att.specified )
1454
 
                        {
1455
 
                                attribs[ att.nodeName.toLowerCase() ] = FCKDomTools.GetAttributeValue( element, att ).toLowerCase() ;
1456
 
                                attribsCount++ ;
1457
 
                        }
1458
 
                }
1459
 
 
1460
 
                attribs._length = attribsCount ;
1461
 
 
1462
 
                return attribs ;
1463
 
        },
1464
 
 
1465
 
        /**
1466
 
         * Checks is the element attributes have a perfect match with the style
1467
 
         * attributes.
1468
 
         */
1469
 
        _CheckAttributesMatch : function( element, styleAttribs )
1470
 
        {
1471
 
                // Loop through all specified attributes. The same number of
1472
 
                // attributes must be found and their values must match to
1473
 
                // declare them as equal.
1474
 
 
1475
 
                var elementAttrbs = element.attributes ;
1476
 
                var matchCount = 0 ;
1477
 
 
1478
 
                for ( var i = 0 ; i < elementAttrbs.length ; i++ )
1479
 
                {
1480
 
                        var att = elementAttrbs[i] ;
1481
 
                        if ( att.specified )
1482
 
                        {
1483
 
                                var attName = att.nodeName.toLowerCase() ;
1484
 
                                var styleAtt = styleAttribs[ attName ] ;
1485
 
 
1486
 
                                // The attribute is not defined in the style.
1487
 
                                if ( !styleAtt )
1488
 
                                        break ;
1489
 
 
1490
 
                                // The values are different.
1491
 
                                if ( styleAtt != FCKDomTools.GetAttributeValue( element, att ).toLowerCase() )
1492
 
                                        break ;
1493
 
 
1494
 
                                matchCount++ ;
1495
 
                        }
1496
 
                }
1497
 
 
1498
 
                return ( matchCount == styleAttribs._length ) ;
1499
 
        }
1500
 
} ;