LayoutUnit RenderImage::computeReplacedLogicalWidth(bool includeMaxWidth) const
{
// If we've got an explicit width/height assigned, propagate it to the image resource.
if (style()->logicalWidth().isFixed() && style()->logicalHeight().isFixed()) {
LayoutUnit width = RenderReplaced::computeReplacedLogicalWidth(includeMaxWidth);
m_imageResource->setContainerSizeForRenderer(IntSize(width, computeReplacedLogicalHeight()));
return width;
}
IntSize containerSize;
if (m_imageResource->imageHasRelativeWidth() || m_imageResource->imageHasRelativeHeight()) {
// Propagate the containing block size to the image resource, otherwhise we can't compute our own intrinsic size, if it's relative.
RenderObject* containingBlock = isPositioned() ? container() : this->containingBlock();
if (containingBlock->isBox()) {
RenderBox* box = toRenderBox(containingBlock);
containerSize = IntSize(box->availableWidth(), box->availableHeight()); // Already contains zooming information.
}
} else {
// Propagate the current zoomed image size to the image resource, otherwhise the image size will remain the same on-screen.
CachedImage* cachedImage = m_imageResource->cachedImage();
if (cachedImage && cachedImage->image()) {
containerSize = cachedImage->image()->size();
// FIXME: Remove unnecessary rounding when layout is off ints: webkit.org/b/63656
containerSize.setWidth(static_cast<LayoutUnit>(containerSize.width() * style()->effectiveZoom()));
containerSize.setHeight(static_cast<LayoutUnit>(containerSize.height() * style()->effectiveZoom()));
}
}
if (!containerSize.isEmpty()) {
m_imageResource->setContainerSizeForRenderer(containerSize);
const_cast<RenderImage*>(this)->updateIntrinsicSizeIfNeeded(containerSize, false);
}
return RenderReplaced::computeReplacedLogicalWidth(includeMaxWidth);
}
// FIXME: Why isn't this just another overload of drawImage? Why have a different name?
void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement* image,
float sx, float sy, float sw, float sh,
float dx, float dy, float dw, float dh,
const String& compositeOperation)
{
if (!image)
return;
CachedImage* cachedImage = image->cachedImage();
if (!cachedImage)
return;
GraphicsContext* c = drawingContext();
if (!c)
return;
CompositeOperator op;
if (!parseCompositeOperator(compositeOperation, op))
op = CompositeSourceOver;
FloatRect destRect = FloatRect(dx, dy, dw, dh);
willDraw(destRect);
#ifdef __OWB__
c->drawImage(cachedImage->image()->nativeImageForCurrentFrame(), destRect, FloatRect(sx, sy, sw, sh), op);
cachedImage->image()->startAnimation();
#else
c->drawImage(cachedImage->image(), destRect, FloatRect(sx, sy, sw, sh), op);
#endif //__OWB__
}
static void writeImageToDataObject(
DataObjectJava* dataObject,
Element* element,
const KURL& url)
{
// Shove image data into a DataObject for use as a file
CachedImage* cachedImage = getCachedImage(element);
if (!cachedImage || !cachedImage->image() || !cachedImage->isLoaded())
return;
SharedBuffer* imageBuffer = cachedImage->image()->data();
if (!imageBuffer || !imageBuffer->size())
return;
dataObject->fileContent = imageBuffer;
// Determine the filename for the file contents of the image. We try to
// use the alt tag if one exists, otherwise we fall back on the suggested
// filename in the http header, and finally we resort to using the filename
// in the URL.
//String title = element->getAttribute(altAttr);
//if (title.isEmpty())
// title = cachedImage->response().suggestedFilename();
//TODO: do we need it?
dataObject->fileContentFilename = cachedImage->response().suggestedFilename();
}
// FIXME: Why isn't this just another overload of drawImage? Why have a different name?
void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement* image,
float sx, float sy, float sw, float sh,
float dx, float dy, float dw, float dh,
const String& compositeOperation)
{
if (!image)
return;
CachedImage* cachedImage = image->cachedImage();
if (!cachedImage)
return;
if (canvas()->originClean())
checkOrigin(cachedImage->response().url());
if (canvas()->originClean() && !cachedImage->image()->hasSingleSecurityOrigin())
canvas()->setOriginTainted();
GraphicsContext* c = drawingContext();
if (!c)
return;
if (!state().m_invertibleCTM)
return;
CompositeOperator op;
if (!parseCompositeOperator(compositeOperation, op))
op = CompositeSourceOver;
FloatRect destRect = FloatRect(dx, dy, dw, dh);
willDraw(destRect);
c->drawImage(cachedImage->image(), DeviceColorSpace, destRect, FloatRect(sx, sy, sw, sh), op);
}
void ClipboardQt::declareAndWriteDragImage(Element* element, const KURL& url, const String& title, Frame* frame)
{
ASSERT(frame);
// WebCore::writeURL(m_writableDataObject.get(), url, title, true, false);
if (!m_writableData)
m_writableData = new QMimeData;
CachedImage* cachedImage = getCachedImage(element);
if (!cachedImage || !cachedImage->image() || !cachedImage->isLoaded())
return;
QPixmap* pixmap = cachedImage->image()->nativeImageForCurrentFrame();
if (pixmap)
m_writableData->setImageData(*pixmap);
AtomicString imageURL = element->getAttribute(HTMLNames::srcAttr);
if (imageURL.isEmpty())
return;
KURL fullURL = frame->document()->completeURL(deprecatedParseURL(imageURL));
if (fullURL.isEmpty())
return;
QList<QUrl> urls;
urls.append(url);
urls.append(fullURL);
m_writableData->setText(title);
m_writableData->setUrls(urls);
#ifndef QT_NO_CLIPBOARD
if (!isForDragging())
QApplication::clipboard()->setMimeData(m_writableData);
#endif
}
static void writeImageToDataObject(IDataObject* dataObject, Element* element, const KURL& url)
{
// Shove image data into a DataObject for use as a file
CachedImage* cachedImage = getCachedImage(element);
if (!cachedImage || !cachedImage->image() || !cachedImage->isLoaded())
return;
SharedBuffer* imageBuffer = cachedImage->image()->data();
if (!imageBuffer || !imageBuffer->size())
return;
HGLOBAL imageFileDescriptor = createGlobalImageFileDescriptor(url.string(), element->getAttribute(altAttr), cachedImage);
if (!imageFileDescriptor)
return;
HGLOBAL imageFileContent = createGlobalImageFileContent(imageBuffer);
if (!imageFileContent) {
GlobalFree(imageFileDescriptor);
return;
}
String fileName = cachedImage->response().suggestedFilename();
HGLOBAL hDropContent = createGlobalHDropContent(url, fileName, imageBuffer);
if (!hDropContent) {
GlobalFree(hDropContent);
return;
}
writeFileToDataObject(dataObject, imageFileDescriptor, imageFileContent, hDropContent);
}
static void writeImageToDataObject(DataObject* dataObject, Element* element,
const KURL& url)
{
// Shove image data into a DataObject for use as a file
CachedImage* cachedImage = getCachedImage(element);
if (!cachedImage || !cachedImage->image() || !cachedImage->isLoaded())
return;
SharedBuffer* imageBuffer = cachedImage->image()->data();
if (!imageBuffer || !imageBuffer->size())
return;
dataObject->fileContent = imageBuffer;
// Determine the filename for the file contents of the image. We try to
// use the alt tag if one exists, otherwise we fall back on the suggested
// filename in the http header, and finally we resort to using the filename
// in the URL.
/*String extension = MIMETypeRegistry::getPreferredExtensionForMIMEType(
cachedImage->response().mimeType());*/
String extension = "png";
dataObject->fileExtension = extension.isEmpty() ? "" : "." + extension;
String title = element->getAttribute(altAttr);
if (title.isEmpty())
title = cachedImage->response().suggestedFilename();
//title = ClipboardBal::validateFileName(title, dataObject);
dataObject->fileContentFilename = title + dataObject->fileExtension;
}
void CanvasRenderingContext2D::drawImage(HTMLImageElement* image, const FloatRect& srcRect, const FloatRect& dstRect,
ExceptionCode& ec)
{
ASSERT(image);
ec = 0;
FloatRect imageRect = FloatRect(FloatPoint(), size(image));
if (!(imageRect.contains(srcRect) && srcRect.width() >= 0 && srcRect.height() >= 0
&& dstRect.width() >= 0 && dstRect.height() >= 0)) {
ec = INDEX_SIZE_ERR;
return;
}
if (srcRect.isEmpty() || dstRect.isEmpty())
return;
GraphicsContext* c = drawingContext();
if (!c)
return;
CachedImage* cachedImage = image->cachedImage();
if (!cachedImage)
return;
FloatRect sourceRect = c->roundToDevicePixels(srcRect);
FloatRect destRect = c->roundToDevicePixels(dstRect);
willDraw(destRect);
#ifdef __OWB__
c->drawImage(cachedImage->image()->nativeImageForCurrentFrame(), destRect, sourceRect, state().m_globalComposite);
cachedImage->image()->startAnimation();
#else
c->drawImage(cachedImage->image(), destRect, sourceRect, state().m_globalComposite);
#endif //__OWB__
}
static void writeImageToDataObject(ChromiumDataObject* dataObject, Element* element,
const KURL& url)
{
// Shove image data into a DataObject for use as a file
CachedImage* cachedImage = getCachedImage(element);
if (!cachedImage || !cachedImage->image() || !cachedImage->isLoaded())
return;
SharedBuffer* imageBuffer = cachedImage->image()->data();
if (!imageBuffer || !imageBuffer->size())
return;
dataObject->fileContent = imageBuffer;
// Determine the filename for the file contents of the image. We try to
// use the alt tag if one exists, otherwise we fall back on the suggested
// filename in the http header, and finally we resort to using the filename
// in the URL.
String extension(".");
extension += MIMETypeRegistry::getPreferredExtensionForMIMEType(
cachedImage->response().mimeType());
String title = element->getAttribute(altAttr);
if (title.isEmpty()) {
title = cachedImage->response().suggestedFilename();
// FIXME: If title is empty, get the filename from the URL.
}
dataObject->fileContentFilename = title + extension;
}
RenderBox* RenderImage::embeddedContentBox() const
{
CachedImage* cachedImage = imageResource().cachedImage();
if (cachedImage && is<SVGImage>(cachedImage->image()))
return downcast<SVGImage>(*cachedImage->image()).embeddedContentBox();
return nullptr;
}
void RenderImage::computeIntrinsicRatioInformation(FloatSize& intrinsicSize, double& intrinsicRatio, bool& isPercentageIntrinsicSize) const
{
// Assure this method is never used for SVGImages.
ASSERT(!embeddedContentBox());
isPercentageIntrinsicSize = false;
CachedImage* cachedImage = m_imageResource ? m_imageResource->cachedImage() : 0;
if (!cachedImage || !cachedImage->image())
return;
intrinsicSize = cachedImage->image()->size();
intrinsicRatio = intrinsicSize.width() / static_cast<double>(intrinsicSize.height());
}
RenderBox* RenderImage::embeddedContentBox() const
{
if (!m_imageResource)
return 0;
#if ENABLE(SVG)
CachedImage* cachedImage = m_imageResource->cachedImage();
if (cachedImage && cachedImage->image() && cachedImage->image()->isSVGImage())
return static_cast<SVGImage*>(cachedImage->image())->embeddedContentBox();
#endif
return 0;
}
void Pasteboard::writeImage(Node* node, const KURL&, const String& title)
{
ASSERT(node);
ASSERT(node->renderer());
ASSERT(node->renderer()->isImage());
RenderImage* renderer = toRenderImage(node->renderer());
CachedImage* cachedImage = renderer->cachedImage();
ASSERT(cachedImage);
Image* image = cachedImage->image();
ASSERT(image);
// If the image is wrapped in a link, |url| points to the target of the
// link. This isn't useful to us, so get the actual image URL.
AtomicString urlString;
if (node->hasTagName(HTMLNames::imgTag) || node->hasTagName(HTMLNames::inputTag))
urlString = static_cast<Element*>(node)->getAttribute(HTMLNames::srcAttr);
#if ENABLE(SVG)
else if (node->hasTagName(SVGNames::imageTag))
urlString = static_cast<Element*>(node)->getAttribute(XLinkNames::hrefAttr);
#endif
else if (node->hasTagName(HTMLNames::embedTag) || node->hasTagName(HTMLNames::objectTag)) {
Element* element = static_cast<Element*>(node);
urlString = element->getAttribute(element->imageSourceAttributeName());
}
KURL url = urlString.isEmpty() ? KURL() : node->document()->completeURL(deprecatedParseURL(urlString));
NativeImageSkia* bitmap = 0;
#if !PLATFORM(CG)
bitmap = image->nativeImageForCurrentFrame();
#endif
ChromiumBridge::clipboardWriteImage(bitmap, url, title);
}
void Pasteboard::writeImage(Node* node, const KURL&, const String& title)
{
ASSERT(node);
ASSERT(node->renderer());
ASSERT(node->renderer()->isImage());
RenderImage* renderer = toRenderImage(node->renderer());
CachedImage* cachedImage = renderer->cachedImage();
if (!cachedImage || cachedImage->errorOccurred())
return;
Image* image = cachedImage->image();
ASSERT(image);
NativeImagePtr bitmap = image->nativeImageForCurrentFrame();
if (!bitmap)
return;
// If the image is wrapped in a link, |url| points to the target of the
// link. This isn't useful to us, so get the actual image URL.
AtomicString urlString;
if (node->hasTagName(HTMLNames::imgTag) || node->hasTagName(HTMLNames::inputTag))
urlString = static_cast<Element*>(node)->getAttribute(HTMLNames::srcAttr);
#if ENABLE(SVG)
else if (node->hasTagName(SVGNames::imageTag))
urlString = static_cast<Element*>(node)->getAttribute(XLinkNames::hrefAttr);
#endif
else if (node->hasTagName(HTMLNames::embedTag) || node->hasTagName(HTMLNames::objectTag)) {
Element* element = static_cast<Element*>(node);
urlString = element->getAttribute(element->imageSourceAttributeName());
}
KURL url = urlString.isEmpty() ? KURL() : node->document()->completeURL(stripLeadingAndTrailingHTMLSpaces(urlString));
PlatformBridge::clipboardWriteImage(bitmap, url, title);
}
void Pasteboard::writeImage(Node* node, const KURL&, const String&)
{
ASSERT(node && node->renderer() && node->renderer()->isImage());
RenderImage* renderer = static_cast<RenderImage*>(node->renderer());
CachedImage* cachedImage = static_cast<CachedImage*>(renderer->cachedImage());
ASSERT(cachedImage);
Image* image = cachedImage->image();
ASSERT(image);
clear();
RefPtr<SharedBitmap> sourceBmp = image->nativeImageForCurrentFrame();
if (!sourceBmp)
return;
IntRect rect(0, 0, sourceBmp->width(), sourceBmp->height());
BitmapInfo bmpInfo;
void* pixels;
HBITMAP resultBitmap = sourceBmp->clipBitmap(rect, true, bmpInfo, pixels);
if (!resultBitmap)
return;
if (::OpenClipboard(m_owner)) {
::SetClipboardData(CF_BITMAP, resultBitmap);
::CloseClipboard();
} else
DeleteObject(resultBitmap);
}
void CanvasRenderingContext2D::drawImage(HTMLImageElement* image, const FloatRect& srcRect, const FloatRect& dstRect,
ExceptionCode& ec)
{
ASSERT(image);
ec = 0;
FloatRect imageRect = FloatRect(FloatPoint(), size(image));
if (!(imageRect.contains(srcRect) && srcRect.width() >= 0 && srcRect.height() >= 0
&& dstRect.width() >= 0 && dstRect.height() >= 0)) {
ec = INDEX_SIZE_ERR;
return;
}
if (srcRect.isEmpty() || dstRect.isEmpty())
return;
GraphicsContext* c = drawingContext();
if (!c)
return;
CachedImage* cachedImage = image->cachedImage();
if (!cachedImage)
return;
if (m_canvas->originClean())
checkOrigin(KURL(cachedImage->url()));
FloatRect sourceRect = c->roundToDevicePixels(srcRect);
FloatRect destRect = c->roundToDevicePixels(dstRect);
willDraw(destRect);
c->drawImage(cachedImage->image(), destRect, sourceRect, state().m_globalComposite);
}
FixedBackgroundImageLayerAndroid::FixedBackgroundImageLayerAndroid(PassRefPtr<RenderStyle> aStyle,
int w, int h)
: LayerAndroid((RenderLayer*)0)
, m_width(w)
, m_height(h)
{
RefPtr<RenderStyle> style = aStyle;
FillLayer* layers = style->accessBackgroundLayers();
StyleImage* styleImage = layers->image();
CachedImage* cachedImage = static_cast<StyleCachedImage*>(styleImage)->cachedImage();
WebCore::Image* image = cachedImage->image();
setContentsImage(image->nativeImageForCurrentFrame());
setSize(image->width(), image->height());
setIntrinsicallyComposited(true);
SkLength left, top;
left = SkLength::convertLength(style->backgroundXPosition());
top = SkLength::convertLength(style->backgroundYPosition());
BackgroundImagePositioning* position = new BackgroundImagePositioning(this);
position->setRepeatX(style->backgroundRepeatX() != WebCore::NoRepeatFill);
position->setRepeatY(style->backgroundRepeatY() != WebCore::NoRepeatFill);
setFixedPosition(position);
position->setPosition(left, top);
#ifdef DEBUG_COUNT
ClassTracker::instance()->increment("FixedBackgroundImageLayerAndroid");
#endif
}
// FIXME: Why isn't this just another overload of drawImage? Why have a different name?
void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement* image,
float sx, float sy, float sw, float sh,
float dx, float dy, float dw, float dh,
const String& compositeOperation)
{
if (!image)
return;
CachedImage* cachedImage = image->cachedImage();
if (!cachedImage)
return;
if (m_canvas->originClean())
checkOrigin(KURL(cachedImage->url()));
GraphicsContext* c = drawingContext();
if (!c)
return;
CompositeOperator op;
if (!parseCompositeOperator(compositeOperation, op))
op = CompositeSourceOver;
FloatRect destRect = FloatRect(dx, dy, dw, dh);
willDraw(destRect);
c->drawImage(cachedImage->image(), destRect, FloatRect(sx, sy, sw, sh), op);
}
static Image* getImage(Element* element)
{
ASSERT(element);
CachedImage* cachedImage = getCachedImage(element);
// Don't use cachedImage->imageForRenderer() here as that may return BitmapImages for cached SVG Images.
// Users of getImage() want access to the SVGImage, in order to figure out the filename extensions,
// which would be empty when asking the cached BitmapImages.
return (cachedImage && !cachedImage->errorOccurred()) ?
cachedImage->image() : 0;
}
void CanvasRenderingContext::checkOrigin(const HTMLImageElement* image)
{
if (!image || !canvas()->originClean())
return;
CachedImage* cachedImage = image->cachedImage();
checkOrigin(cachedImage->response().url());
if (canvas()->originClean() && !cachedImage->image()->hasSingleSecurityOrigin())
canvas()->setOriginTainted();
}
bool CanvasRenderingContext::wouldTaintOrigin(const HTMLImageElement* image)
{
if (!image || !canvas()->originClean())
return false;
CachedImage* cachedImage = image->cachedImage();
if (!cachedImage->image()->hasSingleSecurityOrigin())
return true;
return wouldTaintOrigin(cachedImage->response().url()) && !cachedImage->passesAccessControlCheck(canvas()->securityOrigin());
}
void CanvasRenderingContext2D::drawImage(HTMLImageElement* image, const FloatRect& srcRect, const FloatRect& dstRect,
ExceptionCode& ec)
{
ASSERT(image);
ec = 0;
FloatRect imageRect = FloatRect(FloatPoint(), size(image));
if (!imageRect.contains(normalizeRect(srcRect)) || srcRect.width() == 0 || srcRect.height() == 0) {
ec = INDEX_SIZE_ERR;
return;
}
if (!dstRect.width() || !dstRect.height())
return;
GraphicsContext* c = drawingContext();
if (!c)
return;
if (!state().m_invertibleCTM)
return;
CachedImage* cachedImage = image->cachedImage();
if (!cachedImage)
return;
if (canvas()->originClean())
checkOrigin(cachedImage->response().url());
if (canvas()->originClean() && !cachedImage->image()->hasSingleSecurityOrigin())
canvas()->setOriginTainted();
FloatRect sourceRect = c->roundToDevicePixels(srcRect);
FloatRect destRect = c->roundToDevicePixels(dstRect);
willDraw(destRect);
c->drawImage(cachedImage->image(), DeviceColorSpace, destRect, sourceRect, state().m_globalComposite);
}
QVariant QtPixmapInstance::variantFromObject(JSObject* object, QMetaType::Type hint)
{
if (!object)
goto returnEmptyVariant;
if (object->inherits(&JSHTMLImageElement::s_info)) {
JSHTMLImageElement* elementJSWrapper = static_cast<JSHTMLImageElement*>(object);
HTMLImageElement* imageElement = static_cast<HTMLImageElement*>(elementJSWrapper->impl());
if (!imageElement)
goto returnEmptyVariant;
CachedImage* cachedImage = imageElement->cachedImage();
if (!cachedImage)
goto returnEmptyVariant;
Image* image = cachedImage->image();
if (!image)
goto returnEmptyVariant;
QPixmap* pixmap = image->nativeImageForCurrentFrame();
if (!pixmap)
goto returnEmptyVariant;
return (hint == static_cast<QMetaType::Type>(qMetaTypeId<QPixmap>()))
? QVariant::fromValue<QPixmap>(*pixmap)
: QVariant::fromValue<QImage>(pixmap->toImage());
}
if (object->inherits(&QtPixmapRuntimeObject::s_info)) {
QtPixmapRuntimeObject* runtimeObject = static_cast<QtPixmapRuntimeObject*>(object);
QtPixmapInstance* instance = static_cast<QtPixmapInstance*>(runtimeObject->getInternalInstance());
if (!instance)
goto returnEmptyVariant;
if (hint == qMetaTypeId<QPixmap>())
return QVariant::fromValue<QPixmap>(instance->toPixmap());
if (hint == qMetaTypeId<QImage>())
return QVariant::fromValue<QImage>(instance->toImage());
}
returnEmptyVariant:
if (hint == qMetaTypeId<QPixmap>())
return QVariant::fromValue<QPixmap>(QPixmap());
if (hint == qMetaTypeId<QImage>())
return QVariant::fromValue<QImage>(QImage());
return QVariant();
}
void ClipboardGtk::declareAndWriteDragImage(Element* element, const KURL& url, const String& label, Frame* frame)
{
m_dataObject->setURL(url, label);
m_dataObject->setMarkup(createMarkup(element, IncludeNode, 0, AbsoluteURLs));
CachedImage* image = getCachedImage(element);
if (!image || !image->isLoaded())
return;
GRefPtr<GdkPixbuf> pixbuf = adoptGRef(image->image()->getGdkPixbuf());
if (!pixbuf)
return;
m_dataObject->setImage(pixbuf.get());
}
void Pasteboard::writeImage(Node* node, const KURL&, const String&)
{
GtkClipboard* clipboard = gtk_clipboard_get_for_display(gdk_display_get_default(), GDK_SELECTION_CLIPBOARD);
ASSERT(node && node->renderer() && node->renderer()->isImage());
RenderImage* renderer = static_cast<RenderImage*>(node->renderer());
CachedImage* cachedImage = static_cast<CachedImage*>(renderer->cachedImage());
ASSERT(cachedImage);
Image* image = cachedImage->image();
ASSERT(image);
GdkPixbuf* pixbuf = image->getGdkPixbuf();
gtk_clipboard_set_image(clipboard, pixbuf);
g_object_unref(pixbuf);
}
void Pasteboard::writeImage(Node* node, const KURL&, const String&)
{
ASSERT(node && node->renderer() && node->renderer()->isImage());
#ifndef QT_NO_CLIPBOARD
CachedImage* cachedImage = static_cast<RenderImage*>(node->renderer())->cachedImage();
ASSERT(cachedImage);
Image* image = cachedImage->image();
ASSERT(image);
QPixmap* pixmap = image->nativeImageForCurrentFrame();
ASSERT(pixmap);
QApplication::clipboard()->setPixmap(*pixmap, QClipboard::Clipboard);
#endif
}
void Pasteboard::writeImage(Node* node, const KURL&, const String&)
{
GtkClipboard* clipboard = gtk_clipboard_get_for_display(gdk_display_get_default(), GDK_SELECTION_CLIPBOARD);
ASSERT(node && node->renderer() && node->renderer()->isImage());
RenderImage* renderer = toRenderImage(node->renderer());
CachedImage* cachedImage = renderer->cachedImage();
if (!cachedImage || cachedImage->errorOccurred())
return;
Image* image = cachedImage->image();
ASSERT(image);
PlatformRefPtr<GdkPixbuf> pixbuf = adoptPlatformRef(image->getGdkPixbuf());
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
dataObject->setImage(pixbuf.get());
m_helper->writeClipboardContents(clipboard);
}
void Pasteboard::writeImage(Node* node, const KURL&, const String&)
{
ASSERT(node && node->renderer() && node->renderer()->isImage());
RenderImage* renderer = toRenderImage(node->renderer());
CachedImage* cachedImage = renderer->cachedImage();
if (!cachedImage || cachedImage->errorOccurred())
return;
Image* image = cachedImage->image();
ASSERT(image);
clear();
HDC dc = GetDC(0);
HDC compatibleDC = CreateCompatibleDC(0);
HDC sourceDC = CreateCompatibleDC(0);
OwnPtr<HBITMAP> resultBitmap(CreateCompatibleBitmap(dc, image->width(), image->height()));
HGDIOBJ oldBitmap = SelectObject(compatibleDC, resultBitmap.get());
BitmapInfo bmInfo = BitmapInfo::create(image->size());
HBITMAP coreBitmap = CreateDIBSection(dc, &bmInfo, DIB_RGB_COLORS, 0, 0, 0);
HGDIOBJ oldSource = SelectObject(sourceDC, coreBitmap);
image->getHBITMAP(coreBitmap);
#if !defined(NO_ALPHABLEND)
BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA};
AlphaBlend(compatibleDC, 0, 0, image->width(), image->height(),
sourceDC, 0, 0, image->width(), image->height(), bf);
#else
StretchBlt(compatibleDC, 0, 0, image->width(), image->height(),
sourceDC, 0, 0, image->width(), image->height(), SRCCOPY);
#endif
SelectObject(sourceDC, oldSource);
DeleteObject(coreBitmap);
SelectObject(compatibleDC, oldBitmap);
DeleteDC(sourceDC);
DeleteDC(compatibleDC);
ReleaseDC(0, dc);
if (::OpenClipboard(m_owner)) {
::SetClipboardData(CF_BITMAP, resultBitmap.leakPtr());
::CloseClipboard();
}
}
void ClipboardGtk::declareAndWriteDragImage(Element* element, const KURL& url, const String& label, Frame*)
{
CachedImage* cachedImage = getCachedImage(element);
if (!cachedImage || !cachedImage->isLoaded())
return;
GdkPixbuf* pixbuf = cachedImage->image()->getGdkPixbuf();
if (!pixbuf)
return;
GtkClipboard* imageClipboard = gtk_clipboard_get(gdk_atom_intern_static_string("WebKitClipboardImage"));
gtk_clipboard_clear(imageClipboard);
gtk_clipboard_set_image(imageClipboard, pixbuf);
g_object_unref(pixbuf);
writeURL(url, label, 0);
}
void Pasteboard::writeImage(Node* node, const KURL&, const String&)
{
ASSERT(node && node->renderer() && node->renderer()->isImage());
#ifndef QT_NO_CLIPBOARD
CachedImage* cachedImage = toRenderImage(node->renderer())->cachedImage();
if (!cachedImage || cachedImage->errorOccurred())
return;
Image* image = cachedImage->image();
ASSERT(image);
QPixmap* pixmap = image->nativeImageForCurrentFrame();
if (!pixmap)
return;
QApplication::clipboard()->setPixmap(*pixmap, QClipboard::Clipboard);
#endif
}
