void Pasteboard::writeImage(Node* node, const KURL&, const String& title)
{
ASSERT(node);
if (!(node->renderer() && node->renderer()->isImage()))
return;
RenderImage* renderer = toRenderImage(node->renderer());
CachedImage* cachedImage = renderer->cachedImage();
if (!cachedImage || cachedImage->errorOccurred())
return;
Image* image = cachedImage->imageForRenderer(renderer);
ASSERT(image);
GtkClipboard* clipboard = gtk_clipboard_get_for_display(gdk_display_get_default(), GDK_SELECTION_CLIPBOARD);
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
KURL url = getURLForImageNode(node);
if (!url.isEmpty()) {
dataObject->setURL(url, title);
dataObject->setMarkup(createMarkup(static_cast<Element*>(node), IncludeNode, 0, ResolveAllURLs));
}
GRefPtr<GdkPixbuf> pixbuf = adoptGRef(image->getGdkPixbuf());
dataObject->setImage(pixbuf.get());
PasteboardHelper::defaultPasteboardHelper()->writeClipboardContents(clipboard);
}
void Pasteboard::writeImage(Node* node, const KURL&, const String& title)
{
ASSERT(node);
if (!(node->renderer() && node->renderer()->isImage()))
return;
RenderImage* renderer = toRenderImage(node->renderer());
CachedImage* cachedImage = renderer->cachedImage();
if (!cachedImage || cachedImage->errorOccurred())
return;
Image* image = cachedImage->imageForRenderer(renderer);
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));
PlatformSupport::clipboardWriteImage(bitmap, url, title);
}
void Pasteboard::writeImage(Element& element, const URL&, const String& title)
{
if (!(element.renderer() && element.renderer()->isRenderImage()))
return;
RenderImage* renderer = toRenderImage(element.renderer());
CachedImage* cachedImage = renderer->cachedImage();
if (!cachedImage || cachedImage->errorOccurred())
return;
Image* image = cachedImage->imageForRenderer(renderer);
ASSERT(image);
m_dataObject->clearAll();
URL url = getURLForImageElement(element);
if (!url.isEmpty()) {
m_dataObject->setURL(url, title);
m_dataObject->setMarkup(createMarkup(element, IncludeNode, 0, ResolveAllURLs));
}
GRefPtr<GdkPixbuf> pixbuf = adoptGRef(image->getGdkPixbuf());
m_dataObject->setImage(pixbuf.get());
if (m_gtkClipboard)
PasteboardHelper::defaultPasteboardHelper()->writeClipboardContents(m_gtkClipboard);
}
void ImageLoader::setImage(CachedImage* newImage)
{
ASSERT(m_failedLoadURL.isEmpty());
CachedImage* oldImage = m_image.get();
if (newImage != oldImage) {
m_image = newImage;
if (!m_firedBeforeLoad) {
beforeLoadEventSender().cancelEvent(this);
m_firedBeforeLoad = true;
}
if (!m_firedLoad) {
loadEventSender().cancelEvent(this);
m_firedLoad = true;
}
m_imageComplete = true;
if (newImage)
newImage->addClient(this);
if (oldImage)
oldImage->removeClient(this);
}
if (RenderObject* renderer = m_element->renderer()) {
if (!renderer->isImage())
return;
toRenderImage(renderer)->resetAnimation();
}
}
static void appendServerMapMousePosition(StringBuilder& url, Event* event)
{
if (!event->isMouseEvent())
return;
ASSERT(event->target());
Node* target = event->target()->toNode();
ASSERT(target);
if (!isHTMLImageElement(target))
return;
HTMLImageElement* imageElement = toHTMLImageElement(target);
if (!imageElement || !imageElement->isServerMap())
return;
if (!imageElement->renderer() || !imageElement->renderer()->isRenderImage())
return;
RenderImage* renderer = toRenderImage(imageElement->renderer());
// FIXME: This should probably pass true for useTransforms.
FloatPoint absolutePosition = renderer->absoluteToLocal(FloatPoint(toMouseEvent(event)->pageX(), toMouseEvent(event)->pageY()));
int x = absolutePosition.x();
int y = absolutePosition.y();
url.append('?');
url.appendNumber(x);
url.append(',');
url.appendNumber(y);
}
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);
}
static void appendServerMapMousePosition(String& url, Event* event)
{
if (!event->isMouseEvent())
return;
ASSERT(event->target());
Node* target = event->target()->toNode();
ASSERT(target);
if (!target->hasTagName(imgTag))
return;
HTMLImageElement* imageElement = static_cast<HTMLImageElement*>(event->target()->toNode());
if (!imageElement || !imageElement->isServerMap())
return;
RenderImage* renderer = toRenderImage(imageElement->renderer());
if (!renderer)
return;
// FIXME: This should probably pass true for useTransforms.
FloatPoint absolutePosition = renderer->absoluteToLocal(FloatPoint(static_cast<MouseEvent*>(event)->pageX(), static_cast<MouseEvent*>(event)->pageY()));
int x = absolutePosition.x();
int y = absolutePosition.y();
url += "?";
url += String::number(x);
url += ",";
url += String::number(y);
}
static CachedImage* getCachedImage(Element* element)
{
ASSERT(element);
RenderObject* renderer = element->renderer();
if (!renderer || !renderer->isImage())
return 0;
RenderImage* image = toRenderImage(renderer);
return image->cachedImage();
}
LayoutSize RenderImageResource::getImageSize(float multiplier, ImageResource::SizeType type) const
{
if (!m_cachedImage)
return LayoutSize();
LayoutSize size = m_cachedImage->imageSizeForRenderer(m_renderer, multiplier, type);
if (m_renderer && m_renderer->isRenderImage())
size.scale(toRenderImage(m_renderer)->imageDevicePixelRatio());
return size;
}
static LayoutRect getShapeImageReplacedRect(const RenderBox& renderBox, const StyleImage& styleImage)
{
if (renderBox.isRenderImage()) {
const RenderImage& renderImage = *toRenderImage(&renderBox);
return renderImage.replacedContentRect(renderBox.intrinsicSize());
}
ASSERT(styleImage.cachedImage());
ASSERT(styleImage.cachedImage()->hasImage());
return LayoutRect(LayoutPoint(), styleImage.cachedImage()->image()->size());
}
void SVGImageElement::attach()
{
SVGStyledTransformableElement::attach();
if (RenderImage* imageObj = toRenderImage(renderer())) {
if (imageObj->hasImage())
return;
imageObj->setCachedImage(m_imageLoader.image());
}
}
RenderImageResource* ImageLoader::renderImageResource()
{
auto renderer = element().renderer();
if (!renderer)
return nullptr;
// We don't return style generated image because it doesn't belong to the ImageLoader.
// See <https://bugs.webkit.org/show_bug.cgi?id=42840>
if (renderer->isRenderImage() && !toRenderImage(*renderer).isGeneratedContent())
return &toRenderImage(*renderer).imageResource();
if (renderer->isSVGImage())
return &toRenderSVGImage(renderer)->imageResource();
#if ENABLE(VIDEO)
if (renderer->isVideo())
return &toRenderVideo(*renderer).imageResource();
#endif
return nullptr;
}
static Image* getImage(Element* element)
{
ASSERT(element);
RenderObject* renderer = element->renderer();
if (!renderer || !renderer->isImage())
return 0;
RenderImage* image = toRenderImage(renderer);
if (image->cachedImage() && !image->cachedImage()->errorOccurred())
return image->cachedImage()->image();
return 0;
}
void ImageLoader::updateFromElement()
{
// If we're not making renderers for the page, then don't load images. We don't want to slow
// down the raw HTML parsing case by loading images we don't intend to display.
Document* document = m_element->document();
if (!document->renderer())
return;
AtomicString attr = m_element->getAttribute(m_element->imageSourceAttributeName());
if (attr == m_failedLoadURL)
return;
// Do not load any image if the 'src' attribute is missing or if it is
// an empty string referring to a local file. The latter condition is
// a quirk that preserves old behavior that Dashboard widgets
// need (<rdar://problem/5994621>).
CachedImage* newImage = 0;
if (!(attr.isNull() || (attr.isEmpty() && document->baseURI().isLocalFile()))) {
if (m_loadManually) {
document->docLoader()->setAutoLoadImages(false);
newImage = new CachedImage(sourceURI(attr));
newImage->setLoading(true);
newImage->setDocLoader(document->docLoader());
document->docLoader()->m_documentResources.set(newImage->url(), newImage);
} else
newImage = document->docLoader()->requestImage(sourceURI(attr));
// If we do not have an image here, it means that a cross-site
// violation occurred.
m_failedLoadURL = !newImage ? attr : AtomicString();
}
CachedImage* oldImage = m_image.get();
if (newImage != oldImage) {
setLoadingImage(newImage);
if (newImage) {
newImage->addClient(this);
if (!m_element->document()->hasListenerType(Document::BEFORELOAD_LISTENER))
dispatchPendingBeforeLoadEvent();
else
beforeLoadEventSender().dispatchEventSoon(this);
}
if (oldImage)
oldImage->removeClient(this);
}
if (RenderObject* renderer = m_element->renderer()) {
if (!renderer->isImage())
return;
toRenderImage(renderer)->resetAnimation();
}
}
RenderImageResource* ImageLoader::renderImageResource()
{
RenderObject* renderer = m_element->renderer();
if (!renderer)
return 0;
if (renderer->isImage())
return toRenderImage(renderer)->imageResource();
return 0;
}
void RenderReplaced::computeAspectRatioInformationForRenderBox(RenderBox* contentRenderer, FloatSize& constrainedSize, double& intrinsicRatio, bool& isPercentageIntrinsicSize) const
{
FloatSize intrinsicSize;
if (contentRenderer) {
contentRenderer->computeIntrinsicRatioInformation(intrinsicSize, intrinsicRatio, isPercentageIntrinsicSize);
if (intrinsicRatio)
ASSERT(!isPercentageIntrinsicSize);
// Handle zoom & vertical writing modes here, as the embedded document doesn't know about them.
if (!isPercentageIntrinsicSize) {
intrinsicSize.scale(style().effectiveZoom());
if (isRenderImage())
intrinsicSize.scale(toRenderImage(this)->imageDevicePixelRatio());
}
if (hasAspectRatio() && isPercentageIntrinsicSize)
intrinsicRatio = 1;
// Update our intrinsic size to match what the content renderer has computed, so that when we
// constrain the size below, the correct intrinsic size will be obtained for comparison against
// min and max widths.
if (intrinsicRatio && !isPercentageIntrinsicSize && !intrinsicSize.isEmpty())
m_intrinsicSize = LayoutSize(intrinsicSize);
if (!isHorizontalWritingMode()) {
if (intrinsicRatio)
intrinsicRatio = 1 / intrinsicRatio;
intrinsicSize = intrinsicSize.transposedSize();
}
} else {
computeIntrinsicRatioInformation(intrinsicSize, intrinsicRatio, isPercentageIntrinsicSize);
if (intrinsicRatio) {
ASSERT(!isPercentageIntrinsicSize);
if (!intrinsicSize.isEmpty())
m_intrinsicSize = LayoutSize(isHorizontalWritingMode() ? intrinsicSize : intrinsicSize.transposedSize());
}
}
// Now constrain the intrinsic size along each axis according to minimum and maximum width/heights along the
// opposite axis. So for example a maximum width that shrinks our width will result in the height we compute here
// having to shrink in order to preserve the aspect ratio. Because we compute these values independently along
// each axis, the final returned size may in fact not preserve the aspect ratio.
// FIXME: In the long term, it might be better to just return this code more to the way it used to be before this
// function was added, since all it has done is make the code more unclear.
constrainedSize = intrinsicSize;
if (intrinsicRatio && !isPercentageIntrinsicSize && !intrinsicSize.isEmpty() && style().logicalWidth().isAuto() && style().logicalHeight().isAuto()) {
// We can't multiply or divide by 'intrinsicRatio' here, it breaks tests, like fast/images/zoomed-img-size.html, which
// can only be fixed once subpixel precision is available for things like intrinsicWidth/Height - which include zoom!
constrainedSize.setWidth(RenderBox::computeReplacedLogicalHeight() * intrinsicSize.width() / intrinsicSize.height());
constrainedSize.setHeight(RenderBox::computeReplacedLogicalWidth() * intrinsicSize.height() / intrinsicSize.width());
}
}
Image* HitTestResult::image() const
{
if (!m_innerNonSharedNode)
return 0;
RenderObject* renderer = m_innerNonSharedNode->renderer();
if (renderer && renderer->isImage()) {
RenderImage* image = toRenderImage(renderer);
if (image->cachedImage() && !image->cachedImage()->errorOccurred())
return image->cachedImage()->imageForRenderer(image);
}
return 0;
}
static CachedImage* getCachedImage(Element* element)
{
// Attempt to pull CachedImage from element
ASSERT(element);
RenderObject* renderer = element->renderer();
if (!renderer || !renderer->isImage())
return 0;
RenderImage* image = toRenderImage(renderer);
if (image->cachedImage() && !image->cachedImage()->errorOccurred())
return image->cachedImage();
return 0;
}
PassOwnPtr<Shape> ShapeOutsideInfo::createShapeForImage(StyleImage* styleImage, float shapeImageThreshold, WritingMode writingMode, float margin) const
{
const IntSize& imageSize = m_renderer.calculateImageIntrinsicDimensions(styleImage, roundedIntSize(m_referenceBoxLogicalSize), RenderImage::ScaleByEffectiveZoom);
styleImage->setContainerSizeForRenderer(&m_renderer, imageSize, m_renderer.style()->effectiveZoom());
const LayoutRect& marginRect = getShapeImageMarginRect(m_renderer, m_referenceBoxLogicalSize);
const LayoutRect& imageRect = (m_renderer.isRenderImage())
? toRenderImage(&m_renderer)->replacedContentRect()
: LayoutRect(LayoutPoint(), imageSize);
ASSERT(!styleImage->isPendingImage());
RefPtr<Image> image = styleImage->image(const_cast<RenderBox*>(&m_renderer), imageSize);
return Shape::createRasterShape(image.get(), shapeImageThreshold, imageRect, marginRect, writingMode, margin);
}
void ImageLoader::updateRenderer()
{
if (RenderObject* renderer = m_element->renderer()) {
if (!renderer->isImage() && !renderer->isVideo())
return;
RenderImage* imageRenderer = toRenderImage(renderer);
// Only update the renderer if it doesn't have an image or if what we have
// is a complete image. This prevents flickering in the case where a dynamic
// change is happening between two images.
CachedImage* cachedImage = imageRenderer->cachedImage();
if (m_image != cachedImage && (m_imageComplete || !imageRenderer->cachedImage()))
imageRenderer->setCachedImage(m_image.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 = 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 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();
ASSERT(cachedImage);
Image* image = cachedImage->image();
ASSERT(image);
QPixmap* pixmap = image->nativeImageForCurrentFrame();
ASSERT(pixmap);
QApplication::clipboard()->setPixmap(*pixmap, QClipboard::Clipboard);
#endif
}
void HTMLAreaElement::setFocus(bool shouldBeFocused)
{
if (focused() == shouldBeFocused)
return;
HTMLAnchorElement::setFocus(shouldBeFocused);
HTMLImageElement* imageElement = this->imageElement();
if (!imageElement)
return;
RenderObject* renderer = imageElement->renderer();
if (!renderer || !renderer->isImage())
return;
toRenderImage(renderer)->areaElementFocusChanged(this);
}
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;
KApp::clipboard()->setPixmap(*pixmap, QClipboard::Clipboard);
#endif
}
static void getShapeImageAndRect(const ShapeValue& shapeValue, const RenderBox& renderBox, const LayoutSize& referenceBoxSize, Image*& image, LayoutRect& rect)
{
ASSERT(shapeValue.isImageValid());
StyleImage* styleImage = shapeValue.image();
const LayoutSize& imageSize = renderBox.calculateImageIntrinsicDimensions(styleImage, roundedIntSize(referenceBoxSize), RenderImage::ScaleByEffectiveZoom);
styleImage->setContainerSizeForRenderer(&renderBox, imageSize, renderBox.style().effectiveZoom());
image = nullptr;
if (styleImage->isCachedImage() || styleImage->isCachedImageSet())
image = styleImage->cachedImage()->imageForRenderer(&renderBox);
else if (styleImage->isGeneratedImage())
image = styleImage->image(const_cast<RenderBox*>(&renderBox), imageSize).get();
if (renderBox.isRenderImage())
rect = toRenderImage(&renderBox)->replacedContentRect(renderBox.intrinsicSize());
else
rect = LayoutRect(LayoutPoint(), imageSize);
}
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();
ASSERT(cachedImage);
Image* image = cachedImage->image();
ASSERT(image);
clear();
HDC dc = GetDC(0);
HDC compatibleDC = CreateCompatibleDC(0);
HDC sourceDC = CreateCompatibleDC(0);
HBITMAP resultBitmap = CreateCompatibleBitmap(dc, image->width(), image->height());
HBITMAP oldBitmap = (HBITMAP)SelectObject(compatibleDC, resultBitmap);
BitmapInfo bmInfo = BitmapInfo::create(image->size());
HBITMAP coreBitmap = CreateDIBSection(dc, &bmInfo, DIB_RGB_COLORS, 0, 0, 0);
HBITMAP oldSource = (HBITMAP)SelectObject(sourceDC, coreBitmap);
image->getHBITMAP(coreBitmap);
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);
SelectObject(compatibleDC, oldBitmap);
SelectObject(sourceDC, oldSource);
DeleteObject(oldBitmap);
DeleteObject(oldSource);
DeleteObject(coreBitmap);
ReleaseDC(0, dc);
DeleteDC(compatibleDC);
DeleteDC(sourceDC);
if (::OpenClipboard(m_owner)) {
::SetClipboardData(CF_BITMAP, resultBitmap);
::CloseClipboard();
}
}
void Pasteboard::writeImage(Node* node, const KURL&, const String&)
{
ASSERT(node);
if (!(node->renderer() && node->renderer()->isImage()))
return;
RenderImage* renderer = toRenderImage(node->renderer());
CachedImage* cachedImage = renderer->cachedImage();
if (!cachedImage || cachedImage->errorOccurred())
return;
Image* image = cachedImage->imageForRenderer(renderer);
ASSERT(image);
clear();
HWndDC dc(0);
HDC compatibleDC = CreateCompatibleDC(0);
HDC sourceDC = CreateCompatibleDC(0);
OwnPtr<HBITMAP> resultBitmap = adoptPtr(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);
BitBlt(compatibleDC, 0, 0, image->width(), image->height(), sourceDC, 0, 0, SRCCOPY);
SelectObject(sourceDC, oldSource);
DeleteObject(coreBitmap);
SelectObject(compatibleDC, oldBitmap);
DeleteDC(sourceDC);
DeleteDC(compatibleDC);
if (::OpenClipboard(m_owner)) {
::SetClipboardData(CF_BITMAP, resultBitmap.leakPtr());
::CloseClipboard();
}
}
PassOwnPtr<Shape> ShapeOutsideInfo::createShapeForImage(StyleImage* styleImage, float shapeImageThreshold, WritingMode writingMode, float margin) const
{
const IntSize& imageSize = m_renderer.calculateImageIntrinsicDimensions(styleImage, roundedIntSize(m_referenceBoxLogicalSize), RenderImage::ScaleByEffectiveZoom);
styleImage->setContainerSizeForRenderer(&m_renderer, imageSize, m_renderer.style()->effectiveZoom());
const LayoutRect& marginRect = getShapeImageMarginRect(m_renderer, m_referenceBoxLogicalSize);
const LayoutRect& imageRect = (m_renderer.isRenderImage())
? toRenderImage(m_renderer).replacedContentRect()
: LayoutRect(LayoutPoint(), imageSize);
if (!isValidRasterShapeRect(marginRect) || !isValidRasterShapeRect(imageRect)) {
m_renderer.document().addConsoleMessage(ConsoleMessage::create(RenderingMessageSource, ErrorMessageLevel, "The shape-outside image is too large."));
return Shape::createEmptyRasterShape(writingMode, margin);
}
ASSERT(!styleImage->isPendingImage());
RefPtr<Image> image = styleImage->image(const_cast<RenderBox*>(&m_renderer), imageSize);
return Shape::createRasterShape(image.get(), shapeImageThreshold, imageRect, marginRect, writingMode, margin);
}
RenderImageResource* ImageLoader::renderImageResource()
{
RenderObject* renderer = m_element->renderer();
if (!renderer)
return 0;
// We don't return style generated image because it doesn't belong to the ImageLoader.
// See <https://bugs.webkit.org/show_bug.cgi?id=42840>
if (renderer->isImage() && !static_cast<RenderImage*>(renderer)->isGeneratedContent())
return toRenderImage(renderer)->imageResource();
if (renderer->isSVGImage())
return toRenderSVGImage(renderer)->imageResource();
if (renderer->isVideo())
return toRenderVideo(renderer)->imageResource();
return 0;
}
