Ticket #6977: override.patch

File override.patch, 8.4 KB (added by yiminghe, 5 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 – 2015 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy