Ticket #6977: override.patch

File override.patch, 8.4 KB (added by yiminghe, 4 years ago)
  • _source/plugins/colorbutton/plugin.js

     
    287287CKEDITOR.config.colorButton_backStyle = 
    288288        { 
    289289                element         : 'span', 
    290                 styles          : { 'background-color' : '#(color)' } 
     290                styles          : { 'background-color' : '#(color)' }, 
     291        overrides       : [ { element : '*', styles             : { 'background-color' : null }} ] 
    291292        }; 
  • _source/plugins/styles/plugin.js

     
    100100                { 
    101101                        styleDefinition = CKEDITOR.tools.clone( styleDefinition ); 
    102102 
    103                         replaceVariables( styleDefinition.attributes, variablesValues ); 
    104                         replaceVariables( styleDefinition.styles, variablesValues ); 
     103                        replaceVariables( styleDefinition, variablesValues ); 
    105104                } 
    106105 
    107106                var element = this.element = ( styleDefinition.element || '*' ).toLowerCase(); 
     
    221220                                return false; 
    222221 
    223222                        var def = this._.definition, 
    224                                 attribs; 
     223                                attribs, 
     224                styles; 
    225225 
    226226                        // If the element name is the same as the style name. 
    227227                        if ( element.getName() == this.element ) 
     
    260260                        } 
    261261 
    262262                        // Check if the element can be somehow overriden. 
    263                         var override = getOverrides( this )[ element.getName() ] ; 
     263                        var overrides = getOverrides( this ), 
     264                override = overrides[ element.getName() ]|| overrides["*"]; 
    264265                        if ( override ) 
    265266                        { 
    266267                                // If no attributes have been defined, remove the element. 
    267                                 if ( !( attribs = override.attributes ) ) 
     268                                if ( !( attribs = override.attributes ) && !(styles = override.styles)) 
    268269                                        return true; 
     270                if(attribs) 
     271                { 
     272                    for (  i = 0 ; i < attribs.length ; i++ ) 
     273                    { 
     274                        attName = attribs[i][0]; 
     275                        var actualAttrValue = element.getAttribute( attName ); 
     276                        if ( actualAttrValue ) 
     277                        { 
     278                            var attValue = attribs[i][1]; 
    269279 
    270                                 for ( var i = 0 ; i < attribs.length ; i++ ) 
    271                                 { 
    272                                         attName = attribs[i][0]; 
    273                                         var actualAttrValue = element.getAttribute( attName ); 
    274                                         if ( actualAttrValue ) 
    275                                         { 
    276                                                 var attValue = attribs[i][1]; 
     280                            // Remove the attribute if: 
     281                            //    - The override definition value is null; 
     282                            //    - The override definition value is a string that 
     283                            //      matches the attribute value exactly. 
     284                            //    - The override definition value is a regex that 
     285                            //      has matches in the attribute value. 
     286                            if ( attValue === null || 
     287                                    ( typeof attValue == 'string' && actualAttrValue == attValue ) || 
     288                                    attValue.test( actualAttrValue ) ) 
     289                                return true; 
     290                        } 
     291                    } 
     292                } 
     293                if(styles) 
     294                { 
     295                    for ( var i = 0 ; i < styles.length ; i++ ) 
     296                    { 
     297                        var styleName = styles[i][0]; 
     298                        var actualStyleValue = element.getStyle( styleName ); 
     299                        if ( actualStyleValue ) 
     300                        { 
     301                            var styleValue = styles[i][1]; 
    277302 
    278                                                 // Remove the attribute if: 
    279                                                 //    - The override definition value is null; 
    280                                                 //    - The override definition value is a string that 
    281                                                 //      matches the attribute value exactly. 
    282                                                 //    - The override definition value is a regex that 
    283                                                 //      has matches in the attribute value. 
    284                                                 if ( attValue === null || 
    285                                                                 ( typeof attValue == 'string' && actualAttrValue == attValue ) || 
    286                                                                 attValue.test( actualAttrValue ) ) 
    287                                                         return true; 
    288                                         } 
    289                                 } 
     303 
     304                            if ( styleValue === null || 
     305                                    ( typeof styleValue == 'string' && actualStyleValue == attValue ) || 
     306                                    styleValue.test && styleValue.test( actualStyleValue ) ) 
     307                                return true; 
     308                        } 
     309                    } 
     310                } 
    290311                        } 
    291312                        return false; 
    292313                }, 
     
    10631084        function removeFromElement( style, element ) 
    10641085        { 
    10651086                var def = style._.definition, 
    1066                         attributes = CKEDITOR.tools.extend( {}, def.attributes, getOverrides( style )[ element.getName() ] ), 
    1067                         styles = def.styles, 
     1087            overrides = getOverrides( style ), 
     1088            override = overrides[ element.getName() ] || overrides[ "*" ] || {}, 
     1089                        attributes = CKEDITOR.tools.extend( {}, def.attributes, override.attributes ), 
     1090                        styles = CKEDITOR.tools.extend( {}, def.styles, override.styles ), 
    10681091                        // If the style is only about the element itself, we have to remove the element. 
    10691092                        removeEmpty = CKEDITOR.tools.isEmpty( attributes ) && CKEDITOR.tools.isEmpty( styles ); 
    10701093 
    10711094                // Remove definition attributes/style from the elemnt. 
    10721095                for ( var attName in attributes ) 
    10731096                { 
     1097            if( !attributes.hasOwnProperty( attName ) ) continue; 
    10741098                        // The 'class' element value must match (#1318). 
    10751099                        if ( ( attName == 'class' || style._.definition.fullMatch ) 
    10761100                                && element.getAttribute( attName ) != normalizeProperty( attName, attributes[ attName ] ) ) 
     
    10811105 
    10821106                for ( var styleName in styles ) 
    10831107                { 
     1108            if( !styles.hasOwnProperty( styleName ) ) continue; 
    10841109                        // Full match style insist on having fully equivalence. (#5018) 
    10851110                        if ( style._.definition.fullMatch 
    10861111                                && element.getStyle( styleName ) != normalizeProperty( styleName, styles[ styleName ], true ) ) 
     
    10971122        function removeFromInsideElement( style, element ) 
    10981123        { 
    10991124                var def = style._.definition, 
    1100                         attribs = def.attributes, 
    1101                         styles = def.styles, 
     1125 
    11021126                        overrides = getOverrides( style ); 
    11031127 
    11041128                var innerElements = element.getElementsByTag( style.element ); 
     
    11571181                        } 
    11581182                } 
    11591183 
     1184        var styles = overrides && overrides.styles ; 
     1185 
     1186        if ( styles ) 
     1187                { 
     1188                        for ( var i = 0 ; i < styles.length ; i++ ) 
     1189                        { 
     1190                                var styleName = styles[i][0], actualStyleValue ; 
     1191 
     1192                                if ( ( actualStyleValue = element.getStyle( styleName ) ) ) 
     1193                                { 
     1194                                        var styleValue = styles[i][1] ; 
     1195 
     1196 
     1197                                        if ( styleValue === null || 
     1198                                                        ( styleValue.test && styleValue.test( actualStyleValue ) ) || 
     1199                                                        ( typeof styleValue == 'string' && actualStyleValue == styleValue ) ) 
     1200                                                element.removeStyle( styleName ) ; 
     1201                                } 
     1202                        } 
     1203                } 
     1204 
    11601205                removeNoAttribsElement( element ); 
    11611206        } 
    11621207 
     
    12431288        { 
    12441289                for ( var item in list ) 
    12451290                { 
    1246                         list[ item ] = list[ item ].replace( varRegex, function( match, varName ) 
     1291            if (!list.hasOwnProperty(item)) continue; 
     1292            if(typeof list[ item ]==='string') 
     1293            { 
     1294                list[ item ] = list[ item ].replace( varRegex, function( match, varName ) 
    12471295                                { 
    12481296                                        return variablesValues[ varName ]; 
    12491297                                }); 
     1298            } 
     1299            else 
     1300            { 
     1301                replaceVariables(list[ item ],variablesValues); 
     1302            } 
     1303 
    12501304                } 
    12511305        } 
    12521306 
     
    13201374                                var elementName; 
    13211375                                var overrideEl; 
    13221376                                var attrs; 
     1377                //consider overrides's style 
     1378                var styles; 
    13231379 
    13241380                                // If can be a string with the element name. 
    13251381                                if ( typeof override == 'string' ) 
     
    13291385                                { 
    13301386                                        elementName = override.element ? override.element.toLowerCase() : style.element; 
    13311387                                        attrs = override.attributes; 
     1388                    styles = override.styles; 
    13321389                                } 
    13331390 
    13341391                                // We can have more than one override definition for the same 
     
    13501407                                                overrideAttrs.push( [ attName.toLowerCase(), attrs[ attName ] ] ); 
    13511408                                        } 
    13521409                                } 
     1410 
     1411                // note : consider override's style 
     1412                if ( styles ) 
     1413                                { 
     1414                                        var overrideStyles = ( overrideEl.styles = overrideEl.styles || [] ); 
     1415                                        for ( var styleName in styles ) 
     1416                                        { 
     1417                                                overrideStyles.push( [ styleName.toLowerCase(), styles[ styleName ] ] ); 
     1418                                        } 
     1419                                } 
    13531420                        } 
    13541421                } 
    13551422 
© 2003 – 2012 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy