// Drawing Routines
void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dst,
const FloatRect& src, CompositeOperator op)
{
startAnimation();
QPixmap* image = nativeImageForCurrentFrame();
if (!image)
return;
if (mayFillWithSolidColor()) {
fillWithSolidColor(ctxt, dst, solidColor(), op);
return;
}
IntSize selfSize = size();
ctxt->save();
// Set the compositing operation.
ctxt->setCompositeOperation(op);
QPainter* painter(ctxt->platformContext());
if (!image->hasAlpha() && painter->compositionMode() == QPainter::CompositionMode_SourceOver)
painter->setCompositionMode(QPainter::CompositionMode_Source);
// Test using example site at
// http://www.meyerweb.com/eric/css/edge/complexspiral/demo.html
painter->drawPixmap(dst, *image, src);
ctxt->restore();
if (imageObserver())
imageObserver()->didDraw(this);
}
// Drawing Routines
void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dst,
const FloatRect& src, CompositeOperator op)
{
QPixmap* image = nativeImageForCurrentFrame();
if (!image)
return;
if (mayFillWithSolidColor()) {
fillWithSolidColor(ctxt, dst, solidColor(), op);
return;
}
IntSize selfSize = size();
FloatRect srcRect(src);
FloatRect dstRect(dst);
ctxt->save();
// Set the compositing operation.
ctxt->setCompositeOperation(op);
QPainter* painter(ctxt->platformContext());
// Test using example site at
// http://www.meyerweb.com/eric/css/edge/complexspiral/demo.html
painter->drawPixmap(dst, *image, src);
ctxt->restore();
startAnimation();
}
void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dstRect,
const FloatRect& srcRect, ColorSpace colorSpace, CompositeOperator compositeOp)
{
if (!m_source.initialized())
return;
// Spin the animation to the correct frame before we try to draw it, so we
// don't draw an old frame and then immediately need to draw a newer one,
// causing flicker and wasting CPU.
startAnimation();
NativeImageSkia* bm = nativeImageForCurrentFrame();
if (!bm)
return; // It's too early and we don't have an image yet.
FloatRect normDstRect = normalizeRect(dstRect);
FloatRect normSrcRect = normalizeRect(srcRect);
if (normSrcRect.isEmpty() || normDstRect.isEmpty())
return; // Nothing to draw.
if (ctxt->platformContext()->useGPU() && ctxt->platformContext()->canAccelerate()) {
drawBitmapGLES2(ctxt, bm, normSrcRect, normDstRect, colorSpace, compositeOp);
return;
}
ctxt->platformContext()->prepareForSoftwareDraw();
paintSkBitmap(ctxt->platformContext(),
*bm,
enclosingIntRect(normSrcRect),
normDstRect,
WebCoreCompositeToSkiaComposite(compositeOp));
}
void Image::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRect, const TransformationMatrix& patternTransform,
const FloatPoint& phase, CompositeOperator op, const FloatRect& destRect)
{
QPixmap* framePixmap = nativeImageForCurrentFrame();
if (!framePixmap) // If it's too early we won't have an image yet.
return;
QPixmap pixmap = *framePixmap;
QRect tr = QRectF(tileRect).toRect();
if (tr.x() || tr.y() || tr.width() != pixmap.width() || tr.height() != pixmap.height())
pixmap = pixmap.copy(tr);
QBrush b(pixmap);
b.setTransform(patternTransform);
ctxt->save();
ctxt->setCompositeOperation(op);
QPainter* p = ctxt->platformContext();
if (!pixmap.hasAlpha() && p->compositionMode() == QPainter::CompositionMode_SourceOver)
p->setCompositionMode(QPainter::CompositionMode_Source);
p->setBrushOrigin(phase);
p->fillRect(destRect, b);
ctxt->restore();
if (imageObserver())
imageObserver()->didDraw(this);
}
void Image::drawImage(GraphicsContext *gc, const FloatRect &dstRect, const FloatRect &srcRect,
ColorSpace, CompositeOperator, BlendMode)
{
JNIEnv* env = WebCore_GetJavaEnv();
if (!gc || gc->paintingDisabled()) {
return;
}
NativeImagePtr currFrame = nativeImageForCurrentFrame();
if (!currFrame) {
return;
}
gc->platformContext()->rq().freeSpace(72)
<< (jint)com_sun_webkit_graphics_GraphicsDecoder_DRAWIMAGE
<< currFrame
<< dstRect.x() << dstRect.y()
<< dstRect.width() << dstRect.height()
<< srcRect.x() << srcRect.y()
<< srcRect.width() << srcRect.height();
if (imageObserver())
imageObserver()->didDraw(this);
}
void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dstRect,
const FloatRect& srcRect, ColorSpace colorSpace, CompositeOperator compositeOp)
{
if (!m_source.initialized())
return;
// Spin the animation to the correct frame before we try to draw it, so we
// don't draw an old frame and then immediately need to draw a newer one,
// causing flicker and wasting CPU.
startAnimation();
NativeImageSkia* bm = nativeImageForCurrentFrame();
if (!bm)
return; // It's too early and we don't have an image yet.
FloatRect normDstRect = normalizeRect(dstRect);
FloatRect normSrcRect = normalizeRect(srcRect);
if (normSrcRect.isEmpty() || normDstRect.isEmpty())
return; // Nothing to draw.
paintSkBitmap(ctxt->platformContext(),
*bm,
normSrcRect,
normDstRect,
WebCoreCompositeToSkiaComposite(compositeOp));
if (ImageObserver* observer = imageObserver())
observer->didDraw(this);
}
void Image::drawPattern(GraphicsContext* context, const FloatRect& floatSrcRect, const FloatSize& scale,
const FloatPoint& phase, CompositeOperator compositeOp, const FloatRect& destRect, WebBlendMode blendMode, const IntSize& repeatSpacing)
{
TRACE_EVENT0("skia", "Image::drawPattern");
if (RefPtr<NativeImageSkia> bitmap = nativeImageForCurrentFrame())
bitmap->drawPattern(context, adjustForNegativeSize(floatSrcRect), scale, phase, compositeOp, destRect, blendMode, repeatSpacing);
}
void BitmapImage::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRect, const AffineTransform& patternTransform,
const FloatPoint& phase, CompositeOperator op, const FloatRect& destRect)
{
QPixmap* framePixmap = nativeImageForCurrentFrame();
if (!framePixmap) // If it's too early we won't have an image yet.
return;
QPixmap pixmap = *framePixmap;
QRect tr = QRectF(tileRect).toRect();
if (tr.x() || tr.y() || tr.width() != pixmap.width() || tr.height() != pixmap.height()) {
pixmap = pixmap.copy(tr);
}
if (patternTransform.isIdentity()) {
ctxt->save();
ctxt->setCompositeOperation(op);
QPainter* p = ctxt->platformContext();
p->setBrushOrigin(phase);
p->drawTiledPixmap(destRect, pixmap);
ctxt->restore();
} else {
QBrush b(pixmap);
b.setMatrix(patternTransform);
ctxt->save();
ctxt->setCompositeOperation(op);
QPainter* p = ctxt->platformContext();
p->setBrushOrigin(phase);
p->fillRect(destRect, b);
ctxt->restore();
}
}
void Image::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRect, const AffineTransform& patternTransform,
const FloatPoint& phase, ColorSpace, CompositeOperator op, const FloatRect& destRect)
{
QPixmap* framePixmap = nativeImageForCurrentFrame();
if (!framePixmap) // If it's too early we won't have an image yet.
return;
// Qt interprets 0 width/height as full width/height so just short circuit.
QRectF dr = QRectF(destRect).normalized();
QRect tr = QRectF(tileRect).toRect().normalized();
if (!dr.width() || !dr.height() || !tr.width() || !tr.height())
return;
QPixmap pixmap = *framePixmap;
if (tr.x() || tr.y() || tr.width() != pixmap.width() || tr.height() != pixmap.height())
pixmap = pixmap.copy(tr);
CompositeOperator previousOperator = ctxt->compositeOperation();
ctxt->setCompositeOperation(!pixmap.hasAlpha() && op == CompositeSourceOver ? CompositeCopy : op);
QPainter* p = ctxt->platformContext();
QTransform transform(patternTransform);
// If this would draw more than one scaled tile, we scale the pixmap first and then use the result to draw.
if (transform.type() == QTransform::TxScale) {
QRectF tileRectInTargetCoords = (transform * QTransform().translate(phase.x(), phase.y())).mapRect(tr);
bool tileWillBePaintedOnlyOnce = tileRectInTargetCoords.contains(dr);
if (!tileWillBePaintedOnlyOnce) {
QSizeF scaledSize(float(pixmap.width()) * transform.m11(), float(pixmap.height()) * transform.m22());
QPixmap scaledPixmap(scaledSize.toSize());
if (pixmap.hasAlpha())
scaledPixmap.fill(Qt::transparent);
{
QPainter painter(&scaledPixmap);
painter.setCompositionMode(QPainter::CompositionMode_Source);
painter.setRenderHints(p->renderHints());
painter.drawPixmap(QRect(0, 0, scaledPixmap.width(), scaledPixmap.height()), pixmap);
}
pixmap = scaledPixmap;
transform = QTransform::fromTranslate(transform.dx(), transform.dy());
}
}
/* Translate the coordinates as phase is not in world matrix coordinate space but the tile rect origin is. */
transform *= QTransform().translate(phase.x(), phase.y());
transform.translate(tr.x(), tr.y());
QBrush b(pixmap);
b.setTransform(transform);
p->fillRect(dr, b);
ctxt->setCompositeOperation(previousOperator);
if (imageObserver())
imageObserver()->didDraw(this);
}
void BitmapImage::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRectIn, const AffineTransform& patternTransform,
const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
{
RefPtr<SharedBitmap> bmp = nativeImageForCurrentFrame();
if (!bmp)
return;
bmp->drawPattern(ctxt, tileRectIn, patternTransform, phase, styleColorSpace, op, destRect, m_source.size());
}
void Image::drawPattern(GraphicsContext& ctxt, const FloatRect& tileRect, const AffineTransform& patternTransform,
const FloatPoint& phase, const FloatSize& spacing, CompositeOperator op, const FloatRect& destRect, BlendMode blendMode)
{
if (!nativeImageForCurrentFrame())
return;
ctxt.drawPattern(*this, tileRect, patternTransform, phase, spacing, op, destRect, blendMode);
if (imageObserver())
imageObserver()->didDraw(this);
}
void Image::drawPattern(GraphicsContext* context, const FloatRect& tileRect, const AffineTransform& patternTransform,
const FloatPoint& phase, ColorSpace colorSpace, CompositeOperator op, const FloatRect& destRect)
{
cairo_surface_t* image = nativeImageForCurrentFrame();
if (!image) // If it's too early we won't have an image yet.
return;
cairo_t* cr = context->platformContext()->cr();
drawPatternToCairoContext(cr, image, size(), tileRect, patternTransform, phase, toCairoOperator(op), destRect);
if (imageObserver())
imageObserver()->didDraw(this);
}
void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dstRect, const FloatRect& srcRect, ColorSpace colorSpace, CompositeOperator compositeOp, RespectImageOrientationEnum shouldRespectImageOrientation)
{
if (!m_source.initialized())
return;
// Spin the animation to the correct frame before we try to draw it, so we
// don't draw an old frame and then immediately need to draw a newer one,
// causing flicker and wasting CPU.
startAnimation();
NativeImageSkia* bm = nativeImageForCurrentFrame();
if (!bm)
return; // It's too early and we don't have an image yet.
FloatRect normDstRect = normalizeRect(dstRect);
FloatRect normSrcRect = normalizeRect(srcRect);
normSrcRect.intersect(FloatRect(0, 0, bm->bitmap().width(), bm->bitmap().height()));
if (normSrcRect.isEmpty() || normDstRect.isEmpty())
return; // Nothing to draw.
ImageOrientation orientation = DefaultImageOrientation;
if (shouldRespectImageOrientation == RespectImageOrientation)
orientation = frameOrientationAtIndex(m_currentFrame);
GraphicsContextStateSaver saveContext(*ctxt, false);
if (orientation != DefaultImageOrientation) {
saveContext.save();
// ImageOrientation expects the origin to be at (0, 0)
ctxt->translate(normDstRect.x(), normDstRect.y());
normDstRect.setLocation(FloatPoint());
ctxt->concatCTM(orientation.transformFromDefault(normDstRect.size()));
if (orientation.usesWidthAsHeight()) {
// The destination rect will have it's width and height already reversed for the orientation of
// the image, as it was needed for page layout, so we need to reverse it back here.
normDstRect = FloatRect(normDstRect.x(), normDstRect.y(), normDstRect.height(), normDstRect.width());
}
}
paintSkBitmap(ctxt->platformContext(),
*bm,
normSrcRect,
normDstRect,
WebCoreCompositeToSkiaComposite(compositeOp));
if (ImageObserver* observer = imageObserver())
observer->didDraw(this);
}
void Image::drawPattern(GraphicsContext* context, const FloatRect& tileRect, const TransformationMatrix& patternTransform,
const FloatPoint& phase, CompositeOperator op, const FloatRect& destRect)
{
cairo_surface_t* image = nativeImageForCurrentFrame();
if (!image) // If it's too early we won't have an image yet.
return;
cairo_t* cr = context->platformContext();
context->save();
IntRect imageSize = enclosingIntRect(tileRect);
OwnPtr<ImageBuffer> imageSurface = ImageBuffer::create(imageSize.size(), false);
if (!imageSurface)
return;
if (tileRect.size() != size()) {
cairo_t* clippedImageContext = imageSurface->context()->platformContext();
cairo_set_source_surface(clippedImageContext, image, -tileRect.x(), -tileRect.y());
cairo_paint(clippedImageContext);
image = imageSurface->image()->nativeImageForCurrentFrame();
}
cairo_pattern_t* pattern = cairo_pattern_create_for_surface(image);
cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT);
// Workaround to avoid the unwanted gradient effect (#14017)
cairo_pattern_set_filter(pattern, CAIRO_FILTER_NEAREST);
cairo_matrix_t pattern_matrix = cairo_matrix_t(patternTransform);
cairo_matrix_t phase_matrix = {1, 0, 0, 1, phase.x() + tileRect.x() * patternTransform.a(), phase.y() + tileRect.y() * patternTransform.d()};
cairo_matrix_t combined;
cairo_matrix_multiply(&combined, &pattern_matrix, &phase_matrix);
cairo_matrix_invert(&combined);
cairo_pattern_set_matrix(pattern, &combined);
context->setCompositeOperation(op);
cairo_set_source(cr, pattern);
cairo_pattern_destroy(pattern);
cairo_rectangle(cr, destRect.x(), destRect.y(), destRect.width(), destRect.height());
cairo_fill(cr);
context->restore();
if (imageObserver())
imageObserver()->didDraw(this);
}
void Image::drawPattern(GraphicsContext* context, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, ColorSpace, CompositeOperator op, const FloatRect& dstRect)
{
BBitmap* image = nativeImageForCurrentFrame();
if (!image || !image->IsValid()) // If the image hasn't fully loaded.
return;
// Figure out if the image has any alpha transparency, we can use faster drawing if not
bool hasAlpha = false;
uint8* bits = reinterpret_cast<uint8*>(image->Bits());
uint32 width = image->Bounds().IntegerWidth() + 1;
uint32 height = image->Bounds().IntegerHeight() + 1;
uint32 bytesPerRow = image->BytesPerRow();
for (uint32 y = 0; y < height && !hasAlpha; y++) {
uint8* p = bits;
for (uint32 x = 0; x < width && !hasAlpha; x++) {
hasAlpha = p[3] < 255;
p += 4;
}
bits += bytesPerRow;
}
context->save();
if (hasAlpha)
context->platformContext()->SetDrawingMode(B_OP_ALPHA);
else
context->platformContext()->SetDrawingMode(B_OP_COPY);
context->clip(enclosingIntRect(dstRect));
float currentW = phase.x();
BRect bTileRect(tileRect);
while (currentW < dstRect.x() + dstRect.width()) {
float currentH = phase.y();
while (currentH < dstRect.y() + dstRect.height()) {
BRect bDstRect(currentW, currentH, currentW + width - 1, currentH + height - 1);
context->platformContext()->DrawBitmapAsync(image, bTileRect, bDstRect);
currentH += height;
}
currentW += width;
}
context->restore();
if (imageObserver())
imageObserver()->didDraw(this);
}
void BitmapImage::checkForSolidColor()
{
TiledImageOpenVG* tiledImage = 0;
if (m_frameCount == 1 && m_size.width() == 1 && m_size.height() == 1)
tiledImage = nativeImageForCurrentFrame();
if (tiledImage) {
m_isSolidColor = true;
RGBA32 pixel;
vgGetImageSubData(tiledImage->tile(0, 0), &pixel, 0, VG_sARGB_8888, 0, 0, 1, 1);
ASSERT_VG_NO_ERROR();
m_solidColor.setRGB(pixel);
} else
m_isSolidColor = false;
m_checkedForSolidColor = true;
}
void Image::drawPattern(GraphicsContext& context, const FloatRect& tileRect, const AffineTransform& patternTransform,
const FloatPoint& phase, ColorSpace, CompositeOperator op, const FloatRect& destRect, BlendMode blendOp)
{
RefPtr<cairo_surface_t> surface = nativeImageForCurrentFrame();
if (!surface) // If it's too early we won't have an image yet.
return;
cairo_t* cr = context.platformContext()->cr();
cairo_operator_t cairoOp;
if (blendOp == BlendModeNormal)
cairoOp = toCairoOperator(op);
else
cairoOp = toCairoOperator(blendOp);
drawPatternToCairoContext(cr, surface.get(), IntSize(size()), tileRect, patternTransform, phase, cairoOp, destRect);
if (imageObserver())
imageObserver()->didDraw(this);
}
// Drawing Routines
void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dst,
const FloatRect& src, ColorSpace styleColorSpace, CompositeOperator op)
{
QRectF normalizedDst = dst.normalized();
QRectF normalizedSrc = src.normalized();
startAnimation();
if (normalizedSrc.isEmpty() || normalizedDst.isEmpty())
return;
QPixmap* image = nativeImageForCurrentFrame();
if (!image)
return;
if (mayFillWithSolidColor()) {
fillWithSolidColor(ctxt, normalizedDst, solidColor(), styleColorSpace, op);
return;
}
#if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
normalizedSrc = adjustSourceRectForDownSampling(normalizedSrc, image->size());
#endif
CompositeOperator previousOperator = ctxt->compositeOperation();
ctxt->setCompositeOperation(!image->hasAlpha() && op == CompositeSourceOver ? CompositeCopy : op);
if (ctxt->hasShadow()) {
ShadowBlur* shadow = ctxt->shadowBlur();
GraphicsContext* shadowContext = shadow->beginShadowLayer(ctxt, normalizedDst);
if (shadowContext) {
QPainter* shadowPainter = shadowContext->platformContext();
shadowPainter->drawPixmap(normalizedDst, *image, normalizedSrc);
shadow->endShadowLayer(ctxt);
}
}
ctxt->platformContext()->drawPixmap(normalizedDst, *image, normalizedSrc);
ctxt->setCompositeOperation(previousOperator);
if (imageObserver())
imageObserver()->didDraw(this);
}
// Drawing Routines
void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dst,
const FloatRect& src, CompositeOperator op)
{
os::Bitmap* image = nativeImageForCurrentFrame();
if (!image) // If it's too early we won't have an image yet.
return;
if (mayFillWithSolidColor()) {
fillWithSolidColor(ctxt, dst, solidColor(), op);
return;
}
//DEBUG( "Image::draw() %f %f\n", image->GetBounds().Width(), image->GetBounds().Height() );
IntSize selfSize = size();
FloatRect srcRect(src);
FloatRect dstRect(dst);
ctxt->save();
// Set the compositing operation.
ctxt->setCompositeOperation(op);
os::View* view = ctxt->platformContext();
os::Rect cSrc = srcRect;
os::Rect cDst = dstRect;
cSrc.Resize( 0, 0, -1, -1 );
cDst.Resize( 0, 0, -1, -1 );
if( !image->GetBounds().Includes( cSrc ) )
DEBUG( "Error: Image::draw(): Source size larger than bitmap\n" );
view->DrawBitmap( image, cSrc & image->GetBounds(), cDst );
#if 0
QPainter* painter(ctxt->platformContext());
// Test using example site at
// http://www.meyerweb.com/eric/css/edge/complexspiral/demo.html
painter->drawImage(dst, *image, src);
#endif
ctxt->restore();
startAnimation();
}
// Drawing Routines
void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dst,
const FloatRect& src, ColorSpace styleColorSpace, CompositeOperator op)
{
QRectF normalizedDst = dst.normalized();
QRectF normalizedSrc = src.normalized();
startAnimation();
if (normalizedSrc.isEmpty() || normalizedDst.isEmpty())
return;
QPixmap* image = nativeImageForCurrentFrame();
if (!image)
return;
if (mayFillWithSolidColor()) {
fillWithSolidColor(ctxt, normalizedDst, solidColor(), styleColorSpace, op);
return;
}
CompositeOperator previousOperator = ctxt->compositeOperation();
ctxt->setCompositeOperation(!image->hasAlpha() && op == CompositeSourceOver ? CompositeCopy : op);
ContextShadow* shadow = ctxt->contextShadow();
if (shadow->m_type != ContextShadow::NoShadow) {
QPainter* shadowPainter = shadow->beginShadowLayer(ctxt, normalizedDst);
if (shadowPainter) {
shadowPainter->setOpacity(static_cast<qreal>(shadow->m_color.alpha()) / 255);
shadowPainter->drawPixmap(normalizedDst, *image, normalizedSrc);
shadow->endShadowLayer(ctxt);
}
}
ctxt->platformContext()->drawPixmap(normalizedDst, *image, normalizedSrc);
ctxt->setCompositeOperation(previousOperator);
if (imageObserver())
imageObserver()->didDraw(this);
}
// Drawing Routines
void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dst, const FloatRect& src, ColorSpace styleColorSpace, CompositeOperator op)
{
if (!m_source.initialized())
return;
// Spin the animation to the correct frame before we try to draw it, so we
// don't draw an old frame and then immediately need to draw a newer one,
// causing flicker and wasting CPU.
startAnimation();
BBitmap* image = nativeImageForCurrentFrame();
if (!image || !image->IsValid()) // If the image hasn't fully loaded.
return;
if (mayFillWithSolidColor()) {
fillWithSolidColor(ctxt, dst, solidColor(), styleColorSpace, op);
return;
}
ctxt->save();
ctxt->setCompositeOperation(op);
BRect srcRect(src);
BRect dstRect(dst);
// Test using example site at
// http://www.meyerweb.com/eric/css/edge/complexspiral/demo.html
ctxt->platformContext()->SetDrawingMode(B_OP_ALPHA);
uint32 options = 0;
if (ctxt->imageInterpolationQuality() == InterpolationDefault
|| ctxt->imageInterpolationQuality() > InterpolationLow) {
options |= B_FILTER_BITMAP_BILINEAR;
}
ctxt->platformContext()->DrawBitmapAsync(image, srcRect, dstRect, options);
ctxt->restore();
if (imageObserver())
imageObserver()->didDraw(this);
}
void Image::drawPattern(GraphicsContext* context, const FloatRect& tileRect, const AffineTransform& patternTransform,
const FloatPoint& phase, ColorSpace colorSpace, CompositeOperator op, const FloatRect& destRect)
{
cairo_surface_t* image = nativeImageForCurrentFrame();
if (!image) // If it's too early we won't have an image yet.
return;
cairo_t* cr = context->platformContext()->cr();
drawPatternToCairoContext(cr, image, size(), tileRect, patternTransform, phase, toCairoOperator(op), destRect);
if (imageObserver())
imageObserver()->didDraw(this);
//+EAWebKitChange
//5/30/2012
#if ENABLE(IMAGE_COMPRESSION)
// Check if this is a compressed surface.
const void* pCompressedSurfaceUserData = cairo_surface_get_user_data (image, (cairo_user_data_key_t*) ImageCompressionGetUserDataKey());
if (pCompressedSurfaceUserData)
cairo_surface_destroy(image);
#endif
//-EAWebKitChange
}
void Image::drawPattern(GraphicsContext *gc, const FloatRect& srcRect, const AffineTransform& patternTransform,
const FloatPoint& phase, ColorSpace, CompositeOperator, const FloatRect& destRect, BlendMode)
{
JNIEnv* env = WebCore_GetJavaEnv();
if (!gc || gc->paintingDisabled() || srcRect.isEmpty()) {
return;
}
NativeImagePtr currFrame = nativeImageForCurrentFrame();
if (!currFrame) {
return;
}
TransformationMatrix tm = patternTransform.toTransformationMatrix();
static jmethodID mid = env->GetMethodID(PG_GetGraphicsManagerClass(env),
"createTransform",
"(DDDDDD)Lcom/sun/webkit/graphics/WCTransform;");
ASSERT(mid);
JLObject transform(env->CallObjectMethod(PL_GetGraphicsManager(env), mid,
tm.a(), tm.b(), tm.c(), tm.d(), tm.e(), tm.f()));
ASSERT(transform);
CheckAndClearException(env);
gc->platformContext()->rq().freeSpace(13 * 4)
<< (jint)com_sun_webkit_graphics_GraphicsDecoder_DRAWPATTERN
<< currFrame
<< srcRect.x() << srcRect.y() << srcRect.width() << srcRect.height()
<< RQRef::create(transform)
<< phase.x() << phase.y()
<< destRect.x() << destRect.y() << destRect.width() << destRect.height();
if (imageObserver())
imageObserver()->didDraw(this);
}
void BitmapImage::draw(GraphicsContext* context, const FloatRect& dst, const FloatRect& src, ColorSpace styleColorSpace, CompositeOperator op)
{
if (dst.isEmpty() || src.isEmpty())
return;
NativeImagePtr image = nativeImageForCurrentFrame();
if (!image)
return;
startAnimation();
if (mayFillWithSolidColor()) {
fillWithSolidColor(context, dst, solidColor(), styleColorSpace, op);
return;
}
context->save();
// Set the compositing operation.
if (op == CompositeSourceOver && !frameHasAlphaAtIndex(m_currentFrame))
context->setCompositeOperation(CompositeCopy);
else
context->setCompositeOperation(op);
#if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
FloatRect srcRectLocal = adjustSourceRectForDownSampling(src, image->size());
#else
FloatRect srcRectLocal(src);
#endif
context->platformContext()->activePainter()->drawImage(image, dst, srcRectLocal);
context->restore();
if (imageObserver())
imageObserver()->didDraw(this);
}
void Image::drawPattern(GraphicsContext* context, const FloatRect& src,
const AffineTransform& patternTransformation,
const FloatPoint& phase, ColorSpace styleColorSpace,
CompositeOperator op, const FloatRect& dst)
{
if (dst.isEmpty() || src.isEmpty())
return;
NativeImagePtr image = nativeImageForCurrentFrame();
if (!image)
return;
startAnimation();
if (mayFillWithSolidColor()) {
fillWithSolidColor(context, dst, solidColor(), styleColorSpace, op);
return;
}
notImplemented();
if (imageObserver())
imageObserver()->didDraw(this);
}
void Image::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRect, const AffineTransform& patternTransform,
const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
{
if (!nativeImageForCurrentFrame())
return;
ASSERT(patternTransform.isInvertible());
if (!patternTransform.isInvertible())
// Avoid a hang under CGContextDrawTiledImage on release builds.
return;
CGContextRef context = ctxt->platformContext();
ctxt->save();
CGContextClipToRect(context, destRect);
ctxt->setCompositeOperation(op);
CGContextTranslateCTM(context, destRect.x(), destRect.y() + destRect.height());
CGContextScaleCTM(context, 1, -1);
// Compute the scaled tile size.
float scaledTileHeight = tileRect.height() * narrowPrecisionToFloat(patternTransform.d());
// We have to adjust the phase to deal with the fact we're in Cartesian space now (with the bottom left corner of destRect being
// the origin).
float adjustedX = phase.x() - destRect.x() + tileRect.x() * narrowPrecisionToFloat(patternTransform.a()); // We translated the context so that destRect.x() is the origin, so subtract it out.
float adjustedY = destRect.height() - (phase.y() - destRect.y() + tileRect.y() * narrowPrecisionToFloat(patternTransform.d()) + scaledTileHeight);
CGImageRef tileImage = nativeImageForCurrentFrame();
float h = CGImageGetHeight(tileImage);
RetainPtr<CGImageRef> subImage;
if (tileRect.size() == size())
subImage = tileImage;
else {
// Copying a sub-image out of a partially-decoded image stops the decoding of the original image. It should never happen
// because sub-images are only used for border-image, which only renders when the image is fully decoded.
ASSERT(h == height());
subImage.adoptCF(CGImageCreateWithImageInRect(tileImage, tileRect));
}
// Adjust the color space.
subImage = imageWithColorSpace(subImage.get(), styleColorSpace);
#ifndef BUILDING_ON_TIGER
// Leopard has an optimized call for the tiling of image patterns, but we can only use it if the image has been decoded enough that
// its buffer is the same size as the overall image. Because a partially decoded CGImageRef with a smaller width or height than the
// overall image buffer needs to tile with "gaps", we can't use the optimized tiling call in that case.
// FIXME: Could create WebKitSystemInterface SPI for CGCreatePatternWithImage2 and probably make Tiger tile faster as well.
// FIXME: We cannot use CGContextDrawTiledImage with scaled tiles on Leopard, because it suffers from rounding errors. Snow Leopard is ok.
float scaledTileWidth = tileRect.width() * narrowPrecisionToFloat(patternTransform.a());
float w = CGImageGetWidth(tileImage);
#ifdef BUILDING_ON_LEOPARD
if (w == size().width() && h == size().height() && scaledTileWidth == tileRect.width() && scaledTileHeight == tileRect.height())
#else
if (w == size().width() && h == size().height())
#endif
CGContextDrawTiledImage(context, FloatRect(adjustedX, adjustedY, scaledTileWidth, scaledTileHeight), subImage.get());
else {
#endif
// On Leopard, this code now only runs for partially decoded images whose buffers do not yet match the overall size of the image.
// On Tiger this code runs all the time. This code is suboptimal because the pattern does not reference the image directly, and the
// pattern is destroyed before exiting the function. This means any decoding the pattern does doesn't end up cached anywhere, so we
// redecode every time we paint.
static const CGPatternCallbacks patternCallbacks = { 0, drawPatternCallback, NULL };
CGAffineTransform matrix = CGAffineTransformMake(narrowPrecisionToCGFloat(patternTransform.a()), 0, 0, narrowPrecisionToCGFloat(patternTransform.d()), adjustedX, adjustedY);
matrix = CGAffineTransformConcat(matrix, CGContextGetCTM(context));
// The top of a partially-decoded image is drawn at the bottom of the tile. Map it to the top.
matrix = CGAffineTransformTranslate(matrix, 0, size().height() - h);
RetainPtr<CGPatternRef> pattern(AdoptCF, CGPatternCreate(subImage.get(), CGRectMake(0, 0, tileRect.width(), tileRect.height()),
matrix, tileRect.width(), tileRect.height(),
kCGPatternTilingConstantSpacing, true, &patternCallbacks));
if (!pattern) {
ctxt->restore();
return;
}
RetainPtr<CGColorSpaceRef> patternSpace(AdoptCF, CGColorSpaceCreatePattern(0));
CGFloat alpha = 1;
RetainPtr<CGColorRef> color(AdoptCF, CGColorCreateWithPattern(patternSpace.get(), pattern.get(), &alpha));
CGContextSetFillColorSpace(context, patternSpace.get());
// FIXME: Really want a public API for this. It is just CGContextSetBaseCTM(context, CGAffineTransformIdentiy).
wkSetPatternBaseCTM(context, CGAffineTransformIdentity);
CGContextSetPatternPhase(context, CGSizeZero);
CGContextSetFillColorWithColor(context, color.get());
CGContextFillRect(context, CGContextGetClipBoundingBox(context));
#ifndef BUILDING_ON_TIGER
}
#endif
ctxt->restore();
if (imageObserver())
imageObserver()->didDraw(this);
}
void Image::drawPattern(GraphicsContext* context,
const FloatRect& floatSrcRect,
const AffineTransform& patternTransform,
const FloatPoint& phase,
ColorSpace styleColorSpace,
CompositeOperator compositeOp,
const FloatRect& destRect)
{
#if PLATFORM(CHROMIUM)
TRACE_EVENT0("skia", "Image::drawPattern");
#endif
FloatRect normSrcRect = normalizeRect(floatSrcRect);
if (destRect.isEmpty() || normSrcRect.isEmpty())
return; // nothing to draw
NativeImageSkia* bitmap = nativeImageForCurrentFrame();
if (!bitmap)
return;
SkMatrix ctm = context->platformContext()->canvas()->getTotalMatrix();
SkMatrix totalMatrix;
totalMatrix.setConcat(ctm, patternTransform);
// Figure out what size the bitmap will be in the destination. The
// destination rect is the bounds of the pattern, we need to use the
// matrix to see how big it will be.
SkRect destRectTarget;
totalMatrix.mapRect(&destRectTarget, normSrcRect);
float destBitmapWidth = SkScalarToFloat(destRectTarget.width());
float destBitmapHeight = SkScalarToFloat(destRectTarget.height());
// Compute the resampling mode.
ResamplingMode resampling;
if (context->platformContext()->isAccelerated() || context->platformContext()->printing())
resampling = RESAMPLE_LINEAR;
else
resampling = computeResamplingMode(totalMatrix, *bitmap, normSrcRect.width(), normSrcRect.height(), destBitmapWidth, destBitmapHeight);
resampling = limitResamplingMode(context->platformContext(), resampling);
// Load the transform WebKit requested.
SkMatrix matrix(patternTransform);
SkShader* shader;
if (resampling == RESAMPLE_AWESOME) {
// Do nice resampling.
float scaleX = destBitmapWidth / normSrcRect.width();
float scaleY = destBitmapHeight / normSrcRect.height();
SkRect scaledSrcRect;
SkIRect enclosingScaledSrcRect;
// The image fragment generated here is not exactly what is
// requested. The scale factor used is approximated and image
// fragment is slightly larger to align to integer
// boundaries.
SkBitmap resampled = extractScaledImageFragment(*bitmap, normSrcRect, scaleX, scaleY, &scaledSrcRect, &enclosingScaledSrcRect);
shader = SkShader::CreateBitmapShader(resampled, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
// Since we just resized the bitmap, we need to remove the scale
// applied to the pixels in the bitmap shader. This means we need
// CTM * patternTransform to have identity scale. Since we
// can't modify CTM (or the rectangle will be drawn in the wrong
// place), we must set patternTransform's scale to the inverse of
// CTM scale.
matrix.setScaleX(ctm.getScaleX() ? 1 / ctm.getScaleX() : 1);
matrix.setScaleY(ctm.getScaleY() ? 1 / ctm.getScaleY() : 1);
} else {
// No need to do nice resampling.
SkBitmap srcSubset;
bitmap->bitmap().extractSubset(&srcSubset, enclosingIntRect(normSrcRect));
shader = SkShader::CreateBitmapShader(srcSubset, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
}
// We also need to translate it such that the origin of the pattern is the
// origin of the destination rect, which is what WebKit expects. Skia uses
// the coordinate system origin as the base for the patter. If WebKit wants
// a shifted image, it will shift it from there using the patternTransform.
float adjustedX = phase.x() + normSrcRect.x() *
narrowPrecisionToFloat(patternTransform.a());
float adjustedY = phase.y() + normSrcRect.y() *
narrowPrecisionToFloat(patternTransform.d());
matrix.postTranslate(SkFloatToScalar(adjustedX),
SkFloatToScalar(adjustedY));
shader->setLocalMatrix(matrix);
SkPaint paint;
paint.setShader(shader)->unref();
paint.setXfermodeMode(WebCoreCompositeToSkiaComposite(compositeOp));
paint.setFilterBitmap(resampling == RESAMPLE_LINEAR);
context->platformContext()->paintSkPaint(destRect, paint);
}
void BitmapImage::readyWRATHWidgets(PaintedWidgetsOfWRATHHandleT<Image>& handle, ContextOfWRATH *ctx,
const FloatRect& dst, const FloatRect& src,
ColorSpace styleColorSpace, CompositeOperator op)
{
BitmapImage_readyWRATHWidgets *d(BitmapImage_readyWRATHWidgets::object(this, handle));
ContextOfWRATH::AutoPushNode autoPushRoot(ctx, d->m_root_node);
d->m_solid_color.visible(false);
if (d->m_image_rect_item.widget())
d->m_image_rect_item.widget()->visible(false);
FloatRect normalizedDst = dst.normalized();
FloatRect normalizedSrc = src.normalized();
startAnimation();
if (normalizedSrc.isEmpty() || normalizedDst.isEmpty())
return;
NativeImagePtr nativeImage = nativeImageForCurrentFrame();
if (!nativeImage)
return;
// "Hardcode" the requirement for the underlying wrath image type to WRATHImage.
// The reason is support for setting texture coordinates, which isn't possible for WRATHCompoundImage
WRATHImage* image = nativeImage->getWrathImage();
if (!image)
return;
if (mayFillWithSolidColor()) {
d->m_solid_color.visible(true);
readyWRATHWidgetSolidColor(d->m_solid_color, ctx, this, normalizedDst, solidColor(), styleColorSpace, op);
return;
}
// ImageRectOfWRATH methods handle changing the op with respect to composite operator
/*
CompositeOperator previousOperator = ctxt->compositeOperation();
ctxt->setCompositeOperation(!image->hasAlpha() && op == CompositeSourceOver ? CompositeCopy : op);
*/
if(!nativeImage->hasAlpha() && op == CompositeSourceOver)
{
op=CompositeCopy;
}
/*
[WRATH-DANGER]: No shadows
ContextShadow* shadow = ctxt->contextShadow();
if (shadow->m_type != ContextShadow::NoShadow) {
QPainter* shadowPainter = shadow->beginShadowLayer(ctxt, normalizedDst);
if (shadowPainter) {
shadowPainter->setOpacity(static_cast<qreal>(shadow->m_color.alpha()) / 255);
shadowPainter->drawPixmap(normalizedDst, *image, normalizedSrc);
shadow->endShadowLayer(ctxt);
}
}
*/
/*
[WRATH-DANGER]: Possible rounding errors from converting to IntRect
*/
d->m_image_rect_item.update(ctx, nativeImage,
normalizedDst, IntRect(normalizedSrc),
op);
if (d->m_image_rect_item.widget())
d->m_image_rect_item.widget()->visible(true);
/*
ctxt->platformContext()->drawPixmap(normalizedDst, *image, normalizedSrc);
*/
/*
ctxt->setCompositeOperation(previousOperator);
*/
if (imageObserver())
imageObserver()->didDraw(this);
}
void Image::drawPattern(GraphicsContext* context,
const FloatRect& floatSrcRect,
const AffineTransform& patternTransform,
const FloatPoint& phase,
ColorSpace styleColorSpace,
CompositeOperator compositeOp,
const FloatRect& destRect)
{
FloatRect normSrcRect = normalizeRect(floatSrcRect);
if (destRect.isEmpty() || normSrcRect.isEmpty())
return; // nothing to draw
NativeImageSkia* bitmap = nativeImageForCurrentFrame();
if (!bitmap)
return;
SkIRect srcRect = enclosingIntRect(normSrcRect);
// Figure out what size the bitmap will be in the destination. The
// destination rect is the bounds of the pattern, we need to use the
// matrix to see how big it will be.
float destBitmapWidth, destBitmapHeight;
TransformDimensions(patternTransform, srcRect.width(), srcRect.height(),
&destBitmapWidth, &destBitmapHeight);
// Compute the resampling mode.
ResamplingMode resampling;
if (context->platformContext()->isAccelerated() || context->platformContext()->printing())
resampling = RESAMPLE_LINEAR;
else
resampling = computeResamplingMode(context->platformContext(), *bitmap, srcRect.width(), srcRect.height(), destBitmapWidth, destBitmapHeight);
// Load the transform WebKit requested.
SkMatrix matrix(patternTransform);
SkShader* shader;
if (resampling == RESAMPLE_AWESOME) {
// Do nice resampling.
int width = static_cast<int>(destBitmapWidth);
int height = static_cast<int>(destBitmapHeight);
SkBitmap resampled = bitmap->resizedBitmap(srcRect, width, height);
shader = SkShader::CreateBitmapShader(resampled, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
// Since we just resized the bitmap, we need to undo the scale set in
// the image transform.
matrix.setScaleX(SkIntToScalar(1));
matrix.setScaleY(SkIntToScalar(1));
} else {
// No need to do nice resampling.
SkBitmap srcSubset;
bitmap->bitmap().extractSubset(&srcSubset, srcRect);
shader = SkShader::CreateBitmapShader(srcSubset, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
}
// We also need to translate it such that the origin of the pattern is the
// origin of the destination rect, which is what WebKit expects. Skia uses
// the coordinate system origin as the base for the patter. If WebKit wants
// a shifted image, it will shift it from there using the patternTransform.
float adjustedX = phase.x() + normSrcRect.x() *
narrowPrecisionToFloat(patternTransform.a());
float adjustedY = phase.y() + normSrcRect.y() *
narrowPrecisionToFloat(patternTransform.d());
matrix.postTranslate(SkFloatToScalar(adjustedX),
SkFloatToScalar(adjustedY));
shader->setLocalMatrix(matrix);
SkPaint paint;
paint.setShader(shader)->unref();
paint.setXfermodeMode(WebCoreCompositeToSkiaComposite(compositeOp));
paint.setFilterBitmap(resampling == RESAMPLE_LINEAR);
context->platformContext()->paintSkPaint(destRect, paint);
}
GdkPixbuf* BitmapImage::getGdkPixbuf()
{
RefPtr<cairo_surface_t> surface = nativeImageForCurrentFrame();
return surface ? cairoSurfaceToGdkPixbuf(surface.get()) : 0;
}
