Ticket #6976: override.patch

_source/plugins/colorbutton/plugin.js

@@ -287 +287 @@
 CKEDITOR.config.colorButton_backStyle =
         {
                 element         : 'span',
-                styles          : { 'background-color' : '#(color)' }
+                styles          : { 'background-color' : '#(color)' },
+        overrides       : [ { element : '*', styles             : { 'background-color' : null }} ]
         };

_source/plugins/styles/plugin.js

@@ -100 +100 @@
                 {
                         styleDefinition = CKEDITOR.tools.clone( styleDefinition );
 
-                        replaceVariables( styleDefinition.attributes, variablesValues );
-                        replaceVariables( styleDefinition.styles, variablesValues );
+                        replaceVariables( styleDefinition, variablesValues );
                 }
 
                 var element = this.element = ( styleDefinition.element || '*' ).toLowerCase();
@@ -221 +220 @@
                                 return false;
 
                         var def = this._.definition,
-                                attribs;
+                                attribs,
+                styles;
 
                         // If the element name is the same as the style name.
                         if ( element.getName() == this.element )
@@ -260 +260 @@
                         }
 
                         // Check if the element can be somehow overriden.
-                        var override = getOverrides( this )[ element.getName() ] ;
+                        var overrides = getOverrides( this ),
+                override = overrides[ element.getName() ]|| overrides["*"];
                         if ( override )
                         {
                                 // If no attributes have been defined, remove the element.
-                                if ( !( attribs = override.attributes ) )
+                                if ( !( attribs = override.attributes ) && !(styles = override.styles))
                                         return true;
+                if(attribs)
+                {
+                    for (  i = 0 ; i < attribs.length ; i++ )
+                    {
+                        attName = attribs[i][0];
+                        var actualAttrValue = element.getAttribute( attName );
+                        if ( actualAttrValue )
+                        {
+                            var attValue = attribs[i][1];
 
-                                for ( var i = 0 ; i < attribs.length ; i++ )
-                                {
-                                        attName = attribs[i][0];
-                                        var actualAttrValue = element.getAttribute( attName );
-                                        if ( actualAttrValue )
-                                        {
-                                                var attValue = attribs[i][1];
+                            // Remove the attribute if:
+                            //    - The override definition value is null;
+                            //    - The override definition value is a string that
+                            //      matches the attribute value exactly.
+                            //    - The override definition value is a regex that
+                            //      has matches in the attribute value.
+                            if ( attValue === null ||
+                                    ( typeof attValue == 'string' && actualAttrValue == attValue ) ||
+                                    attValue.test( actualAttrValue ) )
+                                return true;
+                        }
+                    }
+                }
+                if(styles)
+                {
+                    for ( var i = 0 ; i < styles.length ; i++ )
+                    {
+                        var styleName = styles[i][0];
+                        var actualStyleValue = element.getStyle( styleName );
+                        if ( actualStyleValue )
+                        {
+                            var styleValue = styles[i][1];
 
-                                                // Remove the attribute if:
-                                                //    - The override definition value is null;
-                                                //    - The override definition value is a string that
-                                                //      matches the attribute value exactly.
-                                                //    - The override definition value is a regex that
-                                                //      has matches in the attribute value.
-                                                if ( attValue === null ||
-                                                                ( typeof attValue == 'string' && actualAttrValue == attValue ) ||
-                                                                attValue.test( actualAttrValue ) )
-                                                        return true;
-                                        }
-                                }
+
+                            if ( styleValue === null ||
+                                    ( typeof styleValue == 'string' && actualStyleValue == attValue ) ||
+                                    styleValue.test && styleValue.test( actualStyleValue ) )
+                                return true;
+                        }
+                    }
+                }
                         }
                         return false;
                 },
@@ -1063 +1084 @@
         function removeFromElement( style, element )
         {
                 var def = style._.definition,
-                        attributes = CKEDITOR.tools.extend( {}, def.attributes, getOverrides( style )[ element.getName() ] ),
-                        styles = def.styles,
+            overrides = getOverrides( style ),
+            override = overrides[ element.getName() ] || overrides[ "*" ] || {},
+                        attributes = CKEDITOR.tools.extend( {}, def.attributes, override.attributes ),
+                        styles = CKEDITOR.tools.extend( {}, def.styles, override.styles ),
                         // If the style is only about the element itself, we have to remove the element.
                         removeEmpty = CKEDITOR.tools.isEmpty( attributes ) && CKEDITOR.tools.isEmpty( styles );
 
                 // Remove definition attributes/style from the elemnt.
                 for ( var attName in attributes )
                 {
+            if( !attributes.hasOwnProperty( attName ) ) continue;
                         // The 'class' element value must match (#1318).
                         if ( ( attName == 'class' || style._.definition.fullMatch )
                                 && element.getAttribute( attName ) != normalizeProperty( attName, attributes[ attName ] ) )
@@ -1081 +1105 @@
 
                 for ( var styleName in styles )
                 {
+            if( !styles.hasOwnProperty( styleName ) ) continue;
                         // Full match style insist on having fully equivalence. (#5018)
                         if ( style._.definition.fullMatch
                                 && element.getStyle( styleName ) != normalizeProperty( styleName, styles[ styleName ], true ) )
@@ -1097 +1122 @@
         function removeFromInsideElement( style, element )
         {
                 var def = style._.definition,
-                        attribs = def.attributes,
-                        styles = def.styles,
+
                         overrides = getOverrides( style );
 
                 var innerElements = element.getElementsByTag( style.element );
@@ -1157 +1181 @@
                         }
                 }
 
+        var styles = overrides && overrides.styles ;
+
+        if ( styles )
+                {
+                        for ( var i = 0 ; i < styles.length ; i++ )
+                        {
+                                var styleName = styles[i][0], actualStyleValue ;
+
+                                if ( ( actualStyleValue = element.getStyle( styleName ) ) )
+                                {
+                                        var styleValue = styles[i][1] ;
+
+
+                                        if ( styleValue === null ||
+                                                        ( styleValue.test && styleValue.test( actualStyleValue ) ) ||
+                                                        ( typeof styleValue == 'string' && actualStyleValue == styleValue ) )
+                                                element.removeStyle( styleName ) ;
+                                }
+                        }
+                }
+
                 removeNoAttribsElement( element );
         }
 
@@ -1243 +1288 @@
         {
                 for ( var item in list )
                 {
-                        list[ item ] = list[ item ].replace( varRegex, function( match, varName )
+            if (!list.hasOwnProperty(item)) continue;
+            if(typeof list[ item ]==='string')
+            {
+                list[ item ] = list[ item ].replace( varRegex, function( match, varName )
                                 {
                                         return variablesValues[ varName ];
                                 });
+            }
+            else
+            {
+                replaceVariables(list[ item ],variablesValues);
+            }
+
                 }
         }
 
@@ -1320 +1374 @@
                                 var elementName;
                                 var overrideEl;
                                 var attrs;
+                //consider overrides's style
+                var styles;
 
                                 // If can be a string with the element name.
                                 if ( typeof override == 'string' )
@@ -1329 +1385 @@
                                 {
                                         elementName = override.element ? override.element.toLowerCase() : style.element;
                                         attrs = override.attributes;
+                    styles = override.styles;
                                 }
 
                                 // We can have more than one override definition for the same
@@ -1350 +1407 @@
                                                 overrideAttrs.push( [ attName.toLowerCase(), attrs[ attName ] ] );
                                         }
                                 }
+
+                // note : consider override's style
+                if ( styles )
+                                {
+                                        var overrideStyles = ( overrideEl.styles = overrideEl.styles || [] );
+                                        for ( var styleName in styles )
+                                        {
+                                                overrideStyles.push( [ styleName.toLowerCase(), styles[ styleName ] ] );
+                                        }
+                                }
                         }
                 }