lista - etiquetas html
¿Cómo se calcula la propiedad bgcolor? (2)
Como indiqué en los comentarios, HTMLParser lo agrega como una propiedad CSS, y como Jasper ya respondió, es por especificación.
Implementación
Webkit analiza el html en HTMLParser.cpp y si el analizador es inBody agrega el atributo bgColor como CssColor en HTMLBodyElement.cpp
// Color parsing that matches HTML''s "rules for parsing a legacy color value"
void HTMLElement::addHTMLColorToStyle(StylePropertySet* style, CSSPropertyID propertyID, const String& attributeValue)
{
// An empty string doesn''t apply a color. (One containing only whitespace does, which is why this check occurs before stripping.)
if (attributeValue.isEmpty())
return;
String colorString = attributeValue.stripWhiteSpace();
// "transparent" doesn''t apply a color either.
if (equalIgnoringCase(colorString, "transparent"))
return;
// If the string is a named CSS color or a 3/6-digit hex color, use that.
Color parsedColor(colorString);
if (!parsedColor.isValid())
parsedColor.setRGB(parseColorStringWithCrazyLegacyRules(colorString));
style->setProperty(propertyID, cssValuePool().createColorValue(parsedColor.rgb()));
}
Tienes buenas posibilidades de terminar con este método:
static RGBA32 parseColorStringWithCrazyLegacyRules(const String& colorString)
Creo que es compatible con colores antiguos como este: body bgcolor = ff0000 ( Mozilla Gecko Test ).
- Omita un # líder
- Coge los primeros 128 caracteres, reemplazando los caracteres no hexadecimales con 0. 1120
- Los caracteres que no son BMP se reemplazan por "00" debido a que aparecen como dos "caracteres" en la cadena.
- Si no hay dígitos, devuelve Color negro
- Divida los dígitos en tres componentes, luego busque los últimos 8 dígitos de cada componente.
Código de Webkit / HTMLElement.cpp: parseColorStringWithCrazyLegacyRules :
static RGBA32 parseColorStringWithCrazyLegacyRules(const String& colorString)
{
// Per spec, only look at the first 128 digits of the string.
const size_t maxColorLength = 128;
// We''ll pad the buffer with two extra 0s later, so reserve two more than the max.
Vector<char, maxColorLength+2> digitBuffer;
size_t i = 0;
// Skip a leading #.
if (colorString[0] == ''#'')
i = 1;
// Grab the first 128 characters, replacing non-hex characters with 0.
// Non-BMP characters are replaced with "00" due to them appearing as two "characters" in the String.
for (; i < colorString.length() && digitBuffer.size() < maxColorLength; i++) {
if (!isASCIIHexDigit(colorString[i]))
digitBuffer.append(''0'');
else
digitBuffer.append(colorString[i]);
}
if (!digitBuffer.size())
return Color::black;
// Pad the buffer out to at least the next multiple of three in size.
digitBuffer.append(''0'');
digitBuffer.append(''0'');
if (digitBuffer.size() < 6)
return makeRGB(toASCIIHexValue(digitBuffer[0]), toASCIIHexValue(digitBuffer[1]), toASCIIHexValue(digitBuffer[2]));
// Split the digits into three components, then search the last 8 digits of each component.
ASSERT(digitBuffer.size() >= 6);
size_t componentLength = digitBuffer.size() / 3;
size_t componentSearchWindowLength = min<size_t>(componentLength, 8);
size_t redIndex = componentLength - componentSearchWindowLength;
size_t greenIndex = componentLength * 2 - componentSearchWindowLength;
size_t blueIndex = componentLength * 3 - componentSearchWindowLength;
// Skip digits until one of them is non-zero,
// or we''ve only got two digits left in the component.
while (digitBuffer[redIndex] == ''0'' && digitBuffer[greenIndex] == ''0''
&& digitBuffer[blueIndex] == ''0'' && (componentLength - redIndex) > 2) {
redIndex++;
greenIndex++;
blueIndex++;
}
ASSERT(redIndex + 1 < componentLength);
ASSERT(greenIndex >= componentLength);
ASSERT(greenIndex + 1 < componentLength * 2);
ASSERT(blueIndex >= componentLength * 2);
ASSERT(blueIndex + 1 < digitBuffer.size());
int redValue = toASCIIHexValue(digitBuffer[redIndex], digitBuffer[redIndex + 1]);
int greenValue = toASCIIHexValue(digitBuffer[greenIndex], digitBuffer[greenIndex + 1]);
int blueValue = toASCIIHexValue(digitBuffer[blueIndex], digitBuffer[blueIndex + 1]);
return makeRGB(redValue, greenValue, blueValue);
}
Posible duplicado:
¿Por qué HTML cree que "chucknorris" es un color?
¿Cómo se calcula la propiedad bgcolor ?
Cuando uso el siguiente código html ...
<body bgcolor="#Deine Mutter hat eine Farbe und die ist grün."></body>
... lo que obtengo es el siguiente color.
Por cierto: cuando intento usarlo en CSS, no funciona y aplicará el color estándar:
body{
color: #IchwillGOLD;
}
¿Por qué?
Mi primer intento fue un pequeño ensayo de error y, aunque encontré algunas propiedades interesantes del sistema, no fue suficiente para formar una respuesta. Luego, volví mi atención al estándar. La razón por la que creí que esto estaba en el estándar era porque lo probé en tres navegadores diferentes y todos hicieron lo mismo. Usando el estándar descubrí lo que sucede:
- Todos los caracteres que no son hexadecimales se reemplazan por ceros (por lo que solo quedan ceros, 1-9 y ae)
- La cadena tiene un relleno cero al final para ser un múltiplo de tres
- La cuerda se divide en tres partes iguales, cada una representando un color
- Si las cadenas resultantes tienen más de 8 caracteres, tome los últimos 8 caracteres de cada cadena
- Siempre que cada una de las cadenas comience con un cero, el primer carácter se elimina de cada cadena (no ocurre para esta cadena en particular, ya que comienza con
De - Los primeros dos caracteres se toman de cada una de esas cadenas y se convierten a un número para usar como uno de los componentes del color
De esta forma, verás que obtienes 00FA00 para Deine Mutter hat eine Farbe und die ist grün.
El estándar html5 describe el proceso de manera más precisa y describe un par de casos más aquí: http://www.w3.org/TR/html5/common-microsyntaxes.html#colors bajo las "reglas para analizar un valor de color heredado"