static inline void adjustFocusRingColor(Color& color) { #if !PLATFORM(GTK) // Force the alpha to 50%. This matches what the Mac does with outline rings. color.setRGB(makeRGBA(color.red(), color.green(), color.blue(), 127)); #endif }
void SVGAnimatedColorAnimator::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGAnimatedType* from, SVGAnimatedType* to, SVGAnimatedType* toAtEndOfDuration, SVGAnimatedType* animated) { ASSERT(m_animationElement); ASSERT(m_contextElement); StyleColor fromStyleColor = m_animationElement->animationMode() == ToAnimation ? animated->color() : from->color(); StyleColor toStyleColor = to->color(); StyleColor toAtEndOfDurationStyleColor = toAtEndOfDuration->color(); StyleColor& animatedStyleColor = animated->color(); // Apply CSS inheritance rules. m_animationElement->adjustForInheritance<StyleColor>(parseColorFromString, m_animationElement->fromPropertyValueType(), fromStyleColor, m_contextElement); m_animationElement->adjustForInheritance<StyleColor>(parseColorFromString, m_animationElement->toPropertyValueType(), toStyleColor, m_contextElement); // Apply currentColor rules. Color fallbackColor = fallbackColorForCurrentColor(m_contextElement); Color fromColor = fromStyleColor.resolve(fallbackColor); Color toColor = toStyleColor.resolve(fallbackColor); Color toAtEndOfDurationColor = toAtEndOfDurationStyleColor.resolve(fallbackColor); Color animatedColor = animatedStyleColor.resolve(fallbackColor); float animatedRed = animatedColor.red(); m_animationElement->animateAdditiveNumber(percentage, repeatCount, fromColor.red(), toColor.red(), toAtEndOfDurationColor.red(), animatedRed); float animatedGreen = animatedColor.green(); m_animationElement->animateAdditiveNumber(percentage, repeatCount, fromColor.green(), toColor.green(), toAtEndOfDurationColor.green(), animatedGreen); float animatedBlue = animatedColor.blue(); m_animationElement->animateAdditiveNumber(percentage, repeatCount, fromColor.blue(), toColor.blue(), toAtEndOfDurationColor.blue(), animatedBlue); float animatedAlpha = animatedColor.alpha(); m_animationElement->animateAdditiveNumber(percentage, repeatCount, fromColor.alpha(), toColor.alpha(), toAtEndOfDurationColor.alpha(), animatedAlpha); animatedStyleColor = StyleColor(makeRGBA(roundf(animatedRed), roundf(animatedGreen), roundf(animatedBlue), roundf(animatedAlpha))); }
void SVGColorProperty::calculateAnimatedValue(SVGAnimationElement* animationElement, float percentage, unsigned repeatCount, PassRefPtr<NewSVGPropertyBase> fromValue, PassRefPtr<NewSVGPropertyBase> toValue, PassRefPtr<NewSVGPropertyBase> toAtEndOfDurationValue, SVGElement* contextElement) { StyleColor fromStyleColor = toSVGColorProperty(fromValue)->m_styleColor; StyleColor toStyleColor = toSVGColorProperty(toValue)->m_styleColor; StyleColor toAtEndOfDurationStyleColor = toSVGColorProperty(toAtEndOfDurationValue)->m_styleColor; // Apply currentColor rules. ASSERT(contextElement); Color fallbackColor = fallbackColorForCurrentColor(contextElement); Color fromColor = fromStyleColor.resolve(fallbackColor); Color toColor = toStyleColor.resolve(fallbackColor); Color toAtEndOfDurationColor = toAtEndOfDurationStyleColor.resolve(fallbackColor); Color animatedColor = m_styleColor.resolve(fallbackColor); ASSERT(animationElement); float animatedRed = animatedColor.red(); animationElement->animateAdditiveNumber(percentage, repeatCount, fromColor.red(), toColor.red(), toAtEndOfDurationColor.red(), animatedRed); float animatedGreen = animatedColor.green(); animationElement->animateAdditiveNumber(percentage, repeatCount, fromColor.green(), toColor.green(), toAtEndOfDurationColor.green(), animatedGreen); float animatedBlue = animatedColor.blue(); animationElement->animateAdditiveNumber(percentage, repeatCount, fromColor.blue(), toColor.blue(), toAtEndOfDurationColor.blue(), animatedBlue); float animatedAlpha = animatedColor.alpha(); animationElement->animateAdditiveNumber(percentage, repeatCount, fromColor.alpha(), toColor.alpha(), toAtEndOfDurationColor.alpha(), animatedAlpha); m_styleColor = StyleColor(makeRGBA(roundf(animatedRed), roundf(animatedGreen), roundf(animatedBlue), roundf(animatedAlpha))); }
Color::Color(CGColorRef color) { if (!color) { m_color = 0; m_valid = false; return; } size_t numComponents = CGColorGetNumberOfComponents(color); const CGFloat* components = CGColorGetComponents(color); float r = 0; float g = 0; float b = 0; float a = 0; switch (numComponents) { case 2: r = g = b = components[0]; a = components[1]; break; case 4: r = components[0]; g = components[1]; b = components[2]; a = components[3]; break; default: ASSERT_NOT_REACHED(); } m_color = makeRGBA(r * 255, g * 255, b * 255, a * 255); m_valid = true; }
static bool parseRGBParameters(CSSParserTokenRange& range, RGBA32& result, bool parseAlpha) { ASSERT(range.peek().functionId() == CSSValueRgb || range.peek().functionId() == CSSValueRgba); CSSParserTokenRange args = consumeFunction(range); CSSPrimitiveValue* colorParameter = consumeInteger(args); if (!colorParameter) colorParameter = consumePercent(args, ValueRangeAll); if (!colorParameter) return false; const bool isPercent = colorParameter->isPercentage(); int colorArray[3]; colorArray[0] = clampRGBComponent(*colorParameter); for (int i = 1; i < 3; i++) { if (!consumeCommaIncludingWhitespace(args)) return false; colorParameter = isPercent ? consumePercent(args, ValueRangeAll) : consumeInteger(args); if (!colorParameter) return false; colorArray[i] = clampRGBComponent(*colorParameter); } if (parseAlpha) { if (!consumeCommaIncludingWhitespace(args)) return false; double alpha; if (!consumeNumberRaw(args, alpha)) return false; // Convert the floating pointer number of alpha to an integer in the range [0, 256), // with an equal distribution across all 256 values. int alphaComponent = static_cast<int>(clampTo<double>(alpha, 0.0, 1.0) * nextafter(256.0, 0.0)); result = makeRGBA(colorArray[0], colorArray[1], colorArray[2], alphaComponent); } else { result = makeRGB(colorArray[0], colorArray[1], colorArray[2]); } return args.atEnd(); }
RGBA32 makeRGBAFromCMYKA(float c, float m, float y, float k, float a) { double colors = 1 - k; int r = static_cast<int>(nextafter(256, 0) * (colors * (1 - c))); int g = static_cast<int>(nextafter(256, 0) * (colors * (1 - m))); int b = static_cast<int>(nextafter(256, 0) * (colors * (1 - y))); return makeRGBA(r, g, b, static_cast<float>(nextafter(256, 0) * a)); }
// all values are in the range of 0 to 1.0 RGBA32 makeRGBAFromHSLA(double hue, double saturation, double lightness, double alpha) { const double scaleFactor = nextafter(256.0, 0.0); if (!saturation) { int greyValue = static_cast<int>(lightness * scaleFactor); return makeRGBA(greyValue, greyValue, greyValue, static_cast<int>(alpha * scaleFactor)); } double temp2 = lightness < 0.5 ? lightness * (1.0 + saturation) : lightness + saturation - lightness * saturation; double temp1 = 2.0 * lightness - temp2; return makeRGBA(static_cast<int>(calcHue(temp1, temp2, hue + 1.0 / 3.0) * scaleFactor), static_cast<int>(calcHue(temp1, temp2, hue) * scaleFactor), static_cast<int>(calcHue(temp1, temp2, hue - 1.0 / 3.0) * scaleFactor), static_cast<int>(alpha * scaleFactor)); }
static bool fastParseColorInternal(RGBA32& rgb, const CharacterType* characters, unsigned length, bool quirksMode) { CSSPrimitiveValue::UnitType expect = CSSPrimitiveValue::UnitType::Unknown; if (length >= 4 && characters[0] == '#') return Color::parseHexColor(characters + 1, length - 1, rgb); if (quirksMode && (length == 3 || length == 6)) { if (Color::parseHexColor(characters, length, rgb)) return true; } // Try rgba() syntax. if (mightBeRGBA(characters, length)) { const CharacterType* current = characters + 5; const CharacterType* end = characters + length; int red; int green; int blue; int alpha; if (!parseColorIntOrPercentage(current, end, ',', expect, red)) return false; if (!parseColorIntOrPercentage(current, end, ',', expect, green)) return false; if (!parseColorIntOrPercentage(current, end, ',', expect, blue)) return false; if (!parseAlphaValue(current, end, ')', alpha)) return false; if (current != end) return false; rgb = makeRGBA(red, green, blue, alpha); return true; } // Try rgb() syntax. if (mightBeRGB(characters, length)) { const CharacterType* current = characters + 4; const CharacterType* end = characters + length; int red; int green; int blue; if (!parseColorIntOrPercentage(current, end, ',', expect, red)) return false; if (!parseColorIntOrPercentage(current, end, ',', expect, green)) return false; if (!parseColorIntOrPercentage(current, end, ')', expect, blue)) return false; if (current != end) return false; rgb = makeRGB(red, green, blue); return true; } return false; }
// all values are in the range of 0 to 1.0 RGBA32 makeRGBAFromHSLA(double h, double s, double l, double a) { double temp2 = l < 0.5 ? l * (1.0 + s) : l + s - l * s; double temp1 = 2.0 * l - temp2; return makeRGBA(static_cast<int>(calcHue(temp1, temp2, h + 1.0 / 3.0) * 255), static_cast<int>(calcHue(temp1, temp2, h) * 255), static_cast<int>(calcHue(temp1, temp2, h - 1.0 / 3.0) * 255), static_cast<int>(a * 255)); }
static RefPtrWillBeRawPtr<CSSShadowValue> createShadowValue() { RefPtrWillBeRawPtr<CSSPrimitiveValue> color = CSSPrimitiveValue::createColor(makeRGBA(112, 123, 175, 255)); RefPtrWillBeRawPtr<CSSPrimitiveValue> x = CSSPrimitiveValue::create(10, CSSPrimitiveValue::UnitType::Pixels); RefPtrWillBeRawPtr<CSSPrimitiveValue> y = CSSPrimitiveValue::create(20, CSSPrimitiveValue::UnitType::Pixels); RefPtrWillBeRawPtr<CSSPrimitiveValue> blur = CSSPrimitiveValue::create(30, CSSPrimitiveValue::UnitType::Pixels); RefPtrWillBeRawPtr<CSSPrimitiveValue> spread = CSSPrimitiveValue::create(40, CSSPrimitiveValue::UnitType::Pixels); return CSSShadowValue::create(x, y, blur, spread, CSSPrimitiveValue::createIdentifier(CSSValueNone), color); }
void ScrollbarThemeOpus::paintThumb(GraphicsContext* context, ScrollbarThemeClient* scrollbar, const IntRect& rect) { if (!clientOpacityMap->contains(scrollbar)) return; int opacity = clientOpacityMap->get(scrollbar); if (!opacity) return; IntRect thumbRect = rect; thumbRect.inflate(-1); int scrollThickness = thumbRect.width() < thumbRect.height() ? thumbRect.width() : thumbRect.height(); IntSize curveSize(scrollThickness / 2, scrollThickness / 2); Color fillColor(makeRGBA(128, 128, 128, opacity)); context->fillRoundedRect(thumbRect, curveSize, curveSize, curveSize, curveSize, fillColor, ColorSpaceDeviceRGB); }
PassRefPtrWillBeRawPtr<CSSPrimitiveValue> ColorStyleInterpolation::interpolableValueToColor(const InterpolableValue& value) { ASSERT(value.isList()); const InterpolableList* list = toInterpolableList(&value); double alpha = toInterpolableNumber(list->get(3))->value(); if (!alpha) return CSSPrimitiveValue::createColor(Color::transparent); // Clamping is inside makeRGBA. unsigned rgba = makeRGBA( round(toInterpolableNumber(list->get(0))->value() / alpha), round(toInterpolableNumber(list->get(1))->value() / alpha), round(toInterpolableNumber(list->get(2))->value() / alpha), round(alpha)); return CSSPrimitiveValue::createColor(rgba); }
Color::Color(CGColorRef color) { if (!color) { m_color = 0; m_valid = false; return; } #if !PLATFORM(IOS) size_t numComponents = CGColorGetNumberOfComponents(color); const CGFloat* components = CGColorGetComponents(color); #else RetainPtr<CGColorRef> correctedColor = adoptCF(createCGColorWithDeviceRGBA(color)); if (!correctedColor) correctedColor = color; size_t numComponents = CGColorGetNumberOfComponents(correctedColor.get()); const CGFloat* components = CGColorGetComponents(correctedColor.get()); #endif // !PLATFORM(IOS) float r = 0; float g = 0; float b = 0; float a = 0; switch (numComponents) { case 2: r = g = b = components[0]; a = components[1]; break; case 4: r = components[0]; g = components[1]; b = components[2]; a = components[3]; break; default: ASSERT_NOT_REACHED(); } m_color = makeRGBA(r * 255, g * 255, b * 255, a * 255); m_valid = true; }
Vector<SVGGradientStop> SVGGradientElement::buildStops() const { Vector<SVGGradientStop> stops; RenderStyle* gradientStyle = 0; for (Node* n = firstChild(); n; n = n->nextSibling()) { SVGElement* element = n->isSVGElement() ? static_cast<SVGElement*>(n) : 0; if (element && element->isGradientStop()) { SVGStopElement* stop = static_cast<SVGStopElement*>(element); float stopOffset = stop->offset(); Color color; float opacity; if (stop->renderer()) { RenderStyle* stopStyle = stop->renderer()->style(); color = stopStyle->svgStyle()->stopColor(); opacity = stopStyle->svgStyle()->stopOpacity(); } else { // If there is no renderer for this stop element, then a parent element // set display="none" - ie. <g display="none"><linearGradient><stop>.. // Unfortunately we have to manually rebuild the stop style. See pservers-grad-19-b.svg if (!gradientStyle) gradientStyle = const_cast<SVGGradientElement*>(this)->styleForRenderer(parent()->renderer()); RenderStyle* stopStyle = stop->resolveStyle(gradientStyle); color = stopStyle->svgStyle()->stopColor(); opacity = stopStyle->svgStyle()->stopOpacity(); stopStyle->deref(document()->renderArena()); } stops.append(makeGradientStop(stopOffset, makeRGBA(color.red(), color.green(), color.blue(), int(opacity * 255.)))); } } if (gradientStyle) gradientStyle->deref(document()->renderArena()); return stops; }
/* ============================================================================= =============================================================================== */ int C3DSceneMgr::createUITexture(string strFileName, int &width, int &height, int &txWidth) { Fl_Image * img = openTextureFile(strFileName); if (img == NULL) { return -1; } width = img->w(); height = img->h(); // need to add an alpha channel to properly overlay on existing textures const unsigned char *pData = NULL; if (img->d() == 3) pData = makeRGBA((const unsigned char *) img->data()[0], width, height); else pData = (const unsigned char *) img->data()[0]; GLuint textureID; glGenTextures(1, &textureID); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glBindTexture(GL_TEXTURE_2D, textureID); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); int txHeight = height; txWidth = (width <= 64) ? 64 : (width <= 128) ? 128 : width; const unsigned char *pDataNew = NULL; if (width != txWidth) { pDataNew = padOut(pData, width, height, txWidth); txHeight = txWidth; } glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, txWidth, txHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, pDataNew ? pDataNew : pData); if (pDataNew) delete[] pDataNew; if (img->d() == 3) delete[] pData; delete img; return textureID; }
Color CSSColorInterpolationType::resolveInterpolableColor(const InterpolableValue& interpolableColor, const StyleResolverState& state, bool isVisited, bool isTextDecoration) { const InterpolableList& list = toInterpolableList(interpolableColor); ASSERT(list.length() == InterpolableColorIndexCount); double red = toInterpolableNumber(list.get(Red))->value(); double green = toInterpolableNumber(list.get(Green))->value(); double blue = toInterpolableNumber(list.get(Blue))->value(); double alpha = toInterpolableNumber(list.get(Alpha))->value(); if (double currentcolorFraction = toInterpolableNumber(list.get(Currentcolor))->value()) { auto currentColorGetter = isVisited ? ColorPropertyFunctions::getVisitedColor : ColorPropertyFunctions::getUnvisitedColor; StyleColor currentStyleColor = StyleColor::currentColor(); if (isTextDecoration) currentStyleColor = currentColorGetter(CSSPropertyWebkitTextFillColor, *state.style()); if (currentStyleColor.isCurrentColor()) currentStyleColor = currentColorGetter(CSSPropertyColor, *state.style()); addPremultipliedColor(red, green, blue, alpha, currentcolorFraction, currentStyleColor.getColor()); } const TextLinkColors& colors = state.document().textLinkColors(); if (double webkitActivelinkFraction = toInterpolableNumber(list.get(WebkitActivelink))->value()) addPremultipliedColor(red, green, blue, alpha, webkitActivelinkFraction, colors.activeLinkColor()); if (double webkitLinkFraction = toInterpolableNumber(list.get(WebkitLink))->value()) addPremultipliedColor(red, green, blue, alpha, webkitLinkFraction, isVisited ? colors.visitedLinkColor() : colors.linkColor()); if (double quirkInheritFraction = toInterpolableNumber(list.get(QuirkInherit))->value()) addPremultipliedColor(red, green, blue, alpha, quirkInheritFraction, colors.textColor()); alpha = clampTo<double>(alpha, 0, 255); if (alpha == 0) return Color::transparent; return makeRGBA( round(red / alpha), round(green / alpha), round(blue / alpha), round(alpha)); }
Color DragData::asColor() const { return makeRGBA(0, 0, 0, 0); }
Color::Color(const rgb_color& color) : m_color(makeRGBA(color.red, color.green, color.blue, color.alpha)) , m_valid(true) { }
Color::Color(const ClutterColor& c) : m_color(makeRGBA(c.red, c.green, c.blue, c.alpha)) , m_valid(true) { }
void QtWebPageEventHandler::handleInputMethodEvent(QInputMethodEvent* ev) { QString commit = ev->commitString(); QString composition = ev->preeditString(); int replacementStart = ev->replacementStart(); int replacementLength = ev->replacementLength(); // NOTE: We might want to handle events of one char as special // and resend them as key events to make web site completion work. int cursorPositionWithinComposition = 0; Vector<CompositionUnderline> underlines; for (int i = 0; i < ev->attributes().size(); ++i) { const QInputMethodEvent::Attribute& attr = ev->attributes().at(i); switch (attr.type) { case QInputMethodEvent::TextFormat: { if (composition.isEmpty()) break; QTextCharFormat textCharFormat = attr.value.value<QTextFormat>().toCharFormat(); QColor qcolor = textCharFormat.underlineColor(); Color color = makeRGBA(qcolor.red(), qcolor.green(), qcolor.blue(), qcolor.alpha()); int start = qMin(attr.start, (attr.start + attr.length)); int end = qMax(attr.start, (attr.start + attr.length)); underlines.append(CompositionUnderline(start, end, color, false)); break; } case QInputMethodEvent::Cursor: if (attr.length) cursorPositionWithinComposition = attr.start; break; // Selection is handled further down. default: break; } } if (composition.isEmpty()) { int selectionStart = -1; int selectionLength = 0; for (int i = 0; i < ev->attributes().size(); ++i) { const QInputMethodEvent::Attribute& attr = ev->attributes().at(i); if (attr.type == QInputMethodEvent::Selection) { selectionStart = attr.start; selectionLength = attr.length; ASSERT(selectionStart >= 0); ASSERT(selectionLength >= 0); break; } } m_webPageProxy->confirmComposition(commit, selectionStart, selectionLength); } else { ASSERT(cursorPositionWithinComposition >= 0); ASSERT(replacementStart >= 0); m_webPageProxy->setComposition(composition, underlines, cursorPositionWithinComposition, cursorPositionWithinComposition, replacementStart, replacementLength); } ev->accept(); }
void GraphicsContext::setPlatformShadow(const FloatSize& offset, float blur, const Color& color, ColorSpace) { if (paintingDisabled()) return; FloatSize adjustedOffset = offset; if (m_state.shadowsIgnoreTransforms) { // Meaning that this graphics context is associated with a CanvasRenderingContext // We flip the height since CG and HTML5 Canvas have opposite Y axis adjustedOffset.setHeight(-offset.height()); } // if there is an invalid shadow color, we're supposed to use Apple's CG default platformContext()->setShadow(adjustedOffset, blur, color.isValid() ? color.rgb() : makeRGBA(0, 0, 0, 0xFF / 3), m_state.shadowsIgnoreTransforms); }
Color::Color(const QColor& c) : m_color(makeRGBA(c.red(), c.green(), c.blue(), c.alpha())) { m_valid = c.isValid(); }
void Font::drawGlyphs(GraphicsContext* context, const SimpleFontData* font, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& point) const { FS_STATE* iType = font->platformData().scaledFont(context->getCTM().yScale()); if (!iType) return; FloatPoint adjustedPoint = point; if (font->platformData().orientation() == Vertical) adjustedPoint.move(-(font->fontMetrics().floatAscent(IdeographicBaseline) - font->fontMetrics().floatAscent()), 0); bool softwareBlurRequired = context->state().shadowBlur / font->fontMetrics().xHeight() > 0.5; FloatSize currentShadowOffset; float currentShadowBlur; Color currentShadowColor; ColorSpace currentColorSpace; // If we have a shadow blur, and it is too big to apply at text-render time, we must render it now. if (context->hasShadow() && softwareBlurRequired) { context->getShadow(currentShadowOffset, currentShadowBlur, currentShadowColor, currentColorSpace); const GraphicsContextState state = context->state(); FloatSize offset = state.shadowOffset; if (state.shadowsIgnoreTransforms) offset.setHeight(-offset.height()); ShadowBlur shadow(FloatSize(state.shadowBlur, state.shadowBlur), offset, state.shadowColor, state.shadowColorSpace); FloatPoint minPoint(adjustedPoint.x(), adjustedPoint.y() - fontMetrics().ascent()); FloatPoint maxPoint(adjustedPoint.x(), adjustedPoint.y() + fontMetrics().descent()); FloatPoint currentPoint = adjustedPoint; for (int i = 0; i < numGlyphs; ++i) { currentPoint += *glyphBuffer.advances(from + i); minPoint.setX(std::min(minPoint.x(), currentPoint.x())); minPoint.setY(std::min(minPoint.y(), currentPoint.y())); maxPoint = maxPoint.expandedTo(currentPoint); } const FloatRect boundingRect(minPoint.x(), minPoint.y(), maxPoint.x() - minPoint.x(), maxPoint.y() - minPoint.y()); GraphicsContext* shadowContext = shadow.beginShadowLayer(context, boundingRect); if (shadowContext) { iType = font->platformData().scaledFont(shadowContext->getCTM().yScale()); shadowContext->platformContext()->addGlyphs(glyphBuffer.glyphs(from), reinterpret_cast<const BlackBerry::Platform::FloatSize*>(glyphBuffer.advances(from)), numGlyphs, adjustedPoint, iType, 0, 0); iType = font->platformData().scaledFont(context->getCTM().yScale()); shadow.endShadowLayer(context); } context->platformContext()->clearShadow(); } context->platformContext()->addGlyphs(glyphBuffer.glyphs(from), reinterpret_cast<const BlackBerry::Platform::FloatSize*>(glyphBuffer.advances(from)), numGlyphs, adjustedPoint, iType, context->fillGradient() ? context->fillGradient()->platformGradient() : (context->fillPattern() ? context->fillPattern()->platformPattern(AffineTransform()) : static_cast<BlackBerry::Platform::Graphics::Paint*>(0)), context->strokeGradient() ? context->strokeGradient()->platformGradient() : (context->strokePattern() ? context->strokePattern()->platformPattern(AffineTransform()) : static_cast<BlackBerry::Platform::Graphics::Paint*>(0))); if (softwareBlurRequired) context->platformContext()->setShadow(currentShadowOffset, currentShadowBlur, currentShadowColor.isValid() ? currentShadowColor.rgb() : makeRGBA(0, 0, 0, 0xFF / 3), context->state().shadowsIgnoreTransforms); }