Changeset 824


Ignore:
Timestamp:
09/14/07 19:55:41 (7 years ago)
Author:
martinkou
Message:

Changed the justify commands to use DomRangeIterator for processing blocks.
Added the ability to use CSS classes for justify commands for XHTML 1.1 compliancy.
Improved the justify command buttons to highlight the language dependent default text alignment when no justifying styles are applied.
Factored out and removed redundant code in FCKDomRange.CreateBookmark2() and FCKDomRange.MoveToBookmark2().

Location:
FCKeditor/trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • FCKeditor/trunk/editor/_source/classes/fckdomrange.js

    r823 r824  
    359359                // Then, we record down the precise position of the container nodes 
    360360                // by walking up the DOM tree and counting their childNode index 
    361                 var curNode = this._Range.startContainer ; 
    362                 while ( curNode && curNode != this.Window.document.documentElement ) 
    363                 { 
    364                         var curParent = curNode.parentNode ; 
    365                         for( var i = 0 ; i < curParent.childNodes.length ; i++ ) 
    366                         { 
    367                                 if ( curParent.childNodes.item( i ) == curNode ) 
    368                                 { 
    369                                         bookmark.Start.unshift( i ) ; 
    370                                         break ; 
    371                                 } 
    372                         } 
    373                         curNode = curParent; 
    374                 } 
    375                 curNode = this._Range.endContainer; 
    376                 while ( curNode && curNode != this.Window.document.documentElement ) 
    377                 { 
    378                         var curParent = curNode.parentNode; 
    379                         for ( var i = 0 ; i < curParent.childNodes.length ; i++ ) 
    380                         { 
    381                                 if ( curParent.childNodes.item( i ) == curNode ) 
    382                                 { 
    383                                         bookmark.End.unshift( i ); 
    384                                         break; 
    385                                 } 
    386                         } 
    387                         curNode = curParent; 
    388                 } 
     361                bookmark.Start = FCKDomTools.GetNodeAddress( this._Range.startContainer ).concat( bookmark.Start ) ; 
     362                bookmark.End = FCKDomTools.GetNodeAddress( this._Range.endContainer ).concat( bookmark.End ) ; 
    389363                return bookmark; 
    390364        }, 
     
    393367        { 
    394368                // Reverse the childNode counting algorithm in CreateBookmark2() 
    395                 var curStart = this.Window.document.documentElement ; 
    396                 var curEnd = this.Window.document.documentElement ; 
    397                 for ( var i = 0 ; i < bookmark.Start.length - 1 ; i++ ) 
    398                         curStart = curStart.childNodes.item( bookmark.Start[ i ] ) ; 
    399                 for ( var i = 0 ; i < bookmark.End.length - 1 ; i++ ) 
    400                         curEnd = curEnd.childNodes.item( bookmark.End[ i ] ) ; 
     369                var curStart = FCKDomTools.GetNodeFromAddress( this.Window.document, bookmark.Start.slice( 0, -1 ) ) ; 
     370                var curEnd = FCKDomTools.GetNodeFromAddress( this.Window.document, bookmark.End.slice( 0, -1 ) ) ; 
    401371 
    402372                // Generate the W3C Range object and update relevant data 
  • FCKeditor/trunk/editor/_source/commandclasses/fckjustifycommands.js

    r807 r824  
    2424var FCKJustifyCommand = function( alignValue ) 
    2525{ 
    26         this.AlignVaue = alignValue ; 
     26        this.AlignValue = alignValue ; 
    2727        this.CurrentState = FCK_TRISTATE_DISABLED ; 
     28        this.DefaultAlign = ( alignValue == 'left' && FCKConfig.ContentLangDirection.IEquals( 'ltr' ) ) || 
     29                        ( alignValue == 'right' && FCKConfig.ContentLangDirection.IEquals( 'rtl' ) ) ; 
    2830} 
    2931 
     
    3436                var range = new FCKDomRange( FCK.EditorWindow ) ; 
    3537                range.MoveToSelection() ; 
     38 
     39                // Store a bookmark of the selection since the paragraph iterator might change the DOM tree and break selections. 
    3640                var bookmark = range.CreateBookmark() ; 
    37                 var paragraphs = range.GetParagraphs() ; 
     41                var iterator = new FCKDomRangeIterator( range ) ; 
     42                var block = null ; 
     43                var cssClassName = this._GetCSSClassName() ; 
    3844 
    39                 while ( paragraphs.length > 0 ) 
     45                // Apply alignment setting for each paragraph. 
     46                while ( ( block = iterator.GetNextParagraph() ) ) 
    4047                { 
    41                         range = paragraphs.shift() ; 
    42                         if ( range.GetText().search( /^[\r\n\t ]*$/ ) == 0 ) 
    43                                 continue ; 
     48                        block.removeAttribute( 'align' ) ; 
    4449 
    45                         if ( range.StartContainer == range.Window.document.body ) 
    46                                 range.FixBlock( true ) ; 
    47                         range.StartContainer.removeAttribute( 'align' ) ; 
    48  
    49                         if ( this.CurrentState == FCK_TRISTATE_OFF) 
    50                                 range.StartContainer.style.textAlign = this.AlignVaue ; 
    51                         else if ( this.CurrentState == FCK_TRISTATE_ON ) 
    52                                 range.StartContainer.style.textAlign = '' ; 
    53  
    54                         var nextNode = range.EndNode ; 
    55                         while ( nextNode.lastChild ) 
    56                                 nextNode = nextNode.lastChild ; 
    57                         currentNode = nextNode = FCKDomTools.GetNextSourceNode( nextNode ) ; 
     50                        if ( cssClassName ) 
     51                        { 
     52                                block.className = block.className.replace( FCKConfig.JustifyClassPattern, ' ' ) ; 
     53                                if ( block.className.length && block.className.charAt( block.className.length - 1 ) != ' ' ) 
     54                                        block.className += ' ' + cssClassName ; 
     55                                else 
     56                                        block.className += cssClassName ; 
     57                        } 
     58                        else 
     59                        { 
     60                                if ( this.CurrentState == FCK_TRISTATE_OFF) 
     61                                        block.style.textAlign = this.AlignValue ; 
     62                                else if ( this.CurrentState == FCK_TRISTATE_ON ) 
     63                                        block.style.textAlign = '' ; 
     64                        } 
    5865                } 
    5966 
     67                // Restore previous selection. 
    6068                range.MoveToBookmark( bookmark ) ; 
    6169                range.Select() ; 
     
    7179                } 
    7280 
    73                 var nearestBlock = FCKSelection.GetParentBlock() ; 
     81                // Retrieve the first selected block. 
     82                var firstBlock = null ; 
     83                if ( FCKBrowserInfo.IsIE ) 
     84                { 
     85                        var range = FCK.EditorDocument.selection.createRange() ; 
     86                        range.collapse( true ) ; 
     87                        firstBlock = ( new FCKElementPath( range.parentElement() ) ).Block ; 
     88                } 
     89                else 
     90                { 
     91                        var sel = FCK.EditorWindow.getSelection() ; 
     92                        if ( ! sel || sel.rangeCount < 0 ) 
     93                        { 
     94                                this.CurrentState = FCK_TRISTATE_DISABLED ; 
     95                                return this.CurrentState ; 
     96                        } 
     97                        var range = sel.getRangeAt( 0 ) ; 
     98                        firstBlock = ( new FCKElementPath( range.startContainer ) ).Block ; 
     99                } 
    74100 
    75                 if ( ! nearestBlock ) 
     101                if ( ! firstBlock || firstBlock.nodeName.IEquals( 'body' ) ) 
    76102                { 
    77103                        this.CurrentState = FCK_TRISTATE_OFF ; 
     
    79105                } 
    80106 
    81                 if ( nearestBlock.align == this.AlignVaue || nearestBlock.style.textAlign == this.AlignVaue  ) 
     107                // See if the desired style is already applied to the first block. 
     108                var cssClassName = this._GetCSSClassName() ; 
     109                if ( ! cssClassName ) 
    82110                { 
    83                         this.CurrentState = FCK_TRISTATE_ON ; 
    84                         return this.CurrentState ; 
     111                        if ( ! firstBlock.align && ! firstBlock.style.textAlign && this.DefaultAlign ) 
     112                                return FCK_TRISTATE_ON ; 
     113                        this.CurrentState = ( firstBlock.align == this.AlignValue || firstBlock.style.textAlign == this.AlignValue ? 
     114                                        FCK_TRISTATE_ON : FCK_TRISTATE_OFF ) ; 
    85115                } 
    86116                else 
    87117                { 
    88                         this.CurrentState = FCK_TRISTATE_OFF ; 
    89                         return this.CurrentState ; 
     118                        if ( firstBlock.className.search( FCKConfig.JustifyClassPattern ) == -1 && this.DefaultAlign ) 
     119                                return FCK_TRISTATE_ON ; 
     120                        this.CurrentState = ( firstBlock.className.search( new RegExp( '(^|\\s+)' + cssClassName + '($|\\s+)' ) ) == -1 ?  
     121                                                FCK_TRISTATE_OFF : FCK_TRISTATE_ON ) ; 
    90122                } 
     123 
     124                return this.CurrentState ; 
     125        }, 
     126 
     127        _GetCSSClassName : function() 
     128        { 
     129                var cssClassName = null ; 
     130                switch ( this.AlignValue ) 
     131                { 
     132                        case 'left' : 
     133                                cssClassName = FCKConfig.LeftJustifyClass ; 
     134                                break ; 
     135                        case 'right' : 
     136                                cssClassName = FCKConfig.RightJustifyClass ; 
     137                                break ; 
     138                        case 'center' : 
     139                                cssClassName = FCKConfig.CenterJustifyClass ; 
     140                                break ; 
     141                        case 'justify' : 
     142                                cssClassName = FCKConfig.FullJustifyClass ; 
     143                                break ; 
     144                } 
     145                return cssClassName ; 
    91146        } 
    92147} ; 
  • FCKeditor/trunk/editor/_source/internals/fckdomtools.js

    r821 r824  
    532532                range.Release( !!reusableRange ) ; 
    533533        }, 
     534 
     535        /** 
     536         * Retrieves a uniquely identifiable tree address of a DOM tree node. 
     537         * The tree address returns is an array of integers, with each integer indicating a child index from a DOM tree node, 
     538         * starting from document.documentElement. 
     539         * 
     540         * For example, assuming <body> is the second child from <html> (<head> being the first), and we'd like to address 
     541         * the third child under the fourth child of body, the tree address returned would be: 
     542         * [1, 3, 2] 
     543         * 
     544         * The tree address cannot be used for finding back the DOM tree node once the DOM tree structure has been modified. 
     545         */ 
     546        GetNodeAddress : function( node ) 
     547        { 
     548                var retval = [] ; 
     549                while ( node && node != node.ownerDocument.documentElement ) 
     550                { 
     551                        retval.unshift( this.GetIndexOf( node ) ) ; 
     552                        node = node.parentNode ; 
     553                } 
     554                return retval ; 
     555        }, 
     556 
     557        /** 
     558         * The reverse transformation of FCKDomTools.GetNodeAddress(). This function returns the DOM node pointed to by its 
     559         * index address. 
     560         */ 
     561        GetNodeFromAddress : function( doc, addr ) 
     562        { 
     563                var cursor = doc.documentElement ; 
     564                for ( var i = 0 ; i < addr.length ; i++ ) 
     565                        cursor = cursor.childNodes[ addr[i] ] ; 
     566                return cursor ; 
     567        }, 
    534568         
    535569        CloneElement : function( element ) 
  • FCKeditor/trunk/fckconfig.js

    r774 r824  
    5959FCKConfig.DefaultLanguage               = 'en' ; 
    6060FCKConfig.ContentLangDirection  = 'ltr' ; 
     61 
     62// The distance of an indentation step, in pixels. 
     63FCKConfig.IndentLength = 25 ; 
    6164 
    6265FCKConfig.ProcessHTMLEntities   = true ; 
     
    291294FCKConfig.SmileyWindowWidth             = 320 ; 
    292295FCKConfig.SmileyWindowHeight    = 240 ; 
     296 
     297// XHTML 1.1 compliant options example 
     298/* 
     299FCKConfig.JustifyClassPattern = /(^|\s+)Justify(Left|Right|Center|Full)($|\s+)/ ; 
     300FCKConfig.LeftJustifyClass = 'JustifyLeft' ; 
     301FCKConfig.RightJustifyClass = 'JustifyRight' ; 
     302FCKConfig.CenterJustifyClass = 'JustifyCenter' ; 
     303FCKConfig.FullJustifyClass = 'JustifyFull' ; 
     304*/ 
Note: See TracChangeset for help on using the changeset viewer.
© 2003 – 2012 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy