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);
}
Element* HTMLFormCollection::getNamedFormItem(const QualifiedName& attrName, const String& name, int duplicateNumber) const
{
HTMLFormElement* form = static_cast<HTMLFormElement*>(base());
bool foundInputElements = false;
for (unsigned i = 0; i < form->m_associatedElements.size(); ++i) {
FormAssociatedElement* associatedElement = form->m_associatedElements[i];
HTMLElement* element = toHTMLElement(associatedElement);
if (associatedElement->isEnumeratable() && element->getAttribute(attrName) == name) {
foundInputElements = true;
if (!duplicateNumber)
return element;
--duplicateNumber;
}
}
if (!foundInputElements) {
for (unsigned i = 0; i < form->m_imageElements.size(); ++i) {
HTMLImageElement* element = form->m_imageElements[i];
if (element->getAttribute(attrName) == name) {
if (!duplicateNumber)
return element;
--duplicateNumber;
}
}
}
return 0;
}
const AtomicString& HitTestResult::altDisplayString() const
{
if (!m_innerNonSharedNode)
return nullAtom;
if (m_innerNonSharedNode->hasTagName(imgTag)) {
HTMLImageElement* image = toHTMLImageElement(m_innerNonSharedNode);
return image->getAttribute(altAttr);
}
if (m_innerNonSharedNode->hasTagName(inputTag)) {
HTMLInputElement* input = toHTMLInputElement(m_innerNonSharedNode);
return input->alt();
}
#if ENABLE(WML)
if (m_innerNonSharedNode->hasTagName(WMLNames::imgTag)) {
WMLImageElement* image = toWMLImageElement(m_innerNonSharedNode);
// FIXME
return image->fastGetAttribute(altAttr);//image->altText();
}
#endif
return nullAtom;
}
void PageSerializer::serializeFrame(Frame* frame)
{
Document* document = frame->document();
URL url = document->url();
if (!url.isValid() || url.isBlankURL()) {
// For blank frames we generate a fake URL so they can be referenced by their containing frame.
url = urlForBlankFrame(frame);
}
if (m_resourceURLs.contains(url)) {
// FIXME: We could have 2 frame with the same URL but which were dynamically changed and have now
// different content. So we should serialize both and somehow rename the frame src in the containing
// frame. Arg!
return;
}
Vector<Node*> nodes;
SerializerMarkupAccumulator accumulator(*this, *document, &nodes);
TextEncoding textEncoding(document->charset());
CString data;
if (!textEncoding.isValid()) {
// FIXME: iframes used as images trigger this. We should deal with them correctly.
return;
}
String text = accumulator.serializeNodes(*document->documentElement(), 0, IncludeNode);
CString frameHTML = textEncoding.encode(text, EntitiesForUnencodables);
m_resources->append(Resource(url, document->suggestedMIMEType(), SharedBuffer::create(frameHTML.data(), frameHTML.length())));
m_resourceURLs.add(url);
for (Vector<Node*>::iterator iter = nodes.begin(); iter != nodes.end(); ++iter) {
Node* node = *iter;
if (!node->isElementNode())
continue;
Element* element = toElement(node);
// We have to process in-line style as it might contain some resources (typically background images).
if (element->isStyledElement())
retrieveResourcesForProperties(toStyledElement(element)->inlineStyle(), document);
if (isHTMLImageElement(element)) {
HTMLImageElement* imageElement = toHTMLImageElement(element);
URL url = document->completeURL(imageElement->getAttribute(HTMLNames::srcAttr));
CachedImage* cachedImage = imageElement->cachedImage();
addImageToResources(cachedImage, imageElement->renderer(), url);
} else if (element->hasTagName(HTMLNames::linkTag)) {
HTMLLinkElement* linkElement = toHTMLLinkElement(element);
if (CSSStyleSheet* sheet = linkElement->sheet()) {
URL url = document->completeURL(linkElement->getAttribute(HTMLNames::hrefAttr));
serializeCSSStyleSheet(sheet, url);
ASSERT(m_resourceURLs.contains(url));
}
} else if (isHTMLStyleElement(element)) {
if (CSSStyleSheet* sheet = toHTMLStyleElement(element)->sheet())
serializeCSSStyleSheet(sheet, URL());
}
}
for (Frame* childFrame = frame->tree().firstChild(); childFrame; childFrame = childFrame->tree().nextSibling())
serializeFrame(childFrame);
}
// This method filters what element will get tap-highlight'ed or not. To start with,
// we are going to highlight links (anchors with a valid href element), and elements
// whose tap highlight color value is different than the default value.
static Element* elementForTapHighlight(Element* elementUnderFatFinger)
{
// Do not bail out right way here if there element does not have a renderer.
// It is the casefor <map> (descendent of <area>) elements. The associated <image>
// element actually has the renderer.
if (elementUnderFatFinger->renderer()) {
Color tapHighlightColor = elementUnderFatFinger->renderStyle()->tapHighlightColor();
if (tapHighlightColor != RenderTheme::defaultTheme()->platformTapHighlightColor())
return elementUnderFatFinger;
}
bool isArea = elementUnderFatFinger->hasTagName(HTMLNames::areaTag);
Node* linkNode = elementUnderFatFinger->enclosingLinkEventParentOrSelf();
if (!linkNode || !linkNode->isHTMLElement() || (!linkNode->renderer() && !isArea))
return 0;
ASSERT(linkNode->isLink());
// FatFingers class selector ensure only anchor with valid href attr value get here.
// It includes empty hrefs.
Element* highlightCandidateElement = static_cast<Element*>(linkNode);
if (!isArea)
return highlightCandidateElement;
HTMLAreaElement* area = static_cast<HTMLAreaElement*>(highlightCandidateElement);
HTMLImageElement* image = area->imageElement();
if (image && image->renderer())
return image;
return 0;
}
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);
}
static v8::Handle<v8::Value> isMapAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
INC_STATS("DOM.HTMLImageElement.isMap._get");
HTMLImageElement* imp = V8HTMLImageElement::toNative(info.Holder());
if (!R_check(imp)) return v8::Handle<v8::Value>(v8::Undefined());
return v8Boolean(imp->hasAttribute(WebCore::HTMLNames::ismapAttr));
}
static v8::Handle<v8::Value> vspaceAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
INC_STATS("DOM.HTMLImageElement.vspace._get");
HTMLImageElement* imp = V8HTMLImageElement::toNative(info.Holder());
if (!R_check(imp)) return v8::Handle<v8::Value>(v8::Undefined());
return v8::Integer::New(imp->getIntegralAttribute(WebCore::HTMLNames::vspaceAttr));
}
void RenderImage::readyWRATHWidgetIntoRect(PaintedWidgetsOfWRATHHandle& handle,
ContextOfWRATH *wrath_context, const IntRect& rect)
{
RenderImage_ReadyWRATHWidgetIntoRect *d(RenderImage_ReadyWRATHWidgetIntoRect::object(this, handle));
ContextOfWRATH::AutoPushNode autoPushRoot(wrath_context, d->m_root_node);
d->m_image.visible(false);
if (!m_imageResource->hasImage() || m_imageResource->errorOccurred() || rect.width() <= 0 || rect.height() <= 0) {
return;
}
RefPtr<Image> img = m_imageResource->image(rect.width(), rect.height());
if (!img || img->isNull()) {
return;
}
HTMLImageElement* imageElt = (node() && node()->hasTagName(imgTag)) ? static_cast<HTMLImageElement*>(node()) : 0;
CompositeOperator compositeOperator = imageElt ? imageElt->compositeOperator() : CompositeSourceOver;
Image* image = m_imageResource->image().get();
/*
bool useLowQualityScaling = shouldPaintAtLowQuality(context, image, image, rect.size());
[WRATH-TODO]: What to do with the above function call?
*/
/*
context->drawImage(m_imageResource->image(rect.width(), rect.height()).get(), style()->colorSpace(), rect, compositeOperator, useLowQualityScaling);
*/
d->m_image.visible(true);
WRATH_drawImage(d->m_image, wrath_context,
m_imageResource->image(rect.width(), rect.height()).get(), style()->colorSpace(), rect, compositeOperator, false /*useLowQualityScaling*/);
}
static v8::Handle<v8::Value> lowsrcAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
INC_STATS("DOM.HTMLImageElement.lowsrc._get");
HTMLImageElement* imp = V8HTMLImageElement::toNative(info.Holder());
if (!R_check(imp)) return v8::Handle<v8::Value>(v8::Undefined());
return v8String(imp->getURLAttribute(WebCore::HTMLNames::lowsrcAttr));
}
static v8::Handle<v8::Value> completeAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
INC_STATS("DOM.HTMLImageElement.complete._get");
HTMLImageElement* imp = V8HTMLImageElement::toNative(info.Holder());
if (!R_check(imp)) return v8::Handle<v8::Value>(v8::Undefined());
return v8Boolean(imp->complete());
}
Element* HTMLFormCollection::getNamedFormItem(const QualifiedName& attrName, const String& name, int duplicateNumber) const
{
HTMLFormElement* form = static_cast<HTMLFormElement*>(base());
bool foundInputElements = false;
for (unsigned i = 0; i < form->formElements.size(); ++i) {
HTMLFormControlElement* e = form->formElements[i];
const QualifiedName& attributeName = (attrName == idAttr) ? e->idAttributeName() : attrName;
if (e->isEnumeratable() && e->getAttribute(attributeName) == name) {
foundInputElements = true;
if (!duplicateNumber)
return e;
--duplicateNumber;
}
}
if (!foundInputElements) {
for (unsigned i = 0; i < form->imgElements.size(); ++i) {
HTMLImageElement* e = form->imgElements[i];
const QualifiedName& attributeName = (attrName == idAttr) ? e->idAttributeName() : attrName;
if (e->getAttribute(attributeName) == name) {
if (!duplicateNumber)
return e;
--duplicateNumber;
}
}
}
return 0;
}
nsresult
HTMLSourceElement::BindToTree(nsIDocument *aDocument,
nsIContent *aParent,
nsIContent *aBindingParent,
bool aCompileEventHandlers)
{
nsresult rv = nsGenericHTMLElement::BindToTree(aDocument,
aParent,
aBindingParent,
aCompileEventHandlers);
NS_ENSURE_SUCCESS(rv, rv);
if (aParent && aParent->IsNodeOfType(nsINode::eMEDIA)) {
HTMLMediaElement* media = static_cast<HTMLMediaElement*>(aParent);
media->NotifyAddedSource();
} else if (aParent && aParent->IsHTMLElement(nsGkAtoms::picture)) {
// Find any img siblings after this <source> and notify them
nsCOMPtr<nsIContent> sibling = AsContent();
while ( (sibling = sibling->GetNextSibling()) ) {
if (sibling->IsHTMLElement(nsGkAtoms::img)) {
HTMLImageElement *img = static_cast<HTMLImageElement*>(sibling.get());
img->PictureSourceAdded(AsContent());
}
}
}
return NS_OK;
}
FocusCandidate::FocusCandidate(Node* node, FocusDirection direction)
: visibleNode(0)
, focusableNode(0)
, enclosingScrollableBox(0)
, distance(maxDistance())
, parentDistance(maxDistance())
, alignment(None)
, parentAlignment(None)
, isOffscreen(true)
, isOffscreenAfterScrolling(true)
{
ASSERT(node);
ASSERT(node->isElementNode());
if (node->hasTagName(HTMLNames::areaTag)) {
HTMLAreaElement* area = static_cast<HTMLAreaElement*>(node);
HTMLImageElement* image = area->imageElement();
if (!image || !image->renderer())
return;
visibleNode = image;
rect = virtualRectForAreaElementAndDirection(area, direction);
} else {
if (!node->renderer())
return;
visibleNode = node;
rect = nodeRectInAbsoluteCoordinates(node, true /* ignore border */);
}
focusableNode = node;
isOffscreen = hasOffscreenRect(visibleNode);
isOffscreenAfterScrolling = hasOffscreenRect(visibleNode, direction);
}
static v8::Handle<v8::Value> heightAttrGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
{
INC_STATS("DOM.HTMLImageElement.height._get");
HTMLImageElement* imp = V8HTMLImageElement::toNative(info.Holder());
if (!R_check(imp)) return v8::Handle<v8::Value>(v8::Undefined());
return v8::Integer::New(imp->height());
}
static void vspaceAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
{
INC_STATS("DOM.HTMLImageElement.vspace._set");
HTMLImageElement* imp = V8HTMLImageElement::toNative(info.Holder());
int v = toInt32(value);
imp->setIntegralAttribute(WebCore::HTMLNames::vspaceAttr, v);
return;
}
bool HTMLAreaElement::isFocusable() const
{
HTMLImageElement* image = imageElement();
if (!image || !image->renderer() || image->renderer()->style().visibility() != VISIBLE)
return false;
return supportsFocus() && Element::tabIndex() >= 0;
}
static void isMapAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
{
INC_STATS("DOM.HTMLImageElement.isMap._set");
HTMLImageElement* imp = V8HTMLImageElement::toNative(info.Holder());
bool v = value->BooleanValue();
imp->setBooleanAttribute(WebCore::HTMLNames::ismapAttr, v);
return;
}
static void heightAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
{
INC_STATS("DOM.HTMLImageElement.height._set");
HTMLImageElement* imp = V8HTMLImageElement::toNative(info.Holder());
int v = toInt32(value);
imp->setHeight(v);
return;
}
DWORD WINAPI ThreadFunc(void* lpParameter)
{
HTMLImageElement* p = (HTMLImageElement*)lpParameter;
// ISequentialByteStream* stream = new FileByteStream(p->m_pImage->m_url);
// stream->AddRef();
// LXML:DownloadDocument* downloader = new DownloadDocument;
Net::UrlBinding* binder = new Net::UrlBinding;
_Ptr<IO::Stream> stream = binder->BindToObject(p->m_pImage->m_url, NULL/*downloader*//*pBrowser*/);
int n;
for (n = 0; n < 3; n++)
{
int ret = -1;
switch (n)
{
case 0:
{
ret = p->ReadJPEG(stream);
}
break;
case 1:
{
ret = p->ReadGIF(stream);
}
break;
case 2:
{
ret = p->ReadPNG(stream);
}
break;
}
if (ret == 0)
break;
ASSERT(0);
//stream.Seek(0, System::IO::STREAM_SEEK_SET);
}
/*
if (n == 3)
{
int ret = p->ReadPNG(stream);
ASSERT(0);
}
*/
//stream->Release();
return 0;
}
TEST_F(ImageBitmapTest, ImageResourceConsistency)
{
const ImageBitmapOptions defaultOptions;
HTMLImageElement* imageElement = HTMLImageElement::create(*Document::create());
ImageResource* image = ImageResource::create(StaticBitmapImage::create(m_image).get());
imageElement->setImageResource(image);
ImageBitmap* imageBitmapNoCrop = ImageBitmap::create(imageElement,
IntRect(0, 0, m_image->width(), m_image->height()),
&(imageElement->document()), defaultOptions);
ImageBitmap* imageBitmapInteriorCrop = ImageBitmap::create(imageElement,
IntRect(m_image->width() / 2, m_image->height() / 2, m_image->width() / 2, m_image->height() / 2),
&(imageElement->document()), defaultOptions);
ImageBitmap* imageBitmapExteriorCrop = ImageBitmap::create(imageElement,
IntRect(-m_image->width() / 2, -m_image->height() / 2, m_image->width(), m_image->height()),
&(imageElement->document()), defaultOptions);
ImageBitmap* imageBitmapOutsideCrop = ImageBitmap::create(imageElement,
IntRect(-m_image->width(), -m_image->height(), m_image->width(), m_image->height()),
&(imageElement->document()), defaultOptions);
ASSERT_EQ(imageBitmapNoCrop->bitmapImage()->imageForCurrentFrame(), imageElement->cachedImage()->getImage()->imageForCurrentFrame());
ASSERT_NE(imageBitmapInteriorCrop->bitmapImage()->imageForCurrentFrame(), imageElement->cachedImage()->getImage()->imageForCurrentFrame());
ASSERT_NE(imageBitmapExteriorCrop->bitmapImage()->imageForCurrentFrame(), imageElement->cachedImage()->getImage()->imageForCurrentFrame());
StaticBitmapImage* emptyImage = imageBitmapOutsideCrop->bitmapImage();
ASSERT_NE(emptyImage->imageForCurrentFrame(), imageElement->cachedImage()->getImage()->imageForCurrentFrame());
}
void HTMLAreaElement::updateFocusAppearance(SelectionRestorationMode restorationMode, SelectionRevealMode revealMode)
{
if (!isFocusable())
return;
HTMLImageElement* imageElement = this->imageElement();
if (!imageElement)
return;
imageElement->updateFocusAppearance(restorationMode, revealMode);
}
void HTMLAreaElement::updateFocusAppearance(bool restorePreviousSelection)
{
if (!isFocusable())
return;
HTMLImageElement* imageElement = this->imageElement();
if (!imageElement)
return;
imageElement->updateFocusAppearance(restorePreviousSelection);
}
void RenderImage::paintIntoRect(GraphicsContext* context, const IntRect& rect)
{
if (!hasImage() || errorOccurred() || rect.width() <= 0 || rect.height() <= 0)
return;
Image* img = image(rect.width(), rect.height());
if (!img || img->isNull())
return;
HTMLImageElement* imageElt = (node() && node()->hasTagName(imgTag)) ? static_cast<HTMLImageElement*>(node()) : 0;
CompositeOperator compositeOperator = imageElt ? imageElt->compositeOperator() : CompositeSourceOver;
bool useLowQualityScaling = RenderImageScaleObserver::shouldImagePaintAtLowQuality(this, rect.size());
context->drawImage(image(rect.width(), rect.height()), style()->colorSpace(), rect, compositeOperator, useLowQualityScaling);
}
void
ImageDocument::ShrinkToFit()
{
if (!mImageContent) {
return;
}
if (GetZoomLevel() != mOriginalZoomLevel && mImageIsResized &&
!nsContentUtils::IsChildOfSameType(this)) {
// If we're zoomed, so that we don't maintain the invariant that
// mImageIsResized if and only if its displayed width/height fit in
// mVisibleWidth/mVisibleHeight, then we may need to switch to/from the
// overflowingVertical class here, because our viewport size may have
// changed and we don't plan to adjust the image size to compensate. Since
// mImageIsResized it has a "height" attribute set, and we can just get the
// displayed image height by getting .height on the HTMLImageElement.
HTMLImageElement* img = HTMLImageElement::FromContent(mImageContent);
uint32_t imageHeight = img->Height();
nsDOMTokenList* classList = img->ClassList();
ErrorResult ignored;
if (imageHeight > mVisibleHeight) {
classList->Add(NS_LITERAL_STRING("overflowingVertical"), ignored);
} else {
classList->Remove(NS_LITERAL_STRING("overflowingVertical"), ignored);
}
ignored.SuppressException();
return;
}
// Keep image content alive while changing the attributes.
nsCOMPtr<Element> imageContent = mImageContent;
nsCOMPtr<nsIDOMHTMLImageElement> image = do_QueryInterface(imageContent);
image->SetWidth(std::max(1, NSToCoordFloor(GetRatio() * mImageWidth)));
image->SetHeight(std::max(1, NSToCoordFloor(GetRatio() * mImageHeight)));
// The view might have been scrolled when zooming in, scroll back to the
// origin now that we're showing a shrunk-to-window version.
ScrollImageTo(0, 0, false);
if (!mImageContent) {
// ScrollImageTo flush destroyed our content.
return;
}
SetModeClass(eShrinkToFit);
mImageIsResized = true;
UpdateTitleAndCharset();
}
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 RenderImage::paintIntoRect(GraphicsContext* context, const IntRect& rect)
{
if (!m_imageResource->hasImage() || m_imageResource->errorOccurred() || rect.width() <= 0 || rect.height() <= 0)
return;
RefPtr<Image> img = m_imageResource->image(rect.width(), rect.height());
if (!img || img->isNull())
return;
HTMLImageElement* imageElt = (node() && node()->hasTagName(imgTag)) ? static_cast<HTMLImageElement*>(node()) : 0;
CompositeOperator compositeOperator = imageElt ? imageElt->compositeOperator() : CompositeSourceOver;
Image* image = m_imageResource->image().get();
bool useLowQualityScaling = shouldPaintAtLowQuality(context, image, image, rect.size());
context->drawImage(m_imageResource->image(rect.width(), rect.height()).get(), style()->colorSpace(), rect, compositeOperator, useLowQualityScaling);
}
AccessibilityObject* AXObjectCache::focusedImageMapUIElement(HTMLAreaElement* areaElement)
{
// Find the corresponding accessibility object for the HTMLAreaElement. This should be
// in the list of children for its corresponding image.
if (!areaElement)
return 0;
HTMLImageElement* imageElement = areaElement->imageElement();
if (!imageElement)
return 0;
AccessibilityObject* axRenderImage = areaElement->document()->axObjectCache()->getOrCreate(imageElement->renderer());
if (!axRenderImage)
return 0;
AccessibilityObject::AccessibilityChildrenVector imageChildren = axRenderImage->children();
unsigned count = imageChildren.size();
for (unsigned k = 0; k < count; ++k) {
AccessibilityObject* child = imageChildren[k].get();
if (!child->isImageMapLink())
continue;
if (static_cast<AccessibilityImageMapLink*>(child)->areaElement() == areaElement)
return child;
}
return 0;
}
void RenderImage::paintIntoRect(GraphicsContext* context, const LayoutRect& rect)
{
IntRect alignedRect = pixelSnappedIntRect(rect);
if (!m_imageResource->hasImage() || m_imageResource->errorOccurred() || alignedRect.width() <= 0 || alignedRect.height() <= 0)
return;
RefPtr<Image> img = m_imageResource->image(alignedRect.width(), alignedRect.height());
if (!img || img->isNull())
return;
HTMLImageElement* imageElt = hostImageElement();
CompositeOperator compositeOperator = imageElt ? imageElt->compositeOperator() : CompositeSourceOver;
Image* image = m_imageResource->image().get();
bool useLowQualityScaling = shouldPaintAtLowQuality(context, image, image, alignedRect.size());
context->drawImage(m_imageResource->image(alignedRect.width(), alignedRect.height()).get(), style()->colorSpace(), alignedRect, compositeOperator, shouldRespectImageOrientation(), useLowQualityScaling);
}
void HTMLAreaElement::setFocus(bool shouldBeFocused)
{
if (focused() == shouldBeFocused)
return;
HTMLAnchorElement::setFocus(shouldBeFocused);
HTMLImageElement* imageElement = this->imageElement();
if (!imageElement)
return;
auto renderer = imageElement->renderer();
if (!renderer || !renderer->isImage())
return;
toRenderImage(renderer)->areaElementFocusChanged(this);
}
