FloatSize CSSCrossfadeValue::fixedSize(const RenderElement* renderer)
{
float percentage = m_percentageValue->getFloatValue();
float inversePercentage = 1 - percentage;
// FIXME: Skip Content Security Policy check when cross fade is applied to an element in a user agent shadow tree.
// See <https://bugs.webkit.org/show_bug.cgi?id=146663>.
ResourceLoaderOptions options = CachedResourceLoader::defaultCachedResourceOptions();
CachedResourceLoader& cachedResourceLoader = renderer->document().cachedResourceLoader();
CachedImage* cachedFromImage = cachedImageForCSSValue(m_fromValue, cachedResourceLoader, options);
CachedImage* cachedToImage = cachedImageForCSSValue(m_toValue, cachedResourceLoader, options);
if (!cachedFromImage || !cachedToImage)
return FloatSize();
FloatSize fromImageSize = cachedFromImage->imageForRenderer(renderer)->size();
FloatSize toImageSize = cachedToImage->imageForRenderer(renderer)->size();
// Rounding issues can cause transitions between images of equal size to return
// a different fixed size; avoid performing the interpolation if the images are the same size.
if (fromImageSize == toImageSize)
return fromImageSize;
return FloatSize(fromImageSize.width() * inversePercentage + toImageSize.width() * percentage,
fromImageSize.height() * inversePercentage + toImageSize.height() * percentage);
}
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->imageForRenderer(element->renderer()) || !cachedImage->isLoaded())
return;
QPixmap* pixmap = cachedImage->imageForRenderer(element->renderer())->nativeImageForCurrentFrame();
if (pixmap)
m_writableData->setImageData(*pixmap);
QList<QUrl> urls;
urls.append(url);
m_writableData->setText(title);
m_writableData->setUrls(urls);
m_writableData->setHtml(createMarkup(element, IncludeNode, 0, ResolveAllURLs));
#ifndef QT_NO_CLIPBOARD
if (isForCopyAndPaste())
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->imageForRenderer(element->renderer()) || !cachedImage->isLoaded())
return;
SharedBuffer* imageBuffer = cachedImage->imageForRenderer(element->renderer())->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);
}
RefPtr<Image> CSSCrossfadeValue::image(RenderElement* renderer, const FloatSize& size)
{
if (size.isEmpty())
return nullptr;
// FIXME: Skip Content Security Policy check when cross fade is applied to an element in a user agent shadow tree.
// See <https://bugs.webkit.org/show_bug.cgi?id=146663>.
ResourceLoaderOptions options = CachedResourceLoader::defaultCachedResourceOptions();
CachedResourceLoader& cachedResourceLoader = renderer->document().cachedResourceLoader();
CachedImage* cachedFromImage = cachedImageForCSSValue(m_fromValue, cachedResourceLoader, options);
CachedImage* cachedToImage = cachedImageForCSSValue(m_toValue, cachedResourceLoader, options);
if (!cachedFromImage || !cachedToImage)
return Image::nullImage();
Image* fromImage = cachedFromImage->imageForRenderer(renderer);
Image* toImage = cachedToImage->imageForRenderer(renderer);
if (!fromImage || !toImage)
return Image::nullImage();
m_generatedImage = CrossfadeGeneratedImage::create(*fromImage, *toImage, m_percentageValue->getFloatValue(), fixedSize(renderer), size);
return m_generatedImage;
}
PassRefPtr<Image> CSSFilterImageValue::image(RenderObject* renderer, const IntSize& size)
{
if (size.isEmpty())
return 0;
CachedResourceLoader* cachedResourceLoader = renderer->document()->cachedResourceLoader();
CachedImage* cachedImage = cachedImageForCSSValue(m_imageValue.get(), cachedResourceLoader);
if (!cachedImage)
return Image::nullImage();
Image* image = cachedImage->imageForRenderer(renderer);
if (!image)
return Image::nullImage();
// Transform Image into ImageBuffer.
OwnPtr<ImageBuffer> texture = ImageBuffer::create(size);
if (!texture)
return Image::nullImage();
texture->context()->drawImage(image, ColorSpaceDeviceRGB, IntPoint());
RefPtr<FilterEffectRenderer> filterRenderer = FilterEffectRenderer::create();
filterRenderer->setSourceImage(texture.release());
filterRenderer->setSourceImageRect(FloatRect(FloatPoint(), size));
filterRenderer->setFilterRegion(FloatRect(FloatPoint(), size));
// FIXME: SVG Filter don't work at the moment.
if (!filterRenderer->build(0, m_filterOperations, true))
return Image::nullImage();
filterRenderer->apply();
m_generatedImage = filterRenderer->output()->copyImage();
return m_generatedImage.release();
}
void Pasteboard::writeImage(Node* node, const KURL&, const String&)
{
ASSERT(node);
if (!(node->renderer() && node->renderer()->isImage()))
return;
RenderImage* renderer = static_cast<RenderImage*>(node->renderer());
CachedImage* cachedImage = static_cast<CachedImage*>(renderer->cachedImage());
ASSERT(cachedImage);
Image* image = cachedImage->imageForRenderer(renderer);
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 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);
}
IntSize CSSFilterImageValue::fixedSize(const RenderObject* renderer)
{
CachedResourceLoader* cachedResourceLoader = renderer->document()->cachedResourceLoader();
CachedImage* cachedImage = cachedImageForCSSValue(m_imageValue.get(), cachedResourceLoader);
if (!cachedImage)
return IntSize();
return cachedImage->imageForRenderer(renderer)->size();
}
bool CanvasRenderingContext::wouldTaintOrigin(const HTMLImageElement* image)
{
if (!image || !canvas()->originClean())
return false;
CachedImage* cachedImage = image->cachedImage();
if (!cachedImage->imageForRenderer(image->renderer())->hasSingleSecurityOrigin())
return true;
return wouldTaintOrigin(cachedImage->response().url()) && !cachedImage->passesAccessControlCheck(canvas()->securityOrigin());
}
PassRefPtr<Image> CSSCrossfadeValue::image(RenderObject* renderer, const IntSize& size)
{
if (size.isEmpty())
return 0;
CachedResourceLoader* cachedResourceLoader = renderer->document()->cachedResourceLoader();
CachedImage* cachedFromImage = cachedImageForCSSValue(m_fromValue.get(), cachedResourceLoader);
CachedImage* cachedToImage = cachedImageForCSSValue(m_toValue.get(), cachedResourceLoader);
if (!cachedFromImage || !cachedToImage)
return Image::nullImage();
Image* fromImage = cachedFromImage->imageForRenderer(renderer);
Image* toImage = cachedToImage->imageForRenderer(renderer);
if (!fromImage || !toImage)
return Image::nullImage();
m_generatedImage = CrossfadeGeneratedImage::create(fromImage, toImage, m_percentageValue->getFloatValue(), fixedSize(renderer), size);
return m_generatedImage.release();
}
static bool getImageForElement(Element& element, RefPtr<Image>& image)
{
auto* renderer = element.renderer();
if (!is<RenderImage>(renderer))
return false;
CachedImage* cachedImage = downcast<RenderImage>(*renderer).cachedImage();
if (!cachedImage || cachedImage->errorOccurred())
return false;
image = cachedImage->imageForRenderer(renderer);
return image;
}
IntSize CSSCrossfadeValue::fixedSize(const RenderObject* renderer)
{
float percentage = m_percentageValue->getFloatValue();
float inversePercentage = 1 - percentage;
CachedResourceLoader* cachedResourceLoader = renderer->document()->cachedResourceLoader();
CachedImage* cachedFromImage = cachedImageForCSSValue(m_fromValue.get(), cachedResourceLoader);
CachedImage* cachedToImage = cachedImageForCSSValue(m_toValue.get(), cachedResourceLoader);
if (!cachedFromImage || !cachedToImage)
return IntSize();
IntSize fromImageSize = cachedFromImage->imageForRenderer(renderer)->size();
IntSize toImageSize = cachedToImage->imageForRenderer(renderer)->size();
// Rounding issues can cause transitions between images of equal size to return
// a different fixed size; avoid performing the interpolation if the images are the same size.
if (fromImageSize == toImageSize)
return fromImageSize;
return IntSize(fromImageSize.width() * inversePercentage + toImageSize.width() * percentage,
fromImageSize.height() * inversePercentage + toImageSize.height() * percentage);
}
FloatSize CSSFilterImageValue::fixedSize(const RenderElement* renderer)
{
// FIXME: Skip Content Security Policy check when filter is applied to an element in a user agent shadow tree.
// See <https://bugs.webkit.org/show_bug.cgi?id=146663>.
ResourceLoaderOptions options = CachedResourceLoader::defaultCachedResourceOptions();
CachedResourceLoader& cachedResourceLoader = renderer->document().cachedResourceLoader();
CachedImage* cachedImage = cachedImageForCSSValue(m_imageValue.get(), cachedResourceLoader, options);
if (!cachedImage)
return FloatSize();
return cachedImage->imageForRenderer(renderer)->size();
}
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->imageForRenderer(imageElement->renderer());
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();
}
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->imageForRenderer(element->renderer()) || !cachedImage->isLoaded())
return;
SharedBuffer* imageBuffer = cachedImage->imageForRenderer(element->renderer())->data();
if (!imageBuffer || !imageBuffer->size())
return;
dataObject->setFileContent(imageBuffer);
// Determine the filename for the file contents of the image.
String filename = cachedImage->response().suggestedFilename();
if (filename.isEmpty())
filename = url.lastPathComponent();
if (filename.isEmpty())
filename = element->getAttribute(altAttr);
else {
// Strip any existing extension. Assume that alt text is usually not a filename.
int extensionIndex = filename.reverseFind('.');
if (extensionIndex != -1)
filename.truncate(extensionIndex);
}
String extension = MIMETypeRegistry::getPreferredExtensionForMIMEType(
cachedImage->response().mimeType());
extension = extension.isEmpty() ? emptyString() : "." + extension;
ClipboardChromium::validateFilename(filename, extension);
dataObject->setFileContentFilename(filename + extension);
dataObject->setFileExtension(extension);
}
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, ResolveAllURLs));
CachedImage* image = getCachedImage(element);
if (!image || !image->isLoaded())
return;
GRefPtr<GdkPixbuf> pixbuf = adoptGRef(image->imageForRenderer(element->renderer())->getGdkPixbuf());
if (!pixbuf)
return;
m_dataObject->setImage(pixbuf.get());
}
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();
HDC dc = GetDC(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);
ReleaseDC(0, dc);
if (::OpenClipboard(m_owner)) {
::SetClipboardData(CF_BITMAP, resultBitmap.leakPtr());
::CloseClipboard();
}
}
void Pasteboard::writeImage(Node* node, const KURL&, const String&)
{
ASSERT(node);
if (!(node->renderer() && node->renderer()->isImage()))
return;
#ifndef QT_NO_CLIPBOARD
CachedImage* cachedImage = toRenderImage(node->renderer())->cachedImage();
if (!cachedImage || cachedImage->errorOccurred())
return;
Image* image = cachedImage->imageForRenderer(node->renderer());
ASSERT(image);
QPixmap* pixmap = image->nativeImageForCurrentFrame();
if (!pixmap)
return;
QGuiApplication::clipboard()->setPixmap(*pixmap, QClipboard::Clipboard);
#endif
}
QVariant QtPixmapRuntime::toQt(JSContextRef context, JSObjectRef obj, QMetaType::Type hint, JSValueRef* exception)
{
if (!obj)
return emptyVariantForHint(hint);
if (JSValueIsObjectOfClass(context, obj, QtPixmapRuntime::getClassRef())) {
QVariant* originalVariant = static_cast<QVariant*>(JSObjectGetPrivate(obj));
if (hint == qMetaTypeId<QPixmap>())
return QVariant::fromValue<QPixmap>(toPixmap(*originalVariant));
if (hint == qMetaTypeId<QImage>())
return QVariant::fromValue<QImage>(toImage(*originalVariant));
}
JSObject* jsObject = ::toJS(obj);
if (!jsObject->inherits(&JSHTMLImageElement::s_info))
return emptyVariantForHint(hint);
JSHTMLImageElement* elementJSWrapper = static_cast<JSHTMLImageElement*>(jsObject);
HTMLImageElement* imageElement = static_cast<HTMLImageElement*>(elementJSWrapper->impl());
if (!imageElement)
return emptyVariantForHint(hint);
CachedImage* cachedImage = imageElement->cachedImage();
if (!cachedImage)
return emptyVariantForHint(hint);
Image* image = cachedImage->imageForRenderer(imageElement->renderer());
if (!image)
return emptyVariantForHint(hint);
QImage* nativeImage = image->nativeImageForCurrentFrame();
if (!nativeImage)
return emptyVariantForHint(hint);
return (hint == static_cast<QMetaType::Type>(qMetaTypeId<QPixmap>()))
? QVariant::fromValue<QPixmap>(QPixmap::fromImage(*nativeImage))
: QVariant::fromValue<QImage>(*nativeImage);
}
RefPtr<Image> CSSFilterImageValue::image(RenderElement* renderer, const FloatSize& size)
{
if (size.isEmpty())
return nullptr;
// FIXME: Skip Content Security Policy check when filter is applied to an element in a user agent shadow tree.
// See <https://bugs.webkit.org/show_bug.cgi?id=146663>.
ResourceLoaderOptions options = CachedResourceLoader::defaultCachedResourceOptions();
CachedResourceLoader& cachedResourceLoader = renderer->document().cachedResourceLoader();
CachedImage* cachedImage = cachedImageForCSSValue(m_imageValue.get(), cachedResourceLoader, options);
if (!cachedImage)
return Image::nullImage();
Image* image = cachedImage->imageForRenderer(renderer);
if (!image)
return Image::nullImage();
// Transform Image into ImageBuffer.
std::unique_ptr<ImageBuffer> texture = ImageBuffer::create(size);
if (!texture)
return Image::nullImage();
FloatRect imageRect = FloatRect(FloatPoint(), size);
texture->context().drawImage(image, ColorSpaceDeviceRGB, imageRect);
RefPtr<FilterEffectRenderer> filterRenderer = FilterEffectRenderer::create();
filterRenderer->setSourceImage(WTF::move(texture));
filterRenderer->setSourceImageRect(imageRect);
filterRenderer->setFilterRegion(imageRect);
if (!filterRenderer->build(renderer, m_filterOperations, FilterFunction))
return Image::nullImage();
filterRenderer->apply();
m_generatedImage = filterRenderer->output()->copyImage();
return m_generatedImage.release();
}
