Changeset 774


Ignore:
Timestamp:
09/04/2007 04:34:12 PM (7 years ago)
Author:
fredck
Message:

Moved branches/features/style to trunk. Introducing the new Style System.

Location:
FCKeditor/trunk
Files:
12 added
4 deleted
35 edited

Legend:

Unmodified
Added
Removed
  • FCKeditor/trunk/_test/manual/fckdomrange/test1.html

    r619 r774  
    3535        <script type="text/javascript"> 
    3636 
    37 FCKConfig.Debug = true ; 
     37FCKConfig.Debug = false ; 
    3838FCKConfig.BasePath = '../../../editor/' ; 
    3939 
  • FCKeditor/trunk/editor/_source/classes/fckdomrange.js

    r720 r774  
    3434        _UpdateElementInfo : function() 
    3535        { 
    36                 if ( !this._Range ) 
     36                var innerRange = this._Range ; 
     37 
     38                if ( !innerRange ) 
    3739                        this.Release( true ) ; 
    3840                else 
    3941                { 
    40                         var eStart      = this._Range.startContainer ; 
    41                         var eEnd        = this._Range.endContainer ; 
     42                        // For text nodes, the node itself is the StartNode. 
     43                        var eStart      = innerRange.startContainer ; 
     44                        var eEnd        = innerRange.endContainer ; 
    4245 
    4346                        var oElementPath = new FCKElementPath( eStart ) ; 
    44                         this.StartContainer             = oElementPath.LastElement ; 
     47                        this.StartNode                  = eStart.nodeType == 3 ? eStart : eStart.childNodes[ innerRange.startOffset ] ; 
     48                        this.StartContainer             = eStart ; 
    4549                        this.StartBlock                 = oElementPath.Block ; 
    4650                        this.StartBlockLimit    = oElementPath.BlockLimit ; 
     
    4852                        if ( eStart != eEnd ) 
    4953                                oElementPath = new FCKElementPath( eEnd ) ; 
    50                         this.EndContainer               = oElementPath.LastElement ; 
     54                        this.EndNode                    = eEnd.nodeType == 3 ? eEnd : eEnd.childNodes[ innerRange.endOffset ] ; 
     55                        this.EndContainer               = eEnd ; 
    5156                        this.EndBlock                   = oElementPath.Block ; 
    5257                        this.EndBlockLimit              = oElementPath.BlockLimit ; 
     
    215220        }, 
    216221 
    217         CreateBookmark : function() 
     222        // This is an "intrusive" way to create a bookmark. It includes <span> tags 
     223        // in the range boundaries. The advantage of it is that it is possible to 
     224        // handle DOM mutations when moving back to the bookmark. 
     225        // Attention: the inclusion of nodes in the DOM is a design choice and 
     226        // should not be changes as there are other points in the code that may be 
     227        // using those nodes to perform operations. See GetBookmarkNode. 
     228        // For performance, includeNodes=true if intended to SelectBookmark. 
     229        CreateBookmark : function( includeNodes ) 
    218230        { 
    219231                // Create the bookmark info (random IDs). 
    220232                var oBookmark = 
    221233                { 
    222                         StartId : 'fck_dom_range_start_' + (new Date()).valueOf() + '_' + Math.floor(Math.random()*1000), 
    223                         EndId   : 'fck_dom_range_end_' + (new Date()).valueOf() + '_' + Math.floor(Math.random()*1000) 
     234                        StartId : (new Date()).valueOf() + Math.floor(Math.random()*1000) + 'S', 
     235                        EndId   : (new Date()).valueOf() + Math.floor(Math.random()*1000) + 'E' 
    224236                } ; 
    225237 
     
    233245                        eSpan = oDoc.createElement( 'span' ) ; 
    234246                        eSpan.id = oBookmark.EndId ; 
    235                         eSpan.innerHTML = '&nbsp;' ;    // For IE, it must have something inside, otherwise it may be removed during operations. 
     247                        eSpan.setAttribute( '_fck_bookmark', true ) ; 
     248 
     249                        // For IE, it must have something inside, otherwise it may be 
     250                        // removed during DOM operations. 
     251//                      if ( FCKBrowserInfo.IsIE ) 
     252                                eSpan.innerHTML = '&nbsp;' ; 
    236253 
    237254                        oClone = this.Clone() ; 
    238255                        oClone.Collapse( false ) ; 
    239256                        oClone.InsertNode( eSpan ) ; 
     257 
     258                        if ( includeNodes ) 
     259                                oBookmark.EndNode = eSpan ; 
    240260                } 
    241261 
    242262                eSpan = oDoc.createElement( 'span' ) ; 
    243263                eSpan.id = oBookmark.StartId ; 
    244                 eSpan.innerHTML = '&nbsp;' ;    // For IE, it must have something inside, otherwise it may be removed during operations. 
     264                eSpan.setAttribute( '_fck_bookmark', true ) ; 
     265 
     266                // For IE, it must have something inside, otherwise it may be removed 
     267                // during DOM operations. 
     268//              if ( FCKBrowserInfo.IsIE ) 
     269                        eSpan.innerHTML = '&nbsp;' ; 
    245270 
    246271                oClone = this.Clone() ; 
     
    248273                oClone.InsertNode( eSpan ) ; 
    249274 
     275                if ( includeNodes ) 
     276                        oBookmark.StartNode = eSpan ; 
     277 
    250278                return oBookmark ; 
    251279        }, 
    252280 
     281        // This one should be a part of a hypothetic "bookmark" object. 
     282        GetBookmarkNode : function( bookmark, start ) 
     283        { 
     284                var doc = this.Window.document ; 
     285 
     286                if ( start ) 
     287                        return bookmark.StartNode || doc.getElementById( bookmark.StartId ) ; 
     288                else 
     289                        return bookmark.EndNode || doc.getElementById( bookmark.EndId ) ; 
     290        }, 
     291 
    253292        MoveToBookmark : function( bookmark, preserveBookmark ) 
    254293        { 
    255                 var oDoc = this.Window.document ; 
    256  
    257                 var eStartSpan  =  oDoc.getElementById( bookmark.StartId ) ; 
    258                 var eEndSpan    =  oDoc.getElementById( bookmark.EndId ) ; 
     294                var eStartSpan  = this.GetBookmarkNode( bookmark, true ) ; 
     295                var eEndSpan    = this.GetBookmarkNode( bookmark, false ) ; 
    259296 
    260297                this.SetStart( eStartSpan, 3 ) ; 
     
    263300                        FCKDomTools.RemoveNode( eStartSpan ) ; 
    264301 
    265                 // If collapsed, the start span will not be available. 
     302                // If collapsed, the end span will not be available. 
    266303                if ( eEndSpan ) 
    267304                { 
     
    284321                if ( ! this._Range ) 
    285322                        return { "Start" : 0, "End" : 0 } ; 
    286                          
     323 
    287324                // First, we record down the offset values 
    288                 var bookmark =  
     325                var bookmark = 
    289326                { 
    290327                        "Start" : [ this._Range.startOffset ], 
     
    424461                switch ( unit ) 
    425462                { 
     463                        // Expand the range to include all inline parent elements if we are 
     464                        // are in their boundary limits. 
     465                        // For example (where [ ] are the range limits): 
     466                        //      Before =>               Some <b>[<i>Some sample text]</i></b>. 
     467                        //      After =>                Some [<b><i>Some sample text</i></b>]. 
     468                        case 'inline_elements' : 
     469                                // Expand the start boundary. 
     470                                if ( this._Range.startOffset == 0 ) 
     471                                { 
     472                                        oNode = this._Range.startContainer ; 
     473 
     474                                        if ( oNode.nodeType != 1 ) 
     475                                                oNode = oNode.parentNode ; 
     476 
     477                                        while ( FCKListsLib.InlineNonEmptyElements[ oNode.nodeName.toLowerCase() ] ) 
     478                                        { 
     479                                                this._Range.setStartBefore( oNode ) ; 
     480 
     481                                                if ( oNode != oNode.parentNode.firstChild ) 
     482                                                        break ; 
     483 
     484                                                oNode = oNode.parentNode ; 
     485                                        } 
     486                                } 
     487 
     488                                // Expand the end boundary. 
     489                                oNode = this._Range.endContainer ; 
     490                                var offset = this._Range.endOffset ; 
     491 
     492                                if ( ( oNode.nodeType == 3 && offset >= oNode.nodeValue.length ) || ( oNode.nodeType == 1 && offset >= oNode.childNodes.length ) || ( oNode.nodeType != 1 && oNode.nodeType != 3 ) ) 
     493                                { 
     494                                        if ( oNode.nodeType != 1 ) 
     495                                                oNode = oNode.parentNode ; 
     496 
     497                                        while ( FCKListsLib.InlineNonEmptyElements[ oNode.nodeName.toLowerCase() ] ) 
     498                                        { 
     499                                                this._Range.setEndAfter( oNode ) ; 
     500 
     501                                                if ( oNode != oNode.parentNode.lastChild ) 
     502                                                        break ; 
     503 
     504                                                oNode = oNode.parentNode ; 
     505                                        } 
     506                                } 
     507 
     508                                break ; 
     509 
    426510                        case 'block_contents' : 
    427511                                if ( this.StartBlock ) 
     
    531615                                if ( !eStartBlock ) 
    532616                                { 
    533                                         eStartBlock = this._FixBlock( true ) ; 
    534                                         eEndBlock       = this.EndBlock ;       // _FixBlock may have fixed the EndBlock too. 
     617                                        eStartBlock = this.FixBlock( true ) ; 
     618                                        eEndBlock       = this.EndBlock ;       // FixBlock may have fixed the EndBlock too. 
    535619                                } 
    536620 
    537621                                if ( !eEndBlock ) 
    538                                         eEndBlock = this._FixBlock( false ) ; 
     622                                        eEndBlock = this.FixBlock( false ) ; 
    539623                        } 
    540624 
     
    546630                                this.DeleteContents() ; 
    547631 
    548                         if ( eStartBlock && eEndBlock &&  eStartBlock == eEndBlock ) 
     632                        if ( eStartBlock && eEndBlock && eStartBlock == eEndBlock ) 
    549633                        { 
    550634                                if ( bIsStartOfBlock ) 
     
    596680 
    597681        // Transform a block without a block tag in a valid block (orphan text in the body or td, usually). 
    598         _FixBlock : function( isStart ) 
     682        FixBlock : function( isStart ) 
    599683        { 
    600684                // Bookmark the range so we can restore it later. 
     
    628712                        this.Window = null ; 
    629713 
     714                this.StartNode = null ; 
    630715                this.StartContainer = null ; 
    631716                this.StartBlock = null ; 
    632717                this.StartBlockLimit = null ; 
     718                this.EndNode = null ; 
    633719                this.EndContainer = null ; 
    634720                this.EndBlock = null ; 
    635721                this.EndBlockLimit = null ; 
    636722                this._Range = null ; 
     723        }, 
     724 
     725        CheckHasRange : function() 
     726        { 
     727                return ( this._Range && true ) ; 
    637728        } 
    638729} ; 
  • FCKeditor/trunk/editor/_source/classes/fckdomrange_gecko.js

    r694 r774  
    7272        } 
    7373} 
     74 
     75// Not compatible with bookmark created with CreateBookmark2. 
     76// The bookmark nodes will be deleted from the document. 
     77FCKDomRange.prototype.SelectBookmark = function( bookmark ) 
     78{ 
     79        var domRange = this.Window.document.createRange() ; 
     80 
     81        var startNode   = this.GetBookmarkNode( bookmark, true ) ; 
     82        var endNode             = this.GetBookmarkNode( bookmark, false ) ; 
     83 
     84        domRange.setStart( startNode.parentNode, FCKDomTools.GetIndexOf( startNode ) ) ; 
     85        FCKDomTools.RemoveNode( startNode ) ; 
     86 
     87        if ( endNode ) 
     88        { 
     89                domRange.setEnd( endNode.parentNode, FCKDomTools.GetIndexOf( endNode ) ) ; 
     90                FCKDomTools.RemoveNode( endNode ) ; 
     91        } 
     92         
     93        var selection = this.Window.getSelection() ; 
     94        selection.removeAllRanges() ; 
     95        selection.addRange( domRange ) ; 
     96} 
  • FCKeditor/trunk/editor/_source/classes/fckdomrange_ie.js

    r733 r774  
    7070{ 
    7171        if ( this._Range ) 
    72         { 
    73                 var bIsCollapsed = this.CheckIsCollapsed() ; 
     72                this.SelectBookmark( this.CreateBookmark( true ) ) ; 
     73} 
    7474 
    75                 // Create marker tags for the start and end boundaries. 
    76                 var eStartMarker        = this._GetRangeMarkerTag( true ) ; 
     75// Not compatible with bookmark created with CreateBookmark2. 
     76// The bookmark nodes will be deleted from the document. 
     77FCKDomRange.prototype.SelectBookmark = function( bookmark ) 
     78{ 
     79        var bIsCollapsed = this.CheckIsCollapsed() ; 
    7780                var bIsStartMakerAlone ; 
    7881 
    79                 if ( !bIsCollapsed ) 
    80                         var eEndMarker  = this._GetRangeMarkerTag( false ) ; 
     82        // Create marker tags for the start and end boundaries. 
     83        var eStartMarker        = this.GetBookmarkNode( bookmark, true ) ; 
     84         
     85        if ( !eStartMarker ) 
     86                return ; 
    8187 
    82                 // Create the main range which will be used for the selection. 
    83                 var oIERange = this.Window.document.body.createTextRange() ; 
     88        var eEndMarker ; 
     89        if ( !bIsCollapsed ) 
     90                eEndMarker = this.GetBookmarkNode( bookmark, false ) ; 
    8491 
    85                 // Position the range at the start boundary. 
    86                 oIERange.moveToElementText( eStartMarker ) ; 
    87                 oIERange.moveStart( 'character', 1 ) ; 
     92        // Create the main range which will be used for the selection. 
     93        var oIERange = this.Window.document.body.createTextRange() ; 
    8894 
    89                 if ( !bIsCollapsed ) 
     95        // Position the range at the start boundary. 
     96        oIERange.moveToElementText( eStartMarker ) ; 
     97        oIERange.moveStart( 'character', 1 ) ; 
     98 
     99        if ( eEndMarker ) 
     100        { 
     101                // Create a tool range for the end. 
     102                var oIERangeEnd = this.Window.document.body.createTextRange() ; 
     103 
     104                // Position the tool range at the end. 
     105                oIERangeEnd.moveToElementText( eEndMarker ) ; 
     106 
     107                // Move the end boundary of the main range to match the tool range. 
     108                oIERange.setEndPoint( 'EndToEnd', oIERangeEnd ) ; 
     109                oIERange.moveEnd( 'character', -1 ) ; 
     110        } 
     111        else 
     112                bIsStartMakerAlone = ( !eStartMarker.previousSibling || eStartMarker.previousSibling.nodeName.toLowerCase() == 'br' ) && !eStartMarker.nextSibing ; 
     113 
     114        if ( !this._Range ) 
     115                this._Range = this.CreateRange() ; 
     116 
     117        // Remove the markers (reset the position, because of the changes in the DOM tree). 
     118        this._Range.setStartBefore( eStartMarker ) ; 
     119        eStartMarker.parentNode.removeChild( eStartMarker ) ; 
     120 
     121        if ( bIsCollapsed ) 
     122        { 
     123                if ( bIsStartMakerAlone ) 
    90124                { 
    91                         // Create a tool range for the end. 
    92                         var oIERangeEnd = this.Window.document.body.createTextRange() ; 
     125                        // The following trick is needed so IE makes collapsed selections 
     126                        // inside empty blocks visible (expands the block). 
    93127 
    94                         // Position the tool range at the end. 
    95                         oIERangeEnd.moveToElementText( eEndMarker ) ; 
     128                        try 
     129                        { 
     130                                oIERange.pasteHTML( '&nbsp;' ) ; 
     131                                 
     132                                // Move the selection start to include the &nbsp;. 
     133                                oIERange.moveStart( 'character', -1 ) ; 
     134                        } 
     135                        catch (e){} 
    96136 
    97                         // Move the end boundary of the main range to match the tool range. 
    98                         oIERange.setEndPoint( 'EndToEnd', oIERangeEnd ) ; 
    99                         oIERange.moveEnd( 'character', -1 ) ; 
     137                        // The following must be done into a separate try block. (#1034) 
     138                        try 
     139                        {        
     140                                oIERange.select() ; 
     141                                this.Window.document.selection.clear() ; 
     142                        } 
     143                        catch (e){} 
    100144                } 
    101145                else 
    102                         bIsStartMakerAlone = ( !eStartMarker.previousSibling || eStartMarker.previousSibling.nodeName.toLowerCase() == 'br' ) && !eStartMarker.nextSibing ; 
    103  
    104                 // Remove the markers (reset the position, because of the changes in the DOM tree). 
    105                 this._Range.setStartBefore( eStartMarker ) ; 
    106                 eStartMarker.parentNode.removeChild( eStartMarker ) ; 
    107  
    108                 if ( bIsCollapsed ) 
    109                 { 
    110                         if ( bIsStartMakerAlone ) 
    111                         { 
    112                                 // The following trick is needed so IE makes collapsed selections 
    113                                 // inside empty blocks visible (expands the block). 
    114  
    115                                 try 
    116                                 { 
    117                                         oIERange.pasteHTML( '&nbsp;' ) ; 
    118                                          
    119                                         // Move the selection start to include the &nbsp;. 
    120                                         oIERange.moveStart( 'character', -1 ) ; 
    121                                 } 
    122                                 catch (e){} 
    123  
    124                                 // The following must be done into a separate try block. (#1034) 
    125                                 try 
    126                                 {        
    127                                         oIERange.select() ; 
    128                                         this.Window.document.selection.clear() ; 
    129                                 } 
    130                                 catch (e){} 
    131                         } 
    132                         else 
    133                                 oIERange.select() ; 
    134                 } 
    135                 else 
    136                 { 
    137                         this._Range.setEndBefore( eEndMarker ) ; 
    138                         eEndMarker.parentNode.removeChild( eEndMarker ) ; 
    139146                        oIERange.select() ; 
    140                 } 
     147        } 
     148        else 
     149        { 
     150                this._Range.setEndBefore( eEndMarker ) ; 
     151                eEndMarker.parentNode.removeChild( eEndMarker ) ; 
     152                oIERange.select() ; 
    141153        } 
    142154} 
     
    175187        return doc.getElementById( sMarkerId ) ; 
    176188} 
    177  
    178 FCKDomRange.prototype._GetRangeMarkerTag = function( toStart ) 
    179 { 
    180         // Get a range for the start boundary. 
    181         var oRange = this._Range ; 
    182  
    183         // insertNode() will add the node at the beginning of the Range, updating 
    184         // the endOffset if necessary. So, we can work with the current range in this case. 
    185         if ( !toStart ) 
    186         { 
    187                 oRange = oRange.cloneRange() ; 
    188                 oRange.collapse( toStart === true ) ; 
    189         } 
    190  
    191         var eSpan = this.Window.document.createElement( 'span' ) ; 
    192         eSpan.innerHTML = '&nbsp;' ; 
    193         oRange.insertNode( eSpan ) ; 
    194  
    195         return eSpan ; 
    196 } 
  • FCKeditor/trunk/editor/_source/classes/fckspecialcombo.js

    r741 r774  
    117117} 
    118118 
    119 FCKSpecialCombo.prototype.SelectItem = function( itemId ) 
    120 { 
    121         itemId = itemId ? itemId.toString().toLowerCase() : '' ; 
    122  
    123         var oDiv = this.Items[ itemId ] ; 
    124         if ( oDiv ) 
    125         { 
    126                 oDiv.className = oDiv.originalClass = 'SC_ItemSelected' ; 
    127                 oDiv.Selected = true ; 
     119FCKSpecialCombo.prototype.SelectItem = function( item ) 
     120{ 
     121        if ( typeof item == 'string' ) 
     122                item = this.Items[ item.toString().toLowerCase() ] ; 
     123 
     124        if ( item ) 
     125        { 
     126                item.className = item.originalClass = 'SC_ItemSelected' ; 
     127                item.Selected = true ; 
    128128        } 
    129129} 
     
    169169FCKSpecialCombo.prototype.SetLabel = function( text ) 
    170170{ 
    171         this.Label = text.length == 0 ? '&nbsp;' : text ; 
    172  
    173         if ( this._LabelEl ) 
    174         { 
    175                 this._LabelEl.innerHTML = this.Label ; 
     171        text = ( !text || text.length == 0 ) ? '&nbsp;' : text ; 
     172         
     173        if ( text == this.Label ) 
     174                return ; 
     175 
     176        this.Label = text ; 
     177 
     178        var labelEl = this._LabelEl ; 
     179        if ( labelEl ) 
     180        { 
     181                labelEl.innerHTML = text ; 
    176182 
    177183                // It may happen that the label is some HTML, including tags. This 
     
    179185                // combo will get the selection from the editing area. So we must 
    180186                // disable any kind of selection here. 
    181                 FCKTools.DisableSelection( this._LabelEl ) ; 
     187                FCKTools.DisableSelection( labelEl ) ; 
    182188        } 
    183189} 
  • FCKeditor/trunk/editor/_source/classes/fcktoolbarfontformatcombo.js

    r714 r774  
    2424var FCKToolbarFontFormatCombo = function( tooltip, style ) 
    2525{ 
     26        if ( tooltip === false ) 
     27                return ; 
     28 
    2629        this.CommandName = 'FontFormat' ; 
    2730        this.Label              = this.GetLabel() ; 
     
    3740 
    3841// Inherit from FCKToolbarSpecialCombo. 
    39 FCKToolbarFontFormatCombo.prototype = new FCKToolbarSpecialCombo ; 
    40  
    41 FCKToolbarFontFormatCombo.prototype.TypeOf = 'FCKToolbarFontFormatCombo' ;              // @Packager.RemoveLine 
     42FCKToolbarFontFormatCombo.prototype = new FCKToolbarStyleCombo( false ) ; 
    4243 
    4344FCKToolbarFontFormatCombo.prototype.GetLabel = function() 
     
    4647} 
    4748 
    48 FCKToolbarFontFormatCombo.prototype.CreateItems = function( targetSpecialCombo ) 
     49FCKToolbarFontFormatCombo.prototype.GetStyles = function() 
    4950{ 
    50         var oTargetDoc = targetSpecialCombo._Panel.Document ; 
    51  
    52         // Add the Editor Area CSS to the panel to create a realistic preview. 
    53         FCKTools.AppendStyleSheet( oTargetDoc, FCKConfig.ToolbarComboPreviewCSS ) ; 
    54         FCKTools.AppendStyleString( oTargetDoc, FCKConfig.EditorAreaStyles ) ; 
    55  
    56         // Add ID and Class to the body 
    57         FCKConfig.ApplyBodyAttributes( oTargetDoc.body ) ; 
     51        var styles = {} ; 
    5852 
    5953        // Get the format names from the language file. 
     
    6963                h5              : aNames[7], 
    7064                h6              : aNames[8], 
    71                 div             : aNames[9] 
     65                div             : aNames[9] || ( aNames[0] + ' (DIV)') 
    7266        } ; 
     67         
     68        // Get the available formats from the configuration file. 
     69        var elements = FCKConfig.FontFormats.split(';') ; 
    7370 
    74         // Get the available formats from the configuration file. 
    75         var aTags = FCKConfig.FontFormats.split(';') ; 
     71        for ( var i = 0 ; i < elements.length ; i++ ) 
     72        { 
     73                var elementName = elements[ i ] ; 
     74                var style = FCKStyles.GetStyle( '_FCK_' + elementName ) ; 
     75                style.Label = oNames[ elementName ] ; 
     76                styles[ '_FCK_' + elementName ] = style ; 
     77        } 
    7678 
    77         for ( var i = 0 ; i < aTags.length ; i++ ) 
     79        return styles ; 
     80} 
     81 
     82FCKToolbarFontFormatCombo.prototype.RefreshActiveItems = function( targetSpecialCombo ) 
     83{ 
     84        var startElement = FCKSelection.GetBoundaryParentElement( true ) ; 
     85 
     86        if ( startElement ) 
    7887        { 
    79                 // Support for DIV in Firefox has been reintroduced on version 2.2. 
    80 //              if ( aTags[i] == 'div' && FCKBrowserInfo.IsGecko ) 
    81 //                      continue ; 
     88                var path = new FCKElementPath( startElement ) ; 
     89                var blockElement = path.Block ; 
    8290 
    83                 var sTag        = aTags[i] ; 
    84                 var sLabel      = oNames[sTag] ; 
     91                if ( blockElement ) 
     92                { 
     93                        for ( var i in targetSpecialCombo.Items ) 
     94                        { 
     95                                var item = targetSpecialCombo.Items[i] ; 
     96                                var style = item.Style ; 
    8597 
    86                 if ( sTag == 'p' ) 
    87                         this.NormalLabel = sLabel ; 
     98                                if ( style.CheckElementRemovable( blockElement ) ) 
     99                                { 
     100                                        targetSpecialCombo.SetLabel( style.Label ) ; 
     101                                        return ; 
     102                                } 
     103                        } 
     104                } 
     105        } 
    88106 
    89                 this._Combo.AddItem( sTag, '<div class="BaseFont"><' + sTag + '>' + sLabel + '</' + sTag + '></div>', sLabel ) ; 
     107        targetSpecialCombo.SetLabel( this.DefaultLabel ) ; 
     108} 
     109 
     110FCKToolbarFontFormatCombo.prototype.StyleCombo_OnBeforeClick = function( targetSpecialCombo ) 
     111{ 
     112        // Clear the current selection. 
     113        targetSpecialCombo.DeselectAll() ; 
     114 
     115        var startElement = FCKSelection.GetBoundaryParentElement( true ) ; 
     116 
     117        if ( startElement ) 
     118        { 
     119                var path = new FCKElementPath( startElement ) ; 
     120                var blockElement = path.Block ; 
     121 
     122                for ( var i in targetSpecialCombo.Items ) 
     123                { 
     124                        var item = targetSpecialCombo.Items[i] ; 
     125                        var style = item.Style ; 
     126 
     127                        if ( style.CheckElementRemovable( blockElement ) ) 
     128                        { 
     129                                targetSpecialCombo.SelectItem( item ) ; 
     130                                return ; 
     131                        } 
     132                } 
    90133        } 
    91134} 
    92  
    93 if ( FCKBrowserInfo.IsIE ) 
    94 { 
    95         FCKToolbarFontFormatCombo.prototype.RefreshActiveItems = function( combo, value ) 
    96         { 
    97 //              FCKDebug.Output( 'FCKToolbarFontFormatCombo Value: ' + value ) ; 
    98  
    99                 // IE returns normal for DIV and P, so to avoid confusion, we will not show it as normal. 
    100                 if ( value == this.NormalLabel ) 
    101                 { 
    102                         if ( combo.Label != '&nbsp;' ) 
    103                                 combo.DeselectAll(true) ; 
    104                                  
    105                         combo.SetLabel( this.DefaultLabel ) ; 
    106                 } 
    107                 else 
    108                 { 
    109                         if ( this._LastValue == value ) 
    110                                 return ; 
    111  
    112                         if ( !value || value.length == 0 ) 
    113                         { 
    114                                 combo.DeselectAll() ; 
    115                                 combo.SetLabel( this.DefaultLabel ) ; 
    116                         } 
    117                          
    118                         combo.SelectItemByLabel( value, true ) ; 
    119                 } 
    120  
    121                 this._LastValue = value ; 
    122         } 
    123 } 
  • FCKeditor/trunk/editor/_source/classes/fcktoolbarfontscombo.js

    r714 r774  
    2828        this.Tooltip    = tooltip ? tooltip : this.Label ; 
    2929        this.Style              = style ? style : FCK_TOOLBARITEM_ICONTEXT ; 
    30          
     30 
    3131        this.DefaultLabel = FCKConfig.DefaultFontLabel || '' ; 
    3232} 
    3333 
    3434// Inherit from FCKToolbarSpecialCombo. 
    35 FCKToolbarFontsCombo.prototype = new FCKToolbarSpecialCombo ; 
    36  
    37 FCKToolbarFontsCombo.prototype.TypeOf = 'FCKToolbarFontsCombo' ;                // @Packager.RemoveLine 
     35FCKToolbarFontsCombo.prototype = new FCKToolbarFontFormatCombo( false ) ; 
    3836 
    3937FCKToolbarFontsCombo.prototype.GetLabel = function() 
     
    4240} 
    4341 
    44 FCKToolbarFontsCombo.prototype.CreateItems = function( targetSpecialCombo ) 
     42FCKToolbarFontsCombo.prototype.GetStyles = function() 
    4543{ 
    46         var aFonts = FCKConfig.FontNames.split(';') ; 
     44        var baseStyle = FCKStyles.GetStyle( '_FCK_FontFace' ) ; 
    4745 
    48         for ( var i = 0 ; i < aFonts.length ; i++ ) 
    49                 this._Combo.AddItem( aFonts[i], '<font face="' + aFonts[i] + '" style="font-size: 12px">' + aFonts[i] + '</font>' ) ; 
     46        var styles = {} ; 
     47 
     48        var fonts = FCKConfig.FontNames.split(';') ; 
     49 
     50        for ( var i = 0 ; i < fonts.length ; i++ ) 
     51        { 
     52                var fontParts = fonts[i].split('/') ; 
     53                var font = fontParts[0] ; 
     54                var caption = fontParts[1] || font ; 
     55 
     56                var style = FCKTools.CloneObject( baseStyle ) ; 
     57                style.SetVariable( 'Font', font ) ; 
     58                style.Label = caption ; 
     59 
     60                styles[ caption ] = style ; 
     61        } 
     62 
     63        return styles ; 
    5064} 
     65 
     66FCKToolbarFontsCombo.prototype.RefreshActiveItems = FCKToolbarStyleCombo.prototype.RefreshActiveItems ; 
     67 
     68FCKToolbarFontsCombo.prototype.StyleCombo_OnBeforeClick = function( targetSpecialCombo ) 
     69{ 
     70        // Clear the current selection. 
     71        targetSpecialCombo.DeselectAll() ; 
     72 
     73        var startElement = FCKSelection.GetBoundaryParentElement( true ) ; 
     74 
     75        if ( startElement ) 
     76        { 
     77                var path = new FCKElementPath( startElement ) ; 
     78 
     79                for ( var i in targetSpecialCombo.Items ) 
     80                { 
     81                        var item = targetSpecialCombo.Items[i] ; 
     82                        var style = item.Style ; 
     83 
     84                        if ( style.CheckActive( path ) ) 
     85                        { 
     86                                targetSpecialCombo.SelectItem( item ) ; 
     87                                return ; 
     88                        } 
     89                } 
     90        } 
     91} 
  • FCKeditor/trunk/editor/_source/classes/fcktoolbarfontsizecombo.js

    r714 r774  
    3030         
    3131        this.DefaultLabel = FCKConfig.DefaultFontSizeLabel || '' ; 
     32 
     33        this.FieldWidth = 70 ; 
    3234} 
    3335 
    3436// Inherit from FCKToolbarSpecialCombo. 
    35 FCKToolbarFontSizeCombo.prototype = new FCKToolbarSpecialCombo ; 
    36  
    37 FCKToolbarFontSizeCombo.prototype.TypeOf = 'FCKToolbarFontSizeCombo' ;          // @Packager.RemoveLine 
     37FCKToolbarFontSizeCombo.prototype = new FCKToolbarFontFormatCombo( false ) ; 
    3838 
    3939FCKToolbarFontSizeCombo.prototype.GetLabel = function() 
     
    4242} 
    4343 
    44 FCKToolbarFontSizeCombo.prototype.CreateItems = function( targetSpecialCombo ) 
     44FCKToolbarFontSizeCombo.prototype.GetStyles = function() 
    4545{ 
    46         targetSpecialCombo.FieldWidth = 70 ; 
     46        var baseStyle = FCKStyles.GetStyle( '_FCK_Size' ) ; 
    4747 
    48         var aSizes = FCKConfig.FontSizes.split(';') ; 
     48        var styles = {} ; 
    4949 
    50         for ( var i = 0 ; i < aSizes.length ; i++ ) 
     50        var fonts = FCKConfig.FontSizes.split(';') ; 
     51 
     52        for ( var i = 0 ; i < fonts.length ; i++ ) 
    5153        { 
    52                 var aSizeParts = aSizes[i].split('/') ; 
    53                 this._Combo.AddItem( aSizeParts[0], '<font size="' + aSizeParts[0] + '">' + aSizeParts[1] + '</font>', aSizeParts[1] ) ; 
     54                var fontParts = fonts[i].split('/') ; 
     55                var font = fontParts[0] ; 
     56                var caption = fontParts[1] || font ; 
     57 
     58                var style = FCKTools.CloneObject( baseStyle ) ; 
     59                style.SetVariable( 'Size', font ) ; 
     60                style.Label = caption ; 
     61 
     62                styles[ caption ] = style ; 
    5463        } 
     64 
     65        return styles ; 
    5566} 
     67 
     68FCKToolbarFontSizeCombo.prototype.RefreshActiveItems = FCKToolbarStyleCombo.prototype.RefreshActiveItems ; 
     69 
     70FCKToolbarFontSizeCombo.prototype.StyleCombo_OnBeforeClick = FCKToolbarFontsCombo.prototype.StyleCombo_OnBeforeClick ; 
  • FCKeditor/trunk/editor/_source/classes/fcktoolbarstylecombo.js

    r714 r774  
    2424var FCKToolbarStyleCombo = function( tooltip, style ) 
    2525{ 
     26        if ( tooltip === false ) 
     27                return ; 
     28 
    2629        this.CommandName = 'Style' ; 
    2730        this.Label              = this.GetLabel() ; 
    2831        this.Tooltip    = tooltip ? tooltip : this.Label ; 
    2932        this.Style              = style ? style : FCK_TOOLBARITEM_ICONTEXT ; 
    30          
     33 
    3134        this.DefaultLabel = FCKConfig.DefaultStyleLabel || '' ; 
    3235} 
     
    3538FCKToolbarStyleCombo.prototype = new FCKToolbarSpecialCombo ; 
    3639 
    37 FCKToolbarStyleCombo.prototype.TypeOf = 'FCKToolbarStyleCombo' ;                // @Packager.RemoveLine 
    38  
    3940FCKToolbarStyleCombo.prototype.GetLabel = function() 
    4041{ 
     
    4243} 
    4344 
     45FCKToolbarStyleCombo.prototype.GetStyles = function() 
     46{ 
     47        var styles = {} ; 
     48        var allStyles = FCK.ToolbarSet.CurrentInstance.Styles.GetStyles() ; 
     49 
     50        for ( var styleName in allStyles ) 
     51        { 
     52                var style = allStyles[ styleName ] ; 
     53                if ( !style.IsCore ) 
     54                        styles[ styleName ] = style ; 
     55        } 
     56        return styles ; 
     57} 
     58 
    4459FCKToolbarStyleCombo.prototype.CreateItems = function( targetSpecialCombo ) 
    4560{ 
    46         var oTargetDoc = targetSpecialCombo._Panel.Document ; 
     61        var targetDoc = targetSpecialCombo._Panel.Document ; 
    4762 
    4863        // Add the Editor Area CSS to the panel so the style classes are previewed correctly. 
    49         FCKTools.AppendStyleSheet( oTargetDoc, FCKConfig.ToolbarComboPreviewCSS ) ; 
    50         FCKTools.AppendStyleString( oTargetDoc, FCKConfig.EditorAreaStyles ) ; 
    51         oTargetDoc.body.className += ' ForceBaseFont' ; 
     64        FCKTools.AppendStyleSheet( targetDoc, FCKConfig.ToolbarComboPreviewCSS ) ; 
     65        FCKTools.AppendStyleString( targetDoc, FCKConfig.EditorAreaStyles ) ; 
     66        targetDoc.body.className += ' ForceBaseFont' ; 
    5267 
    53         // Add ID and Class to the body 
    54         FCKConfig.ApplyBodyAttributes( oTargetDoc.body ) ; 
     68        // Add ID and Class to the body. 
     69        FCKConfig.ApplyBodyAttributes( targetDoc.body ) ; 
    5570 
    56         // For some reason Gecko is blocking inside the "RefreshVisibleItems" function. 
    57         // The problem is present only in old versions 
    58         if ( !( FCKBrowserInfo.IsGecko && FCKBrowserInfo.IsGecko10 ) ) 
    59                 targetSpecialCombo.OnBeforeClick = this.RefreshVisibleItems ; 
     71        // Get the styles list. 
     72        var styles = this.GetStyles() ; 
    6073 
    61         // Add the styles to the special combo. 
    62         var aCommandStyles = FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( this.CommandName ).Styles ; 
    63         for ( var s in aCommandStyles ) 
     74        for ( var styleName in styles ) 
    6475        { 
    65                 var oStyle = aCommandStyles[s] ; 
    66                 var oItem ; 
     76                var style = styles[ styleName ] ; 
    6777 
    68                 if ( oStyle.IsObjectElement ) 
    69                         oItem = targetSpecialCombo.AddItem( s, s ) ; 
    70                 else 
    71                         oItem = targetSpecialCombo.AddItem( s, oStyle.GetOpenerTag() + s + oStyle.GetCloserTag() ) ; 
     78                // Object type styles have no preview. 
     79                var caption = style.GetType() == FCK_STYLE_OBJECT ?  
     80                        styleName :  
     81                        FCKToolbarStyleCombo_BuildPreview( style, style.Label || styleName ) ; 
     82         
     83                var item = targetSpecialCombo.AddItem( styleName, caption ) ; 
    7284 
    73                 oItem.Style = oStyle ; 
     85                item.Style = style ; 
    7486        } 
     87 
     88        // We must prepare the list before showing it. 
     89        targetSpecialCombo.OnBeforeClick = this.StyleCombo_OnBeforeClick ; 
    7590} 
    7691 
    7792FCKToolbarStyleCombo.prototype.RefreshActiveItems = function( targetSpecialCombo ) 
    7893{ 
    79         // Clear the actual selection. 
     94        var startElement = FCKSelection.GetBoundaryParentElement( true ) ; 
     95 
     96        if ( startElement ) 
     97        { 
     98                var path = new FCKElementPath( startElement ) ; 
     99                var elements = path.Elements ; 
     100 
     101                for ( var e = 0 ; e < elements.length ; e++ ) 
     102                { 
     103                        for ( var i in targetSpecialCombo.Items ) 
     104                        { 
     105                                var item = targetSpecialCombo.Items[i] ; 
     106                                var style = item.Style ; 
     107 
     108                                if ( style.CheckElementRemovable( elements[ e ] ) ) 
     109                                { 
     110                                        targetSpecialCombo.SetLabel( style.Label || style.Name ) ; 
     111                                        return ; 
     112                                } 
     113                        } 
     114                } 
     115        } 
     116 
     117        targetSpecialCombo.SetLabel( this.DefaultLabel ) ; 
     118} 
     119 
     120FCKToolbarStyleCombo.prototype.StyleCombo_OnBeforeClick = function( targetSpecialCombo ) 
     121{ 
     122        // Two things are done here: 
     123        //      - In a control selection, get the element name, so we'll display styles 
     124        //        for that element only. 
     125        //      - Select the styles that are active for the current selection. 
     126         
     127        // Clear the current selection. 
    80128        targetSpecialCombo.DeselectAll() ; 
    81129 
    82         // Get the active styles. 
    83         var aStyles = FCK.ToolbarSet.CurrentInstance.Commands.GetCommand( this.CommandName ).GetActiveStyles() ; 
    84  
    85         if ( aStyles.length > 0 ) 
     130        var startElement ; 
     131        var path ; 
     132        var tagName ; 
     133         
     134        if ( FCKSelection.GetType() == 'Control' ) 
    86135        { 
    87                 // Select the active styles in the combo. 
    88                 for ( var i = 0 ; i < aStyles.length ; i++ ) 
    89                         targetSpecialCombo.SelectItem( aStyles[i].Name ) ; 
    90  
    91                 // Set the combo label to the first style in the collection. 
    92                 targetSpecialCombo.SetLabelById( aStyles[0].Name ) ; 
     136                startElement = FCKSelection.GetSelectedElement() ; 
     137                tagName = startElement.nodeName.toLowerCase() ; 
    93138        } 
    94139        else 
    95                 targetSpecialCombo.SetLabel(this.DefaultLabel) ; 
    96 } 
    97  
    98 FCKToolbarStyleCombo.prototype.RefreshVisibleItems = function( targetSpecialCombo ) 
    99 { 
    100         if ( FCKSelection.GetType() == 'Control' ) 
    101                 var sTagName = FCKSelection.GetSelectedElement().tagName ; 
     140        { 
     141                startElement = FCKSelection.GetBoundaryParentElement( true ) ; 
     142                path = new FCKElementPath( startElement ) ; 
     143        } 
    102144 
    103145        for ( var i in targetSpecialCombo.Items ) 
    104146        { 
    105                 var oItem = targetSpecialCombo.Items[i] ; 
    106                 if ( ( sTagName && oItem.Style.Element == sTagName ) || ( ! sTagName && ! oItem.Style.IsObjectElement ) ) 
    107                         oItem.style.display = '' ; 
     147                var item = targetSpecialCombo.Items[i] ; 
     148                var style = item.Style ; 
     149                 
     150                if ( ( tagName && style.Element == tagName ) || ( !tagName && style.GetType() != FCK_STYLE_OBJECT ) ) 
     151                { 
     152                        item.style.display = '' ; 
     153 
     154                        if ( ( path && style.CheckActive( path ) ) || ( !path && style.CheckElementRemovable( startElement, true ) ) ) 
     155                                targetSpecialCombo.SelectItem( style.Name ) ; 
     156                } 
    108157                else 
    109                         oItem.style.display = 'none' ;  // For some reason Gecko is blocking here. 
     158                        item.style.display = 'none' ; 
    110159        } 
    111160} 
     161 
     162function FCKToolbarStyleCombo_BuildPreview( style, caption )  
     163{ 
     164        var styleType = style.GetType() ; 
     165        var html = [] ; 
     166         
     167        if ( styleType == FCK_STYLE_BLOCK ) 
     168                html.push( '<div class="BaseFont">' ) ; 
     169         
     170        var elementName = style.Element ; 
     171         
     172        // Avoid <bdo> in the preview. 
     173        if ( elementName == 'bdo' ) 
     174                elementName = 'span' ; 
     175 
     176        html = [ '<', elementName ] ; 
     177 
     178        // Assign all defined attributes. 
     179        var attribs     = style._StyleDesc.Attributes ; 
     180        if ( attribs ) 
     181        { 
     182                for ( var att in attribs ) 
     183                { 
     184                        html.push( ' ', att, '="', style.GetFinalAttributeValue( att ), '"' ) ; 
     185                } 
     186        } 
     187 
     188        // Assign the style attribute. 
     189        if ( style._GetStyleText().length > 0 ) 
     190                html.push( ' style="', style.GetFinalStyleValue(), '"' ) ; 
     191 
     192        html.push( '>', caption, '</', elementName, '>' ) ; 
     193 
     194        if ( styleType == FCK_STYLE_BLOCK ) 
     195                html.push( '</div>' ) ; 
     196 
     197        return html.join( '' ) ; 
     198} 
  • FCKeditor/trunk/editor/_source/classes/fckw3crange.js

    r718 r774  
    419419                        // topStart and topEnd. Otherwise, simply collapse it to the start. (W3C specs). 
    420420                        if ( topStart && topEnd && ( startNode.parentNode != topStart.parentNode || endNode.parentNode != topEnd.parentNode ) ) 
    421                                 this.setStart( topEnd.parentNode, FCKDomTools.GetIndexOf( topEnd ) ) ; 
     421                        { 
     422                                var endIndex = FCKDomTools.GetIndexOf( topEnd ) ; 
     423                                 
     424                                // If the start node is to be removed, we must correct the 
     425                                // index to reflect the removal. 
     426                                if ( removeStartNode && topEnd.parentNode == startNode.parentNode ) 
     427                                        endIndex-- ; 
     428 
     429                                this.setStart( topEnd.parentNode, endIndex ) ; 
     430                        } 
    422431 
    423432                        // Collapse it to the start. 
  • FCKeditor/trunk/editor/_source/classes/fckxml_gecko.js

    r132 r774  
    8686                return null ; 
    8787} 
     88 
     89FCKXml.GetAttribute = function( node, attName, defaultValue ) 
     90{ 
     91        var attNode = node.attributes.getNamedItem( attName ) ; 
     92        return attNode ? attNode.value : defaultValue ; 
     93} 
  • FCKeditor/trunk/editor/_source/classes/fckxml_ie.js

    r132 r774  
    8989                return this.DOMDocument.selectSingleNode( xpath ) ; 
    9090} 
     91 
     92FCKXml.GetAttribute = function( node, attName, defaultValue ) 
     93{ 
     94        var attNode = node.attributes.getNamedItem( attName ) ; 
     95        return attNode ? attNode.value : defaultValue ; 
     96} 
  • FCKeditor/trunk/editor/_source/commandclasses/fck_othercommands.js

    r699 r774  
    6767} 
    6868 
     69 
     70// ### FormatBlock 
     71var FCKFormatBlockCommand = function() 
     72{} 
     73 
     74FCKFormatBlockCommand.prototype =  
     75{ 
     76        Name : 'FormatBlock', 
     77         
     78        Execute : FCKStyleCommand.prototype.Execute, 
     79         
     80        GetState : function() 
     81        { 
     82                return FCK.EditorDocument ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ; 
     83        } 
     84}; 
     85 
    6986// ### FontName 
     87 
    7088var FCKFontNameCommand = function() 
    71 { 
    72         this.Name = 'FontName' ; 
    73 } 
    74  
    75 FCKFontNameCommand.prototype.Execute = function( fontName ) 
    76 { 
    77         if (fontName == null || fontName == "") 
    78         { 
    79                 // TODO: Remove font name attribute. 
    80                 /*jsl:pass*/ // @Packager.RemoveLine 
    81         } 
    82         else 
    83                 FCK.ExecuteNamedCommand( 'FontName', fontName ) ; 
    84 } 
    85  
    86 FCKFontNameCommand.prototype.GetState = function() 
    87 { 
    88         var value = FCK.GetNamedCommandValue( 'FontName' ) ; 
    89         if (value && value.charAt( 0 ) == "'" && value.charAt( value.length - 1 ) == "'") 
    90                 value = value.slice( 1, -1 ) ; 
    91         return value ; 
    92 } 
     89{} 
     90 
     91FCKFontNameCommand.prototype =  
     92{ 
     93        Name            : 'FontName', 
     94        Execute         : FCKStyleCommand.prototype.Execute, 
     95        GetState        : FCKFormatBlockCommand.prototype.GetState 
     96}; 
    9397 
    9498// ### FontSize 
    9599var FCKFontSizeCommand = function() 
    96 { 
    97         this.Name = 'FontSize' ; 
    98 } 
    99  
    100 FCKFontSizeCommand.prototype.Execute = function( fontSize ) 
    101 { 
    102         if ( typeof( fontSize ) == 'string' ) fontSize = parseInt(fontSize, 10) ; 
    103  
    104         // If user wants the font size cleared, we have to find 
    105         // where the font size tag is and go clear it (if there's one) 
    106         if ( !fontSize ) 
    107         { 
    108                 var oFont = FCK.Selection.MoveToAncestorNode('FONT'); 
    109                 if ( oFont && oFont.getAttribute("size") ) 
    110                 { 
    111                         //if the only thing here is SIZE, collapse the whole tag 
    112                         if (oFont.attributes.length == 1 || 
    113                                 (oFont.outerHTML && oFont.outerHTML.search(/<FONT size=["]*\d["]*>/i))) 
    114                         { 
    115                                 FCKTools.RemoveOuterTags(oFont); 
    116                         } 
    117                         else 
    118                                 oFont.removeAttribute("size"); 
    119                 }        
    120  
    121         } 
    122         else 
    123                 FCK.ExecuteNamedCommand( 'FontSize', fontSize ) ; 
    124 } 
    125  
    126 FCKFontSizeCommand.prototype.GetState = function() 
    127 { 
    128         return FCK.GetNamedCommandValue( 'FontSize' ) ; 
    129 } 
    130  
    131 // ### FormatBlock 
    132 var FCKFormatBlockCommand = function() 
    133 { 
    134         this.Name = 'FormatBlock' ; 
    135 } 
    136  
    137 FCKFormatBlockCommand.prototype.Execute = function( formatName ) 
    138 { 
    139         if ( formatName == null || formatName == '' ) 
    140                 FCK.ExecuteNamedCommand( 'FormatBlock', '<P>' ) ; 
    141         else if ( formatName == 'div' && FCKBrowserInfo.IsGecko ) 
    142                 FCK.ExecuteNamedCommand( 'FormatBlock', 'div' ) ; 
    143         else 
    144                 FCK.ExecuteNamedCommand( 'FormatBlock', '<' + formatName + '>' ) ; 
    145 } 
    146  
    147 FCKFormatBlockCommand.prototype.GetState = function() 
    148 { 
    149         return FCK.GetNamedCommandValue( 'FormatBlock' ) ; 
    150 } 
     100{} 
     101 
     102FCKFontSizeCommand.prototype =  
     103{ 
     104        Name            : 'FontSize', 
     105        Execute         : FCKStyleCommand.prototype.Execute, 
     106        GetState        : FCKFormatBlockCommand.prototype.GetState 
     107}; 
    151108 
    152109// ### Preview 
  • FCKeditor/trunk/editor/_source/commandclasses/fckstylecommand.js

    r132 r774  
    2323 
    2424var FCKStyleCommand = function() 
     25{} 
     26 
     27FCKStyleCommand.prototype = 
    2528{ 
    26         this.Name = 'Style' ; 
     29        Name : 'Style', 
     30         
     31        Execute : function( styleName, styleComboItem ) 
     32        { 
     33                FCKUndo.SaveUndoStep() ; 
    2734 
    28         // Load the Styles defined in the XML file. 
    29         this.StylesLoader = new FCKStylesLoader() ; 
    30         this.StylesLoader.Load( FCKConfig.StylesXmlPath ) ; 
    31         this.Styles = this.StylesLoader.Styles ; 
    32 } 
     35                if ( styleComboItem.Selected ) 
     36                        FCK.Styles.RemoveStyle( styleComboItem.Style ) ; 
     37                else 
     38                        FCK.Styles.ApplyStyle( styleComboItem.Style ) ; 
    3339 
    34 FCKStyleCommand.prototype.Execute = function( styleName, styleComboItem ) 
    35 { 
    36         FCKUndo.SaveUndoStep() ; 
     40                FCKUndo.SaveUndoStep() ; 
    3741 
    38         if ( styleComboItem.Selected ) 
    39                 styleComboItem.Style.RemoveFromSelection() ; 
    40         else 
    41                 styleComboItem.Style.ApplyToSelection() ; 
     42                FCK.Focus() ; 
    4243 
    43         FCKUndo.SaveUndoStep() ; 
     44                FCK.Events.FireEvent( 'OnSelectionChange' ) ; 
     45        }, 
    4446 
    45         FCK.Focus() ; 
     47        GetState : function() 
     48        { 
     49                if ( !FCK.EditorDocument ) 
     50                        return FCK_TRISTATE_DISABLED ; 
    4651 
    47         FCK.Events.FireEvent( "OnSelectionChange" ) ; 
    48 } 
     52                if ( FCKSelection.GetType() == 'Control' ) 
     53                { 
     54                        var el = FCKSelection.GetSelectedElement() ; 
     55                        if ( !el || !FCKStyles.CheckHasObjectStyle( el.nodeName.toLowerCase() ) ) 
     56                                return FCK_TRISTATE_DISABLED ; 
     57                } 
    4958 
    50 FCKStyleCommand.prototype.GetState = function() 
    51 { 
    52         if ( !FCK.EditorDocument ) 
    53                 return FCK_TRISTATE_DISABLED ; 
    54  
    55         var oSelection = FCK.EditorDocument.selection ; 
    56  
    57         if ( FCKSelection.GetType() == 'Control' ) 
    58         { 
    59                 var e = FCKSelection.GetSelectedElement() ; 
    60                 if ( e ) 
    61                         return this.StylesLoader.StyleGroups[ e.tagName ] ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ; 
     59                return FCK_TRISTATE_OFF ; 
    6260        } 
    63  
    64         return FCK_TRISTATE_OFF ; 
    65 } 
    66  
    67 FCKStyleCommand.prototype.GetActiveStyles = function() 
    68 { 
    69         var aActiveStyles = new Array() ; 
    70  
    71         if ( FCKSelection.GetType() == 'Control' ) 
    72                 this._CheckStyle( FCKSelection.GetSelectedElement(), aActiveStyles, false ) ; 
    73         else 
    74                 this._CheckStyle( FCKSelection.GetParentElement(), aActiveStyles, true ) ; 
    75  
    76         return aActiveStyles ; 
    77 } 
    78  
    79 FCKStyleCommand.prototype._CheckStyle = function( element, targetArray, checkParent ) 
    80 { 
    81         if ( ! element ) 
    82                 return ; 
    83  
    84         if ( element.nodeType == 1 ) 
    85         { 
    86                 var aStyleGroup = this.StylesLoader.StyleGroups[ element.tagName ] ; 
    87                 if ( aStyleGroup ) 
    88                 { 
    89                         for ( var i = 0 ; i < aStyleGroup.length ; i++ ) 
    90                         { 
    91                                 if ( aStyleGroup[i].IsEqual( element ) ) 
    92                                         targetArray[ targetArray.length ] = aStyleGroup[i] ; 
    93                         } 
    94                 } 
    95         } 
    96  
    97         if ( checkParent ) 
    98                 this._CheckStyle( element.parentNode, targetArray, checkParent ) ; 
    99 } 
     61}; 
  • FCKeditor/trunk/editor/_source/commandclasses/fcktextcolorcommand.js

    r752 r774  
    5858FCKTextColorCommand.prototype.SetColor = function( color ) 
    5959{ 
    60         if ( FCK._ActiveColorPanelType == 'ForeColor' ) 
    61                 FCK.ExecuteNamedCommand( 'ForeColor', color ) ; 
    62         else if ( FCKBrowserInfo.IsGeckoLike ) 
     60        var style = FCKStyles.GetStyle( '_FCK_' +  
     61                ( FCK._ActiveColorPanelType == 'ForeColor' ? 'Color' : 'BackColor' ) ) ; 
     62 
     63        if ( !color || color.length == 0 ) 
     64                FCK.Styles.RemoveStyle( style ) ; 
     65        else 
    6366        { 
    64                 if ( FCKBrowserInfo.IsGecko && !FCKConfig.GeckoUseSPAN ) 
    65                         FCK.EditorDocument.execCommand( 'useCSS', false, false ) ; 
    66  
    67                 FCK.ExecuteNamedCommand( 'hilitecolor', color ) ; 
    68  
    69                 if ( FCKBrowserInfo.IsGecko && !FCKConfig.GeckoUseSPAN ) 
    70                         FCK.EditorDocument.execCommand( 'useCSS', false, true ) ; 
     67                style.SetVariable( 'Color', color ) ; 
     68                FCKStyles.ApplyStyle( style ) ; 
    7169        } 
    72         else 
    73                 FCK.ExecuteNamedCommand( 'BackColor', color ) ; 
    7470 
    7571        // Delete the "cached" active panel type. 
  • FCKeditor/trunk/editor/_source/fckconstants.js

    r132 r774  
    5151var SHIFT       = 2000 ; 
    5252var ALT         = 4000 ; 
     53 
     54var FCK_STYLE_BLOCK             = 0 ; 
     55var FCK_STYLE_INLINE    = 1 ; 
     56var FCK_STYLE_OBJECT    = 2 ; 
  • FCKeditor/trunk/editor/_source/fckjscoreextensions.js

    r694 r774  
    135135} 
    136136 
     137String.prototype.Replace = function( regExp, replacement, thisObj ) 
     138{ 
     139        if ( typeof replacement == 'function' ) 
     140        { 
     141                return this.replace( regExp,  
     142                        function()  
     143                        {  
     144                                return replacement.apply( thisObj || this, arguments ) ;  
     145                        } ) ; 
     146        } 
     147        else 
     148                return this.replace( regExp, replacement ) ; 
     149} 
     150 
    137151Array.prototype.AddItem = function( item ) 
    138152{ 
  • FCKeditor/trunk/editor/_source/fckscriptloader.js

    r654 r774  
    9393FCKScriptLoader.AddScript( 'FCKJSCoreExtensions' ) ; 
    9494 
     95FCKScriptLoader.AddScript( 'FCK_Xhtml10Transitional', '../dtd/' ) ; 
     96 
    9597FCKScriptLoader.AddScript( 'FCKDataProcessor'   , 'classes/'    , ['FCKConfig','FCKBrowserInfo','FCKRegexLib','FCKXHtml'] ) ; 
    9698FCKScriptLoader.AddScript( 'FCKDocumentFragment', 'classes/'    , ['FCKDomTools'], FCK_SPECIFIC ) ; 
     
    100102FCKScriptLoader.AddScript( 'FCKImagePreloader'  , 'classes/' ) ; 
    101103FCKScriptLoader.AddScript( 'FCKKeystrokeHandler', 'classes/'    , ['FCKConstants','FCKBrowserInfo','FCKTools'], FCK_GENERIC ) ; 
     104FCKScriptLoader.AddScript( 'FCKStyle'                   , 'classes/'    , ['FCKConstants','FCKDomRange','FCKDomTools','FCKListsLib','FCK_Xhtml10Transitional'], FCK_GENERIC ) ; 
    102105FCKScriptLoader.AddScript( 'FCKW3CRange'                , 'classes/'    , ['FCKDomTools','FCKTools','FCKDocumentFragment'], FCK_GENERIC ) ; 
    103106 
     
    106109FCKScriptLoader.AddScript( 'FCKConfig'                  , 'internals/'  , ['FCKBrowserInfo','FCKConstants'] ) ; 
    107110FCKScriptLoader.AddScript( 'FCKDebug'                   , 'internals/'  , ['FCKConfig'] ) ; 
    108 FCKScriptLoader.AddScript( 'FCKDomTools'                , 'internals/'  , ['FCKJSCoreExtensions'], FCK_GENERIC ) ; 
     111FCKScriptLoader.AddScript( 'FCKDomTools'                , 'internals/'  , ['FCKJSCoreExtensions','FCKBrowserInfo','FCKTools'], FCK_GENERIC ) ; 
    109112FCKScriptLoader.AddScript( 'FCKListsLib'                , 'internals/' ) ; 
    110 FCKScriptLoader.AddScript( 'FCKListHandler'             , 'internals/'  , ['FCKConfig', 'FCKDocumentFragment', 'FCKJSCoreExtensions','FCKDomTools','FCKTools'], FCK_GENERIC ) ; 
     113FCKScriptLoader.AddScript( 'FCKListHandler'             , 'internals/'  , ['FCKConfig', 'FCKDocumentFragment', 'FCKJSCoreExtensions','FCKDomTools'], FCK_GENERIC ) ; 
    111114FCKScriptLoader.AddScript( 'FCKRegexLib'                , 'internals/' ) ; 
     115FCKScriptLoader.AddScript( 'FCKStyles'                  , 'internals/'  , ['FCKConfig', 'FCKDocumentFragment', 'FCKDomRange','FCKDomTools','FCKElementPath','FCKTools'], FCK_GENERIC ) ; 
    112116FCKScriptLoader.AddScript( 'FCKTools'                   , 'internals/'  , ['FCKJSCoreExtensions','FCKBrowserInfo'], FCK_GENERIC_SPECIFIC ) ; 
    113117FCKScriptLoader.AddScript( 'FCKXHtml'                   , 'internals/'  , ['FCKBrowserInfo','FCKCodeFormatter','FCKConfig','FCKDomTools','FCKListsLib','FCKRegexLib','FCKTools','FCKXHtmlEntities'], FCK_GENERIC_SPECIFIC ) ; 
  • FCKeditor/trunk/editor/_source/internals/fck.js

    r756 r774  
    361361                        data = FCK.ProtectTags( data ) ; 
    362362 
    363                         // Firefox can't handle correctly the editing of the STRONG and EM tags. 
    364                         // We must replace them with B and I. 
    365                         // TODO : remove this check  if possible, as soon as the new style system is in use. 
    366                         if ( FCKBrowserInfo.IsGecko ) 
    367                         { 
    368                                 data = data.replace( FCKRegexLib.StrongOpener, '<b$1' ) ; 
    369                                 data = data.replace( FCKRegexLib.StrongCloser, '<\/b>' ) ; 
    370                                 data = data.replace( FCKRegexLib.EmOpener, '<i$1' ) ; 
    371                                 data = data.replace( FCKRegexLib.EmCloser, '<\/i>' ) ; 
    372                         } 
    373  
    374363                        // Insert the base tag (FCKConfig.BaseHref), if not exists in the source. 
    375364                        // The base must be the first tag in the HEAD, to get relative 
     
    737726} ; 
    738727 
    739 FCK.Events      = new FCKEvents( FCK ) ; 
     728FCK.Events = new FCKEvents( FCK ) ; 
    740729 
    741730// DEPRECATED in favor or "GetData". 
  • FCKeditor/trunk/editor/_source/internals/fck_gecko.js

    r742 r774  
    350350        html = FCK.ProtectTags( html ) ; 
    351351 
    352         // Firefox can't handle correctly the editing of the STRONG and EM tags. 
    353         // We must replace them with B and I. 
    354         html = html.replace( FCKRegexLib.StrongOpener, '<b$1' ) ; 
    355         html = html.replace( FCKRegexLib.StrongCloser, '<\/b>' ) ; 
    356         html = html.replace( FCKRegexLib.EmOpener, '<i$1' ) ; 
    357         html = html.replace( FCKRegexLib.EmCloser, '<\/i>' ) ; 
    358  
    359352        // Save an undo snapshot first. 
    360353        FCKUndo.SaveUndoStep() ; 
  • FCKeditor/trunk/editor/_source/internals/fckcommands.js

    r764 r774  
    3939        switch ( commandName ) 
    4040        { 
     41                case 'Bold'                     : 
     42                case 'Italic'           : 
     43                case 'Underline'        : 
     44                case 'StrikeThrough': 
     45                case 'Subscript'        : 
     46                case 'Superscript'      : oCommand = new FCKCoreStyleCommand( commandName ) ; break ; 
     47                 
     48                case 'RemoveFormat'     : oCommand = new FCKRemoveFormatCommand() ; break ; 
     49 
    4150                case 'DocProps'         : oCommand = new FCKDialogCommand( 'DocProps'   , FCKLang.DocProps                              , 'dialog/fck_docprops.html'    , 400, 390, FCKCommands.GetFullPageState ) ; break ; 
    4251                case 'Templates'        : oCommand = new FCKDialogCommand( 'Templates'  , FCKLang.DlgTemplatesTitle             , 'dialog/fck_template.html'    , 380, 450 ) ; break ; 
     
    8291                case 'TableInsertRowAfter'              : oCommand = new FCKTableCommand('TableInsertRowAfter') ; break ; 
    8392                case 'TableInsertRowBefore'             : oCommand = new FCKTableCommand('TableInsertRowBefore') ; break ; 
    84                 case 'TableDeleteRows'          : oCommand = new FCKTableCommand('TableDeleteRows') ; break ; 
     93                case 'TableDeleteRows'                  : oCommand = new FCKTableCommand('TableDeleteRows') ; break ; 
    8594                case 'TableInsertColumnAfter'   : oCommand = new FCKTableCommand('TableInsertColumnAfter') ; break ; 
    8695                case 'TableInsertColumnBefore'  : oCommand = new FCKTableCommand('TableInsertColumnBefore') ; break ; 
    87                 case 'TableDeleteColumns'       : oCommand = new FCKTableCommand('TableDeleteColumns') ; break ; 
     96                case 'TableDeleteColumns'               : oCommand = new FCKTableCommand('TableDeleteColumns') ; break ; 
    8897                case 'TableInsertCellAfter'             : oCommand = new FCKTableCommand('TableInsertCellAfter') ; break ; 
    89                 case 'TableInsertCellBefore'            : oCommand = new FCKTableCommand('TableInsertCellBefore') ; break ; 
    90                 case 'TableDeleteCells'         : oCommand = new FCKTableCommand('TableDeleteCells') ; break ; 
    91                 case 'TableMergeCells'          : oCommand = new FCKTableCommand('TableMergeCells') ; break ; 
    92                 case 'TableMergeRight'          : oCommand = new FCKTableCommand('TableMergeRight') ; break ; 
    93                 case 'TableMergeDown'           : oCommand = new FCKTableCommand('TableMergeDown') ; break ; 
    94                 case 'TableHorizontalSplitCell'         : oCommand = new FCKTableCommand('TableHorizontalSplitCell') ; break ; 
    95                 case 'TableVerticalSplitCell'           : oCommand = new FCKTableCommand('TableVerticalSplitCell') ; break ; 
    96                 case 'TableDelete'                      : oCommand = new FCKTableCommand('TableDelete') ; break ; 
     98                case 'TableInsertCellBefore'    : oCommand = new FCKTableCommand('TableInsertCellBefore') ; break ; 
     99                case 'TableDeleteCells'                 : oCommand = new FCKTableCommand('TableDeleteCells') ; break ; 
     100                case 'TableMergeCells'                  : oCommand = new FCKTableCommand('TableMergeCells') ; break ; 
     101                case 'TableMergeRight'                  : oCommand = new FCKTableCommand('TableMergeRight') ; break ; 
     102                case 'TableMergeDown'                   : oCommand = new FCKTableCommand('TableMergeDown') ; break ; 
     103                case 'TableHorizontalSplitCell' : oCommand = new FCKTableCommand('TableHorizontalSplitCell') ; break ; 
     104                case 'TableVerticalSplitCell'   : oCommand = new FCKTableCommand('TableVerticalSplitCell') ; break ; 
     105                case 'TableDelete'                              : oCommand = new FCKTableCommand('TableDelete') ; break ; 
    97106 
    98107                case 'Form'                     : oCommand = new FCKDialogCommand( 'Form'               , FCKLang.Form                  , 'dialog/fck_form.html'                , 380, 230 ) ; break ; 
     
    113122                case 'Copy'     : oCommand = new FCKCopyCommand() ; break ; 
    114123 
    115                 case 'SelectAll' : oCommand = new FCKSelectAllCommand() ; break ; 
    116                 case 'InsertOrderedList' : oCommand = new FCKListCommand( 'insertorderedlist' ) ; break ; 
    117                 case 'InsertUnorderedList' : oCommand = new FCKListCommand( 'insertunorderedlist' ) ; break ; 
     124                case 'SelectAll'                        : oCommand = new FCKSelectAllCommand() ; break ; 
     125                case 'InsertOrderedList'        : oCommand = new FCKListCommand( 'insertorderedlist' ) ; break ; 
     126                case 'InsertUnorderedList'      : oCommand = new FCKListCommand( 'insertunorderedlist' ) ; break ; 
    118127                case 'ShowBlocks' : oCommand = new FCKShowBlockCommand( 'ShowBlocks', FCKConfig.StartupShowBlocks ? FCK_TRISTATE_ON : FCK_TRISTATE_OFF ) ; break ; 
    119128 
  • FCKeditor/trunk/editor/_source/internals/fckdomtools.js

    r771 r774  
    2424var FCKDomTools = 
    2525{ 
    26         MoveChildren : function( source, target ) 
     26        MoveChildren : function( source, target, toTargetStart ) 
    2727        { 
    2828                if ( source == target ) 
     
    3030 
    3131                var eChild ; 
    32                 while ( (eChild = source.firstChild) ) 
    33                         target.appendChild( source.removeChild( eChild ) ) ; 
     32 
     33                if ( toTargetStart ) 
     34                { 
     35                        while ( (eChild = source.lastChild) ) 
     36                                target.insertBefore( source.removeChild( eChild ), target.firstChild ) ; 
     37                } 
     38                else 
     39                { 
     40                        while ( (eChild = source.firstChild) ) 
     41                                target.appendChild( source.removeChild( eChild ) ) ; 
     42                } 
     43        }, 
     44 
     45        MoveNode : function( source, target, toTargetStart ) 
     46        { 
     47                if ( toTargetStart ) 
     48                        target.insertBefore( FCKDomTools.RemoveNode( source ), target.firstChild ) ; 
     49                else 
     50                        target.appendChild( FCKDomTools.RemoveNode( source ) ) ; 
    3451        }, 
    3552 
     
    228245        GetNextSourceElement : function( currentNode, ignoreSpaceTextOnly, stopSearchElements, ignoreElements ) 
    229246        { 
     247                while( ( currentNode = this.GetNextSourceNode( currentNode ) ) )        // Only one "=". 
     248                { 
     249                        if ( currentNode.nodeType == 1 ) 
     250                        { 
     251                                if ( stopSearchElements && currentNode.nodeName.IEquals( stopSearchElements ) ) 
     252                                        break ; 
     253 
     254                                if ( !ignoreElements || !currentNode.nodeName.IEquals( ignoreElements ) ) 
     255                                        return currentNode ; 
     256                        } 
     257                        else if ( ignoreSpaceTextOnly && currentNode.nodeType == 3 && currentNode.nodeValue.RTrim().length > 0 ) 
     258                                break ; 
     259                } 
     260 
     261                return null ; 
     262        }, 
     263 
     264        /* 
     265         * Get the next DOM node available in source order. 
     266         */ 
     267        GetNextSourceNode : function( currentNode, startFromSibling, nodeType ) 
     268        { 
    230269                if ( !currentNode ) 
    231270                        return null ; 
    232271 
    233                 if ( currentNode.nextSibling ) 
    234                         currentNode = currentNode.nextSibling ; 
    235                 else 
    236                         return this.GetNextSourceElement( currentNode.parentNode, ignoreSpaceTextOnly, stopSearchElements, ignoreElements ) ; 
    237  
    238                 while ( currentNode ) 
    239                 { 
    240                         if ( currentNode.nodeType == 1 ) 
    241                         { 
    242                                 if ( stopSearchElements && currentNode.nodeName.IEquals( stopSearchElements ) ) 
    243                                         break ; 
    244  
    245                                 if ( !ignoreElements || !currentNode.nodeName.IEquals( ignoreElements ) ) 
    246                                         return currentNode ; 
    247                         } 
    248                         else if ( ignoreSpaceTextOnly && currentNode.nodeType == 3 && currentNode.nodeValue.RTrim().length > 0 ) 
    249                                 break ; 
    250  
    251                         if ( currentNode.firstChild ) 
    252                                 currentNode = currentNode.firstChild ; 
    253                         else 
    254                                 return this.GetNextSourceElement( currentNode, ignoreSpaceTextOnly, stopSearchElements, ignoreElements ) ; 
    255                 } 
    256  
    257                 return null ; 
     272                var nextNode ; 
     273                 
     274                if ( !startFromSibling && currentNode.firstChild ) 
     275                        nextNode = currentNode.firstChild ; 
     276                else 
     277                        nextNode = ( currentNode.nextSibling || this.GetNextSourceNode( currentNode.parentNode, true, nodeType ) ) ; 
     278                 
     279                if ( nodeType && nextNode && nextNode.nodeType != nodeType ) 
     280                        return this.GetNextSourceNode( nextNode, false, nodeType ) ; 
     281                 
     282                return nextNode ; 
    258283        }, 
    259284 
     
    307332                        FCKTools.AppendBogusBr( node ) ; 
    308333                this.PaddingNode = node ; 
    309                 if ( doc.body.childNodes.length == 1  
     334                if ( doc.body.childNodes.length == 1 
    310335                                && doc.body.firstChild.nodeType == 1 
    311336                                && doc.body.firstChild.tagName.toLowerCase() == 'br' 
     
    326351                if ( paddingNode.parentNode != doc.body 
    327352                        || paddingNode.tagName.toLowerCase() != tagName 
    328                         || ( paddingNode.childNodes.length > 1 )  
    329                         || ( paddingNode.firstChild && paddingNode.firstChild.nodeValue != '\xa0'  
     353                        || ( paddingNode.childNodes.length > 1 ) 
     354                        || ( paddingNode.firstChild && paddingNode.firstChild.nodeValue != '\xa0' 
    330355                                && String(paddingNode.firstChild.tagName).toLowerCase() != 'br' ) ) 
    331356                { 
     
    341366                        this.PaddingNode = null ; 
    342367                } 
     368        }, 
     369 
     370        HasAttribute : function( element, attributeName ) 
     371        { 
     372                if ( element.hasAttribute ) 
     373                        return element.hasAttribute( attributeName ) ; 
     374                else 
     375                { 
     376                        var att = element.attributes[ attributeName ] ; 
     377                        return ( att != undefined && att.specified ) ; 
     378                } 
     379        }, 
     380 
     381        /** 
     382         * Checks if an element has "specified" attributes. 
     383         */ 
     384        HasAttributes : function( element ) 
     385        { 
     386                var attributes = element.attributes ; 
     387 
     388                for ( var i = 0 ; i < attributes.length ; i++ ) 
     389                { 
     390                        if ( attributes[i].specified ) 
     391                                return true ; 
     392                } 
     393 
     394                return false ; 
     395        }, 
     396         
     397        /** 
     398         * Remove an attribute from an element. 
     399         */ 
     400        RemoveAttribute : function( element, attributeName ) 
     401        { 
     402                if ( FCKBrowserInfo.IsIE && attributeName.toLowerCase() == 'class' ) 
     403                        attributeName = 'className' ; 
     404                 
     405                return element.removeAttribute( attributeName ) ; 
     406        }, 
     407         
     408         
     409        GetAttributeValue : function( element, att ) 
     410        { 
     411                var attName = att ; 
     412                 
     413                if ( typeof att == 'string' ) 
     414                        att = element.attributes[ att ] ; 
     415                else 
     416                        attName = att.nodeName ; 
     417                 
     418                if ( att && att.specified ) 
     419                { 
     420                        // IE returns "null" for the nodeValue of a "style" attribute. 
     421                        if ( attName == 'style' ) 
     422                                return element.style.cssText ; 
     423                        // There are two cases when the nodeValue must be used: 
     424                        //              - for the "class" attribute (all browsers). 
     425                        //              - for events attributes (IE only). 
     426                        else if ( attName == 'class' || attName.indexOf('on') == 0 ) 
     427                                return att.nodeValue ; 
     428                        else 
     429                        { 
     430                                // Use getAttribute to get its value  exactly as it is 
     431                                // defined. 
     432                                return element.getAttribute( attName, 2 ) ; 
     433                        } 
     434                } 
     435                return null ; 
     436        }, 
     437         
     438        /** 
     439         * Checks whether one element contains the other.  
     440         */ 
     441        Contains : function( mainElement, otherElement ) 
     442        { 
     443                if ( mainElement.contains ) 
     444                        return mainElement.contains( otherElement ) ; 
     445                 
     446                while ( ( otherElement = otherElement.parentNode ) )    // Only one "=" 
     447                { 
     448                        if ( otherElement == mainElement ) 
     449                                return true ; 
     450                } 
     451                return false ; 
     452        }, 
     453         
     454        /** 
     455         * Breaks a parent element in the position of one of its contained elements. 
     456         * For example, in the following case: 
     457         *              <b>This <i>is some<span /> sample</i> test text</b> 
     458         * If element = <span />, we have these results: 
     459         *              <b>This <i>is some</i><span /><i> sample</i> test text</b>                      (If parent = <i>) 
     460         *              <b>This <i>is some</i></b><span /><b<i> sample</i> test text</b>        (If parent = <b>) 
     461         */ 
     462        BreakParent : function( element, parent, reusableRange ) 
     463        { 
     464                var range = reusableRange || new FCKDomRange( FCKTools.GetElementWindow( element ) ) ; 
     465                 
     466                // We'll be extracting part of this element, so let's use our 
     467                // range to get the correct piece. 
     468                range.SetStart( element, 4 ) ; 
     469                range.SetEnd( parent, 4 ) ; 
     470                 
     471                // Extract it. 
     472                var docFrag = range.ExtractContents() ; 
     473                 
     474                // Move the element outside the broken element. 
     475                range.InsertNode( element.parentNode.removeChild( element ) ) ; 
     476 
     477                // Re-insert the extracted piece after the element. 
     478                docFrag.InsertAfterNode( element ) ; 
     479                 
     480                range.Release( !!reusableRange ) ; 
    343481        } 
    344482} ; 
  • FCKeditor/trunk/editor/_source/internals/fcklistslib.js

    r719 r774  
    3737        InlineChildReqElements : { abbr:1,acronym:1,b:1,bdo:1,big:1,cite:1,code:1,del:1,dfn:1,em:1,font:1,i:1,ins:1,label:1,kbd:1,q:1,samp:1,small:1,span:1,strike:1,strong:1,sub:1,sup:1,tt:1,u:1,'var':1 }, 
    3838 
     39        // Inline elements which are not marked as empty "Empty" in the XHTML DTD. 
     40        InlineNonEmptyElements : { a:1,abbr:1,acronym:1,b:1,bdo:1,big:1,cite:1,code:1,del:1,dfn:1,em:1,font:1,i:1,ins:1,label:1,kbd:1,q:1,samp:1,small:1,span:1,strike:1,strong:1,sub:1,sup:1,tt:1,u:1,'var':1 }, 
     41 
    3942        // Elements marked as empty "Empty" in the XHTML DTD. 
    4043        EmptyElements : { base:1,meta:1,link:1,hr:1,br:1,param:1,img:1,area:1,input:1 }, 
    41          
     44 
    4245        // Elements that may be considered the "Block boundary" in an element path. 
    4346        PathBlockElements : { address:1,blockquote:1,dl:1,h1:1,h2:1,h3:1,h4:1,h5:1,h6:1,p:1,pre:1,ol:1,ul:1,li:1,dt:1,de:1 }, 
    44          
     47 
    4548        // Elements that may be considered the "Block limit" in an element path. 
    4649        PathBlockLimitElements : { body:1,td:1,th:1,caption:1,form:1 }, 
    4750 
    48         // Final setup of FCKListsLib once the editor is loaded (at FCK.StartEditor).  
     51        // Block elements for the Styles System. 
     52        StyleBlockElements : { address:1,h1:1,h2:1,h3:1,h4:1,h5:1,h6:1,p:1,pre:1 }, 
     53 
     54        // Object elements for the Styles System. 
     55        StyleObjectElements : { img:1,hr:1,li:1,table:1,tr:1,td:1,embed:1,object:1,ol:1,ul:1 }, 
     56 
     57        // Final setup of FCKListsLib once the editor is loaded (at FCK.StartEditor). 
    4958        // TODO: For v3, there should be a generic way to register to the editor 
    5059        // startup event, so this function would not be needed to be defined here, not 
     
    5463                // <div> is considered a block element only if EnterMode=div, otherwise it is a block limit. 
    5564                if ( FCKConfig.EnterMode == 'div' ) 
     65                { 
    5666                        this.PathBlockElements.div = 1 ; 
     67                        this.StyleBlockElements.div = 1 ; 
     68                } 
    5769                else 
    5870                        this.PathBlockLimitElements.div = 1 ; 
  • FCKeditor/trunk/editor/_source/internals/fckregexlib.js

    r706 r774  
    6868TagBody                 : /></ , 
    6969 
    70 StrongOpener    : /<STRONG([ \>])/gi , 
    71 StrongCloser    : /<\/STRONG>/gi , 
    72 EmOpener                : /<EM([ \>])/gi , 
    73 EmCloser                : /<\/EM>/gi , 
    74  
    7570GeckoEntitiesMarker : /#\?-\:/g , 
    7671 
     
    9287 
    9388// [a-zA-Z0-9:]+ seams to be more efficient than [\w:]+ 
    94 InvalidSelfCloseTags : /(<(?!base|meta|link|hr|br|param|img|area|input)([a-zA-Z0-9:]+)[^>]*)\/>/gi 
     89InvalidSelfCloseTags : /(<(?!base|meta|link|hr|br|param|img|area|input)([a-zA-Z0-9:]+)[^>]*)\/>/gi, 
     90 
     91// All variables defined in a style attribute or style definition. The variable 
     92// name is returned with $2. 
     93StyleVariableAttName : /#\(\s*("|')(.+?)\1[^\)]*\s*\)/g 
    9594} ; 
  • FCKeditor/trunk/editor/_source/internals/fckselection_gecko.js

    r667 r774  
    2525FCKSelection.GetType = function() 
    2626{ 
    27 //      if ( ! this._Type ) 
    28 //      { 
    29                 // By default set the type to "Text". 
    30                 this._Type = 'Text' ; 
    31  
    32                 // Check if the actual selection is a Control (IMG, TABLE, HR, etc...). 
    33                 var oSel ; 
    34                 try { oSel = FCK.EditorWindow.getSelection() ; } 
    35                 catch (e) {} 
    36  
    37                 if ( oSel && oSel.rangeCount == 1 ) 
     27        // By default set the type to "Text". 
     28        var type = 'Text' ; 
     29 
     30        // Check if the actual selection is a Control (IMG, TABLE, HR, etc...). 
     31 
     32        var sel ; 
     33        try { sel = FCK.EditorWindow.getSelection() ; } catch (e) {} 
     34 
     35        if ( sel && sel.rangeCount == 1 ) 
     36        { 
     37                var range = sel.getRangeAt(0) ; 
     38                if ( range.startContainer == range.endContainer 
     39                        && ( range.endOffset - range.startOffset ) == 1 
     40                        && range.startContainer.nodeType == 1 
     41                        && FCKListsLib.StyleObjectElements[ range.startContainer.childNodes[ range.startOffset ].nodeName.toLowerCase() ] ) 
    3842                { 
    39                         var oRange = oSel.getRangeAt(0) ; 
    40                         if ( oRange.startContainer == oRange.endContainer && (oRange.endOffset - oRange.startOffset) == 1 && oRange.startContainer.nodeType != Node.TEXT_NODE ) 
    41                                 this._Type = 'Control' ; 
     43                        type = 'Control' ; 
    4244                } 
    43 //      } 
    44         return this._Type ; 
     45        } 
     46 
     47        return type ; 
    4548} 
    4649 
     
    5255        { 
    5356                var oSel = FCK.EditorWindow.getSelection() ; 
    54                 return oSel.anchorNode.childNodes[ oSel.anchorOffset ] ; 
     57 
     58                // For Safari, the anchor node for a control selection is the control 
     59                // itself, which seams logic. FF and Opera use the parent as the anchor 
     60                // node, pointing to the control with the offset. 
     61                // As FF created the selection "standard", Safari would do better by 
     62                // following their steps. 
     63                if ( FCKBrowserInfo.IsSafari ) 
     64                        return oSel.anchorNode ; 
     65                else 
     66                        return oSel.anchorNode.childNodes[ oSel.anchorOffset ] ; 
    5567        } 
    5668        return null ; 
     
    6779                { 
    6880                        // make the common case fast - for collapsed/nearly collapsed selections just return anchor.parent. 
    69                         if ( oSel.anchorNode == oSel.focusNode && oSel.anchorNode != null) 
     81                        if ( oSel.anchorNode && oSel.anchorNode == oSel.focusNode ) 
    7082                                return oSel.anchorNode.parentNode ; 
    7183 
    7284                        // looks like we're having a large selection here. To make the behavior same as IE's TextRange.parentElement(), 
    7385                        // we need to find the nearest ancestor node which encapsulates both the beginning and the end of the selection. 
     86                        // TODO: A simpler logic can be found. 
    7487                        var anchorPath = new FCKElementPath( oSel.anchorNode ) ; 
    75                         var focusPath = new FCKElementPath( oSel.focusNode ) ;  
     88                        var focusPath = new FCKElementPath( oSel.focusNode ) ; 
    7689                        var deepPath = null ; 
    7790                        var shallowPath = null ; 
     
    8699                                shallowPath = anchorPath.Elements ; 
    87100                        } 
    88                          
     101 
    89102                        var deepPathBase = deepPath.length - shallowPath.length ; 
    90103                        for( var i = 0 ; i < shallowPath.length ; i++) 
     
    99112} 
    100113 
     114FCKSelection.GetBoundaryParentElement = function( startBoundary ) 
     115{ 
     116        if ( this.GetType() == 'Control' ) 
     117                return FCKSelection.GetSelectedElement().parentNode ; 
     118        else 
     119        { 
     120                var oSel = FCK.EditorWindow.getSelection() ; 
     121                if ( oSel && oSel.rangeCount > 0 ) 
     122                { 
     123                        var range = oSel.getRangeAt( startBoundary ? 0 : ( oSel.rangeCount - 1 ) ) ; 
     124 
     125                        var element = startBoundary ? range.startContainer : range.endContainer ; 
     126 
     127                        // Firefox has a strange selection system which diverts from IE, 
     128                        // Safari and Opera. If the start of the selection ends in the left 
     129                        // boundary of an element, it is placed outside the element. All 
     130                        // other browsers place it inside of it. So, the following code is 
     131                        // needed to fix it. 
     132                        if ( element.nodeType == 3 
     133                                && startBoundary 
     134                                && range.startOffset >= element.length ) 
     135                        { 
     136                                var nextText = element ; 
     137                                while ( nextText ) 
     138                                { 
     139                                        nextText = FCKDomTools.GetNextSourceNode( nextText, false, 3 ) ; 
     140 
     141                                        if ( nextText && nextText.length > 0 ) 
     142                                                break ; 
     143                                } 
     144                                element = nextText || element ; 
     145                        } 
     146 
     147                        return ( element.nodeType == 1 ? element : element.parentNode ) ; 
     148                } 
     149        } 
     150        return null ; 
     151} 
     152 
    101153FCKSelection.SelectNode = function( element ) 
    102154{ 
    103 //      FCK.Focus() ; 
    104  
    105155        var oRange = FCK.EditorDocument.createRange() ; 
    106156        oRange.selectNode( element ) ; 
  • FCKeditor/trunk/editor/_source/internals/fckselection_ie.js

    r668 r774  
    6464                case 'Control' : 
    6565                        var el = FCKSelection.GetSelectedElement() ; 
    66                         if ( !el ) 
    67                                 return null ; 
    68                         return el.parentElement ; 
     66                        return el ? el.parentElement : null ; 
    6967 
    7068                case 'None' : 
     
    7371                default : 
    7472                        return FCK.EditorDocument.selection.createRange().parentElement() ; 
     73        } 
     74} ; 
     75 
     76FCKSelection.GetBoundaryParentElement = function( startBoundary ) 
     77{ 
     78        switch ( this.GetType() ) 
     79        { 
     80                case 'Control' : 
     81                        var el = FCKSelection.GetSelectedElement() ; 
     82                        return el ? el.parentElement : null ; 
     83 
     84                case 'None' : 
     85                        return null ; 
     86 
     87                default : 
     88                        var range = FCK.EditorDocument.selection.createRange() ; 
     89                        range.collapse( startBoundary !== false ) ; 
     90                        return range.parentElement() ; 
    7591        } 
    7692} ; 
  • FCKeditor/trunk/editor/_source/internals/fcktools.js

    r771 r774  
    519519                domNode.style[i] = styleDict[ i ] ; 
    520520} 
     521 
     522/** 
     523 * Merge all objects passed by argument into a single object. 
     524 */ 
     525FCKTools.Merge = function() 
     526{ 
     527        var args = arguments ; 
     528        var o = args[0] ; 
     529 
     530        for ( var i = 1 ; i < args.length ; i++ ) 
     531        { 
     532                var arg = args[i] ; 
     533                for ( var p in arg ) 
     534                        o[p] = arg[p] ; 
     535        } 
     536 
     537        return o ; 
     538} 
     539 
     540/** 
     541 * Check if the passed argument is a real Array. It may not working when 
     542 * calling it cross windows. 
     543 */ 
     544FCKTools.IsArray = function( it ) 
     545{ 
     546        return ( it instanceof Array ) ; 
     547} 
     548 
     549/** 
     550 * Appends a "length" property to an object, containing the number of 
     551 * properties available on it, excluded the append property itself. 
     552 */ 
     553FCKTools.AppendLengthProperty = function( targetObject, propertyName ) 
     554{ 
     555        var counter = 0 ; 
     556 
     557        for ( var n in targetObject ) 
     558                counter++ ; 
     559 
     560        return targetObject[ propertyName || 'length' ] = counter ; 
     561} 
     562 
     563/** 
     564 * Gets the browser parsed version of a css text (style attribute value). On 
     565 * some cases, the browser makes changes to the css text, returning a different 
     566 * value. For example, hexadecimal colors get transformed to rgb(). 
     567 */ 
     568FCKTools.NormalizeCssText = function( unparsedCssText ) 
     569{ 
     570        // Injects the style in a temporary span object, so the browser parses it, 
     571        // retrieving its final format. 
     572        var tempSpan = document.createElement( 'span' ) ; 
     573        tempSpan.style.cssText = unparsedCssText ; 
     574        return tempSpan.style.cssText ; 
     575} 
  • FCKeditor/trunk/editor/_source/internals/fckxhtml.js

    r755 r774  
    3838        var bIsDirty = FCK.IsDirty() ; 
    3939 
    40         this._CreateNode = FCKConfig.ForceStrongEm ? FCKXHtml_CreateNode_StrongEm : FCKXHtml_CreateNode_Normal ; 
    41  
    4240        // Special blocks are blocks of content that remain untouched during the 
    4341        // process. It is used for SCRIPTs and STYLEs. 
     
    5149 
    5250        FCKXHtml.CurrentJobNum++ ; 
     51 
     52//      var dTimer = new Date() ; 
    5353 
    5454        if ( includeNode ) 
     
    5959        // Get the resulting XHTML as a string. 
    6060        var sXHTML = this._GetMainXmlString() ; 
     61 
     62//      alert( 'Time: ' + ( ( ( new Date() ) - dTimer ) ) + ' ms' ) ; 
    6163 
    6264        this.XML = null ; 
     
    232234                                return false ; 
    233235 
    234                         var oNode = this._CreateNode( sNodeName ) ; 
    235  
     236                        var oNode = this.XML.createElement( sNodeName ) ; 
     237                         
    236238                        // Add all attributes. 
    237239                        FCKXHtml._AppendAttributes( xmlNode, htmlNode, oNode, sNodeName ) ; 
     
    279281} 
    280282 
    281 function FCKXHtml_CreateNode_StrongEm( nodeName ) 
    282 { 
    283         switch ( nodeName ) 
    284         { 
    285                 case 'b' : 
    286                         nodeName = 'strong' ; 
    287                         break ; 
    288                 case 'i' : 
    289                         nodeName = 'em' ; 
    290                         break ; 
    291         } 
    292         return this.XML.createElement( nodeName ) ; 
    293 } 
    294  
    295 function FCKXHtml_CreateNode_Normal( nodeName ) 
    296 { 
    297         return this.XML.createElement( nodeName ) ; 
    298 } 
    299  
    300283// Append an item to the SpecialBlocks array and returns the tag to be used. 
    301284FCKXHtml._AppendSpecialItem = function( item ) 
  • FCKeditor/trunk/editor/css/fck_editorarea.css

    r701 r774  
    4141body, td 
    4242{ 
    43         font-family: Arial, Verdana, Sans-Serif; 
     43        font-family: Arial, Verdana, sans-serif; 
    4444        font-size: 12px; 
    4545} 
  • FCKeditor/trunk/editor/fckeditor.html

    r701 r774  
    1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> 
     1<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> 
    22<!-- 
    33 * FCKeditor - The text editor for Internet - http://www.fckeditor.net 
     
    8686LoadScript( '_source/classes/fckkeystrokehandler.js' ) ; 
    8787 
     88LoadScript( 'dtd/fck_xhtml10transitional.js' ) ; 
     89LoadScript( '_source/classes/fckstyle.js' ) ; 
     90LoadScript( '_source/internals/fckstyles.js' ) ; 
     91 
    8892LoadScript( '_source/internals/fcklisthandler.js' ) ; 
    8993LoadScript( '_source/classes/fckelementpath.js' ) ; 
     
    101105LoadScript( '_source/internals/fcktablehandler_' + sSuffix + '.js' ) ; 
    102106LoadScript( '_source/classes/fckxml_' + sSuffix + '.js' ) ; 
    103 LoadScript( '_source/classes/fckstyledef.js' ) ; 
    104 LoadScript( '_source/classes/fckstyledef_' + sSuffix + '.js' ) ; 
    105 LoadScript( '_source/classes/fckstylesloader.js' ) ; 
    106107 
    107108LoadScript( '_source/commandclasses/fcknamedcommand.js' ) ; 
     109LoadScript( '_source/commandclasses/fckstylecommand.js' ) ; 
    108110LoadScript( '_source/commandclasses/fck_othercommands.js' ) ; 
    109111LoadScript( '_source/commandclasses/fckshowblocks.js' ) ; 
     
    113115LoadScript( '_source/commandclasses/fckpastewordcommand.js' ) ; 
    114116LoadScript( '_source/commandclasses/fcktablecommand.js' ) ; 
    115 LoadScript( '_source/commandclasses/fckstylecommand.js' ) ; 
    116117LoadScript( '_source/commandclasses/fckfitwindow.js' ) ; 
    117118LoadScript( '_source/commandclasses/fcklistcommands.js' ) ; 
     119LoadScript( '_source/commandclasses/fckcorestylecommand.js' ) ; 
     120LoadScript( '_source/commandclasses/fckremoveformatcommand.js' ) ; 
    118121LoadScript( '_source/internals/fckcommands.js' ) ; 
    119122 
     
    124127LoadScript( '_source/classes/fckspecialcombo.js' ) ; 
    125128LoadScript( '_source/classes/fcktoolbarspecialcombo.js' ) ; 
     129LoadScript( '_source/classes/fcktoolbarstylecombo.js' ) ; 
     130LoadScript( '_source/classes/fcktoolbarfontformatcombo.js' ) ; 
    126131LoadScript( '_source/classes/fcktoolbarfontscombo.js' ) ; 
    127132LoadScript( '_source/classes/fcktoolbarfontsizecombo.js' ) ; 
    128 LoadScript( '_source/classes/fcktoolbarfontformatcombo.js' ) ; 
    129 LoadScript( '_source/classes/fcktoolbarstylecombo.js' ) ; 
    130133LoadScript( '_source/classes/fcktoolbarpanelbutton.js' ) ; 
    131134LoadScript( '_source/internals/fcktoolbaritems.js' ) ; 
     
    169172        FCK.IECleanup.AddItem( FCK, FCK_Cleanup ) ; 
    170173} 
     174 
     175// The first function to be called on selection change must the the styles 
     176// change checker, because the result of its processing may be used by another 
     177// functions listening to the same event. 
     178FCK.Events.AttachEvent( 'OnSelectionChange', function() { FCKStyles.CheckSelectionChanges() ; } ) ; 
    171179 
    172180// The config hidden field is processed immediately, because 
  • FCKeditor/trunk/fckconfig.js

    r729 r774  
    7474FCKConfig.FormatIndentator      = '    ' ; 
    7575 
    76 FCKConfig.ForceStrongEm = true ; 
    7776FCKConfig.GeckoUseSPAN  = false ; 
    7877FCKConfig.StartupFocus  = false ; 
     
    109108        ['Style','FontFormat','FontName','FontSize'], 
    110109        ['TextColor','BGColor'], 
    111         ['FitWindow','ShowBlocks','-','About'] 
     110        ['FitWindow','ShowBlocks','-','About']          // No comma for the last row. 
    112111] ; 
    113112 
     
    146145FCKConfig.FontColors = '000000,993300,333300,003300,003366,000080,333399,333333,800000,FF6600,808000,808080,008080,0000FF,666699,808080,FF0000,FF9900,99CC00,339966,33CCCC,3366FF,800080,999999,FF00FF,FFCC00,FFFF00,00FF00,00FFFF,00CCFF,993366,C0C0C0,FF99CC,FFCC99,FFFF99,CCFFCC,CCFFFF,99CCFF,CC99FF,FFFFFF' ; 
    147146 
     147FCKConfig.FontFormats   = 'p;div;pre;address;h1;h2;h3;h4;h5;h6' ; 
    148148FCKConfig.FontNames             = 'Arial;Comic Sans MS;Courier New;Tahoma;Times New Roman;Verdana' ; 
    149 FCKConfig.FontSizes             = '1/xx-small;2/x-small;3/small;4/medium;5/large;6/x-large;7/xx-large' ; 
    150 FCKConfig.FontFormats   = 'p;div;pre;address;h1;h2;h3;h4;h5;h6' ; 
     149FCKConfig.FontSizes             = 'smaller;larger;xx-small;x-small;small;medium;large;x-large;xx-large' ; 
    151150 
    152151FCKConfig.StylesXmlPath         = FCKConfig.EditorPath + 'fckstyles.xml' ; 
     
    186185// The option switches between trying to keep the html structure or do the changes so the content looks like it was in Word 
    187186FCKConfig.CleanWordKeepsStructure = false ; 
     187 
     188// Only inline elements are valid. 
     189FCKConfig.RemoveFormatTags = 'b,big,code,del,dfn,em,font,i,ins,kbd,q,samp,small,span,strike,strong,sub,sup,tt,u,var' ; 
     190 
     191FCKConfig.CustomStyles =  
     192{ 
     193        'Red Title'     : { Element : 'h3', Styles : { 'color' : 'Red' } } 
     194}; 
     195 
     196// Do not add, rename or remove styles here. Only apply definition changes. 
     197FCKConfig.CoreStyles =  
     198{ 
     199        // Basic Inline Styles. 
     200        'Bold'                  : { Element : 'b', Overrides : 'strong' }, 
     201        'Italic'                : { Element : 'i', Overrides : 'em' }, 
     202        'Underline'             : { Element : 'u' }, 
     203        'StrikeThrough' : { Element : 'strike' }, 
     204        'Subscript'             : { Element : 'sub' }, 
     205        'Superscript'   : { Element : 'sup' }, 
     206         
     207        // Basic Block Styles (Font Format Combo). 
     208        'p'                             : { Element : 'p' }, 
     209        'div'                   : { Element : 'div' }, 
     210        'pre'                   : { Element : 'pre' }, 
     211        'address'               : { Element : 'address' }, 
     212        'h1'                    : { Element : 'h1' }, 
     213        'h2'                    : { Element : 'h2' }, 
     214        'h3'                    : { Element : 'h3' }, 
     215        'h4'                    : { Element : 'h4' }, 
     216        'h5'                    : { Element : 'h5' }, 
     217        'h6'                    : { Element : 'h6' }, 
     218         
     219        // Other formatting features. 
     220        'FontFace' :  
     221        {  
     222                Element         : 'span',  
     223                Styles          : { 'font-family' : '#("Font")' },  
     224                Overrides       : [ { Element : 'font', Attributes : { 'face' : null } } ] 
     225        }, 
     226         
     227        'Size' : 
     228        {  
     229                Element         : 'span',  
     230                Styles          : { 'font-size' : '#("Size","fontSize")' },  
     231                Overrides       : [ { Element : 'font', Attributes : { 'size' : null } } ] 
     232        }, 
     233         
     234        'Color' : 
     235        {  
     236                Element         : 'span',  
     237                Styles          : { 'color' : '#("Color","color")' },  
     238                Overrides       : [ { Element : 'font', Attributes : { 'color' : null } } ] 
     239        }, 
     240         
     241        'BackColor'             : { Element : 'span', Styles : { 'background-color' : '#("Color","color")' } } 
     242}; 
    188243 
    189244// The following value defines which File Browser connector and Quick Upload 
  • FCKeditor/trunk/fckeditor.cfc

    r735 r774  
    211211        lConfigKeys = lConfigKeys & ",PreloadImages,PluginsPath,AutoDetectLanguage,DefaultLanguage,ContentLangDirection"; 
    212212        lConfigKeys = lConfigKeys & ",ProcessHTMLEntities,IncludeLatinEntities,IncludeGreekEntities,ProcessNumericEntities,AdditionalNumericEntities"; 
    213         lConfigKeys = lConfigKeys & ",FillEmptyBlocks,FormatSource,FormatOutput,FormatIndentator,ForceStrongEm"; 
     213        lConfigKeys = lConfigKeys & ",FillEmptyBlocks,FormatSource,FormatOutput,FormatIndentator"; 
    214214        lConfigKeys = lConfigKeys & ",GeckoUseSPAN,StartupFocus,ForcePasteAsPlainText,AutoDetectPasteFromWord,ForceSimpleAmpersand"; 
    215215        lConfigKeys = lConfigKeys & ",TabSpaces,ShowBorders,SourcePopup,ToolbarStartExpanded,ToolbarCanCollapse"; 
  • FCKeditor/trunk/fckeditor.cfm

    r729 r774  
    122122                lConfigKeys = lConfigKeys & ",PreloadImages,PluginsPath,AutoDetectLanguage,DefaultLanguage,ContentLangDirection"; 
    123123                lConfigKeys = lConfigKeys & ",ProcessHTMLEntities,IncludeLatinEntities,IncludeGreekEntities,ProcessNumericEntities,AdditionalNumericEntities"; 
    124                 lConfigKeys = lConfigKeys & ",FillEmptyBlocks,FormatSource,FormatOutput,FormatIndentator,ForceStrongEm"; 
     124                lConfigKeys = lConfigKeys & ",FillEmptyBlocks,FormatSource,FormatOutput,FormatIndentator"; 
    125125                lConfigKeys = lConfigKeys & ",GeckoUseSPAN,StartupFocus,ForcePasteAsPlainText,AutoDetectPasteFromWord,ForceSimpleAmpersand"; 
    126126                lConfigKeys = lConfigKeys & ",TabSpaces,ShowBorders,SourcePopup,ToolbarStartExpanded,ToolbarCanCollapse"; 
  • FCKeditor/trunk/fckpackager.xml

    r701 r774  
    6363                <Constant name="FCK_EDITMODE_WYSIWYG" value="0" /> 
    6464                <Constant name="FCK_EDITMODE_SOURCE" value="1" /> 
     65                <Constant name="FCK_STYLE_BLOCK" value="0" /> 
     66                <Constant name="FCK_STYLE_INLINE" value="1" /> 
     67                <Constant name="FCK_STYLE_OBJECT" value="2" /> 
    6568        </Constants> 
    6669        <PackageFile path="editor/js/fckeditorcode_ie.js"> 
     
    9396                <File path="editor/_source/classes/fckkeystrokehandler.js" /> 
    9497 
     98                <File path="editor/dtd/fck_xhtml10transitional.js" /> 
     99                <File path="editor/_source/classes/fckstyle.js" /> 
     100                <File path="editor/_source/internals/fckstyles.js" /> 
     101                           
    95102                <File path="editor/_source/internals/fcklisthandler.js" /> 
    96103                <File path="editor/_source/classes/fckelementpath.js" /> 
     
    108115                <File path="editor/_source/internals/fcktablehandler_ie.js" /> 
    109116                <File path="editor/_source/classes/fckxml_ie.js" /> 
    110                 <File path="editor/_source/classes/fckstyledef.js" /> 
    111                 <File path="editor/_source/classes/fckstyledef_ie.js" /> 
    112                 <File path="editor/_source/classes/fckstylesloader.js" /> 
    113117 
    114118                <File path="editor/_source/commandclasses/fcknamedcommand.js" /> 
     119                <File path="editor/_source/commandclasses/fckstylecommand.js" /> 
    115120                <File path="editor/_source/commandclasses/fck_othercommands.js" /> 
    116121                <File path="editor/_source/commandclasses/fckshowblocks.js" /> 
     
    120125                <File path="editor/_source/commandclasses/fckpastewordcommand.js" /> 
    121126                <File path="editor/_source/commandclasses/fcktablecommand.js" /> 
    122                 <File path="editor/_source/commandclasses/fckstylecommand.js" /> 
    123127                <File path="editor/_source/commandclasses/fckfitwindow.js" /> 
    124128                <File path="editor/_source/commandclasses/fcklistcommands.js" /> 
     129                <File path="editor/_source/commandclasses/fckcorestylecommand.js" /> 
     130                <File path="editor/_source/commandclasses/fckremoveformatcommand.js" /> 
    125131                <File path="editor/_source/internals/fckcommands.js" /> 
    126132 
     
    131137                <File path="editor/_source/classes/fckspecialcombo.js" /> 
    132138                <File path="editor/_source/classes/fcktoolbarspecialcombo.js" /> 
     139                <File path="editor/_source/classes/fcktoolbarstylecombo.js" /> 
     140                <File path="editor/_source/classes/fcktoolbarfontformatcombo.js" /> 
    133141                <File path="editor/_source/classes/fcktoolbarfontscombo.js" /> 
    134142                <File path="editor/_source/classes/fcktoolbarfontsizecombo.js" /> 
    135                 <File path="editor/_source/classes/fcktoolbarfontformatcombo.js" /> 
    136                 <File path="editor/_source/classes/fcktoolbarstylecombo.js" /> 
    137143                <File path="editor/_source/classes/fcktoolbarpanelbutton.js" /> 
    138144                <File path="editor/_source/internals/fcktoolbaritems.js" /> 
     
    181187                <File path="editor/_source/classes/fckkeystrokehandler.js" /> 
    182188 
     189                <File path="editor/dtd/fck_xhtml10transitional.js" /> 
     190                <File path="editor/_source/classes/fckstyle.js" /> 
     191                <File path="editor/_source/internals/fckstyles.js" /> 
     192 
    183193                <File path="editor/_source/internals/fcklisthandler.js" /> 
    184194                <File path="editor/_source/classes/fckelementpath.js" /> 
     
    196206                <File path="editor/_source/internals/fcktablehandler_gecko.js" /> 
    197207                <File path="editor/_source/classes/fckxml_gecko.js" /> 
    198                 <File path="editor/_source/classes/fckstyledef.js" /> 
    199                 <File path="editor/_source/classes/fckstyledef_gecko.js" /> 
    200                 <File path="editor/_source/classes/fckstylesloader.js" /> 
    201208 
    202209                <File path="editor/_source/commandclasses/fcknamedcommand.js" /> 
     210                <File path="editor/_source/commandclasses/fckstylecommand.js" /> 
    203211                <File path="editor/_source/commandclasses/fck_othercommands.js" /> 
    204212                <File path="editor/_source/commandclasses/fckshowblocks.js" /> 
     
    208216                <File path="editor/_source/commandclasses/fckpastewordcommand.js" /> 
    209217                <File path="editor/_source/commandclasses/fcktablecommand.js" /> 
    210                 <File path="editor/_source/commandclasses/fckstylecommand.js" /> 
    211218                <File path="editor/_source/commandclasses/fckfitwindow.js" /> 
    212219                <File path="editor/_source/commandclasses/fcklistcommands.js" /> 
     220                <File path="editor/_source/commandclasses/fckcorestylecommand.js" /> 
     221                <File path="editor/_source/commandclasses/fckremoveformatcommand.js" /> 
    213222                <File path="editor/_source/internals/fckcommands.js" /> 
    214223 
     
    219228                <File path="editor/_source/classes/fckspecialcombo.js" /> 
    220229                <File path="editor/_source/classes/fcktoolbarspecialcombo.js" /> 
     230                <File path="editor/_source/classes/fcktoolbarstylecombo.js" /> 
     231                <File path="editor/_source/classes/fcktoolbarfontformatcombo.js" /> 
    221232                <File path="editor/_source/classes/fcktoolbarfontscombo.js" /> 
    222233                <File path="editor/_source/classes/fcktoolbarfontsizecombo.js" /> 
    223                 <File path="editor/_source/classes/fcktoolbarfontformatcombo.js" /> 
    224                 <File path="editor/_source/classes/fcktoolbarstylecombo.js" /> 
    225234                <File path="editor/_source/classes/fcktoolbarpanelbutton.js" /> 
    226235                <File path="editor/_source/internals/fcktoolbaritems.js" /> 
  • FCKeditor/trunk/fckstyles.xml

    r132 r774  
    2626--> 
    2727<Styles> 
     28 
     29        <!-- Block Styles --> 
     30 
     31        <!-- 
     32        # These styles are already available in the "Format" combo, so they are not 
     33        # needed here by default. 
     34 
     35        <Style name="Heading 1" element="h1" /> 
     36        <Style name="Heading 2" element="h2" /> 
     37        <Style name="Heading 3" element="h3" /> 
     38        <Style name="Heading 4" element="h4" /> 
     39        <Style name="Heading 5" element="h5" /> 
     40        <Style name="Heading 6" element="h6" /> 
     41        <Style name="Paragraph" element="p" /> 
     42        <Style name="Document Block" element="div" /> 
     43        <Style name="Preformatted Text" element="pre" /> 
     44        <Style name="Address" element="address" /> 
     45        --> 
     46 
     47        <!-- Inline Styles --> 
     48 
     49        <!-- 
     50        # These are core styles available as toolbar buttons. 
     51 
     52        <Style name="Bold" element="b" /> 
     53        <Style name="Italic" element="i" /> 
     54        <Style name="Underline" element="u" /> 
     55        <Style name="Strikethrough" element="strike" /> 
     56        <Style name="Subscript" element="sub" /> 
     57        <Style name="Superscript" element="sup" /> 
     58        --> 
     59 
     60        <Style name="Marker: Yellow" element="span"> 
     61                <Style name="background-color" value="Yellow" /> 
     62        </Style> 
     63        <Style name="Marker: Green" element="span"> 
     64                <Style name="background-color" value="Lime" /> 
     65        </Style> 
     66 
     67        <Style name="Strong Emphasis" element="strong" /> 
     68        <Style name="Emphasis" element="em" /> 
     69 
     70        <Style name="Big" element="big" /> 
     71        <Style name="Small" element="small" /> 
     72        <Style name="Typewriter" element="tt" /> 
     73 
     74        <Style name="Computer Code" element="code" /> 
     75        <Style name="Keyboard Phrase" element="kbd" /> 
     76        <Style name="Sample Text" element="samp" /> 
     77        <Style name="Variable" element="var" /> 
     78 
     79        <Style name="Deleted Text" element="del" /> 
     80        <Style name="Inserted Text" element="ins" /> 
     81 
     82        <Style name="Cited Work" element="cite" /> 
     83        <Style name="Inline Quotation" element="q" /> 
     84 
     85        <Style name="Language: RTL" element="span"> 
     86                <Attribute name="dir" value="rtl" /> 
     87        </Style> 
     88        <Style name="Language: LTR" element="span"> 
     89                <Attribute name="dir" value="ltr" /> 
     90        </Style> 
     91        <Style name="Language: RTL Strong" element="bdo"> 
     92                <Attribute name="dir" value="rtl" /> 
     93        </Style> 
     94        <Style name="Language: LTR Strong" element="bdo"> 
     95                <Attribute name="dir" value="ltr" /> 
     96        </Style> 
     97 
     98        <!-- Object Styles --> 
     99 
    28100        <Style name="Image on Left" element="img"> 
    29101                <Attribute name="style" value="padding: 5px; margin-right: 5px" /> 
     
    36108                <Attribute name="align" value="right" /> 
    37109        </Style> 
    38         <Style name="Custom Bold" element="span"> 
    39                 <Attribute name="style" value="font-weight: bold;" /> 
    40         </Style> 
    41         <Style name="Custom Italic" element="em" /> 
    42         <Style name="Title" element="span"> 
    43                 <Attribute name="class" value="Title" /> 
    44         </Style> 
    45         <Style name="Code" element="span"> 
    46                 <Attribute name="class" value="Code" /> 
    47         </Style> 
    48         <Style name="Title H3" element="h3" /> 
    49         <Style name="Custom Ruler" element="hr"> 
    50                 <Attribute name="size" value="1" /> 
    51                 <Attribute name="color" value="#ff0000" /> 
    52         </Style> 
    53110</Styles> 
Note: See TracChangeset for help on using the changeset viewer.
© 2003 – 2012 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy