自学教程：C++ toRenderImage函数代码示例

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();    }}

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);}

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;}

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&){    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();    }}

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);}