summaryrefslogtreecommitdiffstats
path: root/layout/generic/nsImageMap.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'layout/generic/nsImageMap.cpp')
-rw-r--r--layout/generic/nsImageMap.cpp1020
1 files changed, 1020 insertions, 0 deletions
diff --git a/layout/generic/nsImageMap.cpp b/layout/generic/nsImageMap.cpp
new file mode 100644
index 000000000..19c879756
--- /dev/null
+++ b/layout/generic/nsImageMap.cpp
@@ -0,0 +1,1020 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* code for HTML client-side image maps */
+
+#include "nsImageMap.h"
+
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/Event.h" // for nsIDOMEvent::InternalDOMEvent()
+#include "mozilla/gfx/PathHelpers.h"
+#include "mozilla/UniquePtr.h"
+#include "nsString.h"
+#include "nsReadableUtils.h"
+#include "nsPresContext.h"
+#include "nsNameSpaceManager.h"
+#include "nsGkAtoms.h"
+#include "nsImageFrame.h"
+#include "nsCoord.h"
+#include "nsIScriptError.h"
+#include "nsIStringBundle.h"
+#include "nsContentUtils.h"
+#include "ImageLayers.h"
+
+#ifdef ACCESSIBILITY
+#include "nsAccessibilityService.h"
+#endif
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+
+class Area {
+public:
+ explicit Area(nsIContent* aArea);
+ virtual ~Area();
+
+ virtual void ParseCoords(const nsAString& aSpec);
+
+ virtual bool IsInside(nscoord x, nscoord y) const = 0;
+ virtual void Draw(nsIFrame* aFrame, DrawTarget& aDrawTarget,
+ const ColorPattern& aColor,
+ const StrokeOptions& aStrokeOptions) = 0;
+ virtual void GetRect(nsIFrame* aFrame, nsRect& aRect) = 0;
+
+ void HasFocus(bool aHasFocus);
+
+ nsCOMPtr<nsIContent> mArea;
+ UniquePtr<nscoord[]> mCoords;
+ int32_t mNumCoords;
+ bool mHasFocus;
+};
+
+Area::Area(nsIContent* aArea)
+ : mArea(aArea)
+{
+ MOZ_COUNT_CTOR(Area);
+ NS_PRECONDITION(mArea, "How did that happen?");
+ mNumCoords = 0;
+ mHasFocus = false;
+}
+
+Area::~Area()
+{
+ MOZ_COUNT_DTOR(Area);
+}
+
+#include <stdlib.h>
+
+inline bool
+is_space(char c)
+{
+ return (c == ' ' ||
+ c == '\f' ||
+ c == '\n' ||
+ c == '\r' ||
+ c == '\t' ||
+ c == '\v');
+}
+
+static void logMessage(nsIContent* aContent,
+ const nsAString& aCoordsSpec,
+ int32_t aFlags,
+ const char* aMessageName) {
+ nsIDocument* doc = aContent->OwnerDoc();
+
+ nsContentUtils::ReportToConsole(
+ aFlags, NS_LITERAL_CSTRING("Layout: ImageMap"), doc,
+ nsContentUtils::eLAYOUT_PROPERTIES,
+ aMessageName,
+ nullptr, /* params */
+ 0, /* params length */
+ nullptr,
+ PromiseFlatString(NS_LITERAL_STRING("coords=\"") +
+ aCoordsSpec +
+ NS_LITERAL_STRING("\""))); /* source line */
+}
+
+void Area::ParseCoords(const nsAString& aSpec)
+{
+ char* cp = ToNewCString(aSpec);
+ if (cp) {
+ char *tptr;
+ char *n_str;
+ int32_t i, cnt;
+
+ /*
+ * Nothing in an empty list
+ */
+ mNumCoords = 0;
+ mCoords = nullptr;
+ if (*cp == '\0')
+ {
+ free(cp);
+ return;
+ }
+
+ /*
+ * Skip beginning whitespace, all whitespace is empty list.
+ */
+ n_str = cp;
+ while (is_space(*n_str))
+ {
+ n_str++;
+ }
+ if (*n_str == '\0')
+ {
+ free(cp);
+ return;
+ }
+
+ /*
+ * Make a pass where any two numbers separated by just whitespace
+ * are given a comma separator. Count entries while passing.
+ */
+ cnt = 0;
+ while (*n_str != '\0')
+ {
+ bool has_comma;
+
+ /*
+ * Skip to a separator
+ */
+ tptr = n_str;
+ while (!is_space(*tptr) && *tptr != ',' && *tptr != '\0')
+ {
+ tptr++;
+ }
+ n_str = tptr;
+
+ /*
+ * If no more entries, break out here
+ */
+ if (*n_str == '\0')
+ {
+ break;
+ }
+
+ /*
+ * Skip to the end of the separator, noting if we have a
+ * comma.
+ */
+ has_comma = false;
+ while (is_space(*tptr) || *tptr == ',')
+ {
+ if (*tptr == ',')
+ {
+ if (!has_comma)
+ {
+ has_comma = true;
+ }
+ else
+ {
+ break;
+ }
+ }
+ tptr++;
+ }
+ /*
+ * If this was trailing whitespace we skipped, we are done.
+ */
+ if ((*tptr == '\0') && !has_comma)
+ {
+ break;
+ }
+ /*
+ * Else if the separator is all whitespace, and this is not the
+ * end of the string, add a comma to the separator.
+ */
+ else if (!has_comma)
+ {
+ *n_str = ',';
+ }
+
+ /*
+ * count the entry skipped.
+ */
+ cnt++;
+
+ n_str = tptr;
+ }
+ /*
+ * count the last entry in the list.
+ */
+ cnt++;
+
+ /*
+ * Allocate space for the coordinate array.
+ */
+ UniquePtr<nscoord[]> value_list = MakeUnique<nscoord[]>(cnt);
+ if (!value_list)
+ {
+ free(cp);
+ return;
+ }
+
+ /*
+ * Second pass to copy integer values into list.
+ */
+ tptr = cp;
+ for (i=0; i<cnt; i++)
+ {
+ char *ptr;
+
+ ptr = strchr(tptr, ',');
+ if (ptr)
+ {
+ *ptr = '\0';
+ }
+ /*
+ * Strip whitespace in front of number because I don't
+ * trust atoi to do it on all platforms.
+ */
+ while (is_space(*tptr))
+ {
+ tptr++;
+ }
+ if (*tptr == '\0')
+ {
+ value_list[i] = 0;
+ }
+ else
+ {
+ value_list[i] = (nscoord) ::atoi(tptr);
+ }
+ if (ptr)
+ {
+ *ptr = ',';
+ tptr = ptr + 1;
+ }
+ }
+
+ mNumCoords = cnt;
+ mCoords = Move(value_list);
+
+ free(cp);
+ }
+}
+
+void Area::HasFocus(bool aHasFocus)
+{
+ mHasFocus = aHasFocus;
+}
+
+//----------------------------------------------------------------------
+
+class DefaultArea : public Area {
+public:
+ explicit DefaultArea(nsIContent* aArea);
+
+ virtual bool IsInside(nscoord x, nscoord y) const override;
+ virtual void Draw(nsIFrame* aFrame, DrawTarget& aDrawTarget,
+ const ColorPattern& aColor,
+ const StrokeOptions& aStrokeOptions) override;
+ virtual void GetRect(nsIFrame* aFrame, nsRect& aRect) override;
+};
+
+DefaultArea::DefaultArea(nsIContent* aArea)
+ : Area(aArea)
+{
+}
+
+bool DefaultArea::IsInside(nscoord x, nscoord y) const
+{
+ return true;
+}
+
+void DefaultArea::Draw(nsIFrame* aFrame, DrawTarget& aDrawTarget,
+ const ColorPattern& aColor,
+ const StrokeOptions& aStrokeOptions)
+{
+ if (mHasFocus) {
+ nsRect r(nsPoint(0, 0), aFrame->GetSize());
+ const nscoord kOnePixel = nsPresContext::CSSPixelsToAppUnits(1);
+ r.width -= kOnePixel;
+ r.height -= kOnePixel;
+ Rect rect =
+ ToRect(nsLayoutUtils::RectToGfxRect(r, aFrame->PresContext()->AppUnitsPerDevPixel()));
+ StrokeSnappedEdgesOfRect(rect, aDrawTarget, aColor, aStrokeOptions);
+ }
+}
+
+void DefaultArea::GetRect(nsIFrame* aFrame, nsRect& aRect)
+{
+ aRect = aFrame->GetRect();
+ aRect.MoveTo(0, 0);
+}
+
+//----------------------------------------------------------------------
+
+class RectArea : public Area {
+public:
+ explicit RectArea(nsIContent* aArea);
+
+ virtual void ParseCoords(const nsAString& aSpec) override;
+ virtual bool IsInside(nscoord x, nscoord y) const override;
+ virtual void Draw(nsIFrame* aFrame, DrawTarget& aDrawTarget,
+ const ColorPattern& aColor,
+ const StrokeOptions& aStrokeOptions) override;
+ virtual void GetRect(nsIFrame* aFrame, nsRect& aRect) override;
+};
+
+RectArea::RectArea(nsIContent* aArea)
+ : Area(aArea)
+{
+}
+
+void RectArea::ParseCoords(const nsAString& aSpec)
+{
+ Area::ParseCoords(aSpec);
+
+ bool saneRect = true;
+ int32_t flag = nsIScriptError::warningFlag;
+ if (mNumCoords >= 4) {
+ if (mCoords[0] > mCoords[2]) {
+ // x-coords in reversed order
+ nscoord x = mCoords[2];
+ mCoords[2] = mCoords[0];
+ mCoords[0] = x;
+ saneRect = false;
+ }
+
+ if (mCoords[1] > mCoords[3]) {
+ // y-coords in reversed order
+ nscoord y = mCoords[3];
+ mCoords[3] = mCoords[1];
+ mCoords[1] = y;
+ saneRect = false;
+ }
+
+ if (mNumCoords > 4) {
+ // Someone missed the concept of a rect here
+ saneRect = false;
+ }
+ } else {
+ saneRect = false;
+ flag = nsIScriptError::errorFlag;
+ }
+
+ if (!saneRect) {
+ logMessage(mArea, aSpec, flag, "ImageMapRectBoundsError");
+ }
+}
+
+bool RectArea::IsInside(nscoord x, nscoord y) const
+{
+ if (mNumCoords >= 4) { // Note: > is for nav compatibility
+ nscoord x1 = mCoords[0];
+ nscoord y1 = mCoords[1];
+ nscoord x2 = mCoords[2];
+ nscoord y2 = mCoords[3];
+ NS_ASSERTION(x1 <= x2 && y1 <= y2,
+ "Someone screwed up RectArea::ParseCoords");
+ if ((x >= x1) && (x <= x2) && (y >= y1) && (y <= y2)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+void RectArea::Draw(nsIFrame* aFrame, DrawTarget& aDrawTarget,
+ const ColorPattern& aColor,
+ const StrokeOptions& aStrokeOptions)
+{
+ if (mHasFocus) {
+ if (mNumCoords >= 4) {
+ nscoord x1 = nsPresContext::CSSPixelsToAppUnits(mCoords[0]);
+ nscoord y1 = nsPresContext::CSSPixelsToAppUnits(mCoords[1]);
+ nscoord x2 = nsPresContext::CSSPixelsToAppUnits(mCoords[2]);
+ nscoord y2 = nsPresContext::CSSPixelsToAppUnits(mCoords[3]);
+ NS_ASSERTION(x1 <= x2 && y1 <= y2,
+ "Someone screwed up RectArea::ParseCoords");
+ nsRect r(x1, y1, x2 - x1, y2 - y1);
+ Rect rect =
+ ToRect(nsLayoutUtils::RectToGfxRect(r, aFrame->PresContext()->AppUnitsPerDevPixel()));
+ StrokeSnappedEdgesOfRect(rect, aDrawTarget, aColor, aStrokeOptions);
+ }
+ }
+}
+
+void RectArea::GetRect(nsIFrame* aFrame, nsRect& aRect)
+{
+ if (mNumCoords >= 4) {
+ nscoord x1 = nsPresContext::CSSPixelsToAppUnits(mCoords[0]);
+ nscoord y1 = nsPresContext::CSSPixelsToAppUnits(mCoords[1]);
+ nscoord x2 = nsPresContext::CSSPixelsToAppUnits(mCoords[2]);
+ nscoord y2 = nsPresContext::CSSPixelsToAppUnits(mCoords[3]);
+ NS_ASSERTION(x1 <= x2 && y1 <= y2,
+ "Someone screwed up RectArea::ParseCoords");
+
+ aRect.SetRect(x1, y1, x2, y2);
+ }
+}
+
+//----------------------------------------------------------------------
+
+class PolyArea : public Area {
+public:
+ explicit PolyArea(nsIContent* aArea);
+
+ virtual void ParseCoords(const nsAString& aSpec) override;
+ virtual bool IsInside(nscoord x, nscoord y) const override;
+ virtual void Draw(nsIFrame* aFrame, DrawTarget& aDrawTarget,
+ const ColorPattern& aColor,
+ const StrokeOptions& aStrokeOptions) override;
+ virtual void GetRect(nsIFrame* aFrame, nsRect& aRect) override;
+};
+
+PolyArea::PolyArea(nsIContent* aArea)
+ : Area(aArea)
+{
+}
+
+void PolyArea::ParseCoords(const nsAString& aSpec)
+{
+ Area::ParseCoords(aSpec);
+
+ if (mNumCoords >= 2) {
+ if (mNumCoords & 1U) {
+ logMessage(mArea,
+ aSpec,
+ nsIScriptError::warningFlag,
+ "ImageMapPolyOddNumberOfCoords");
+ }
+ } else {
+ logMessage(mArea,
+ aSpec,
+ nsIScriptError::errorFlag,
+ "ImageMapPolyWrongNumberOfCoords");
+ }
+}
+
+bool PolyArea::IsInside(nscoord x, nscoord y) const
+{
+ if (mNumCoords >= 6) {
+ int32_t intersects = 0;
+ nscoord wherex = x;
+ nscoord wherey = y;
+ int32_t totalv = mNumCoords / 2;
+ int32_t totalc = totalv * 2;
+ nscoord xval = mCoords[totalc - 2];
+ nscoord yval = mCoords[totalc - 1];
+ int32_t end = totalc;
+ int32_t pointer = 1;
+
+ if ((yval >= wherey) != (mCoords[pointer] >= wherey)) {
+ if ((xval >= wherex) == (mCoords[0] >= wherex)) {
+ intersects += (xval >= wherex) ? 1 : 0;
+ } else {
+ intersects += ((xval - (yval - wherey) *
+ (mCoords[0] - xval) /
+ (mCoords[pointer] - yval)) >= wherex) ? 1 : 0;
+ }
+ }
+
+ // XXX I wonder what this is doing; this is a translation of ptinpoly.c
+ while (pointer < end) {
+ yval = mCoords[pointer];
+ pointer += 2;
+ if (yval >= wherey) {
+ while((pointer < end) && (mCoords[pointer] >= wherey))
+ pointer+=2;
+ if (pointer >= end)
+ break;
+ if ((mCoords[pointer-3] >= wherex) ==
+ (mCoords[pointer-1] >= wherex)) {
+ intersects += (mCoords[pointer-3] >= wherex) ? 1 : 0;
+ } else {
+ intersects +=
+ ((mCoords[pointer-3] - (mCoords[pointer-2] - wherey) *
+ (mCoords[pointer-1] - mCoords[pointer-3]) /
+ (mCoords[pointer] - mCoords[pointer - 2])) >= wherex) ? 1:0;
+ }
+ } else {
+ while((pointer < end) && (mCoords[pointer] < wherey))
+ pointer+=2;
+ if (pointer >= end)
+ break;
+ if ((mCoords[pointer-3] >= wherex) ==
+ (mCoords[pointer-1] >= wherex)) {
+ intersects += (mCoords[pointer-3] >= wherex) ? 1:0;
+ } else {
+ intersects +=
+ ((mCoords[pointer-3] - (mCoords[pointer-2] - wherey) *
+ (mCoords[pointer-1] - mCoords[pointer-3]) /
+ (mCoords[pointer] - mCoords[pointer - 2])) >= wherex) ? 1:0;
+ }
+ }
+ }
+ if ((intersects & 1) != 0) {
+ return true;
+ }
+ }
+ return false;
+}
+
+void PolyArea::Draw(nsIFrame* aFrame, DrawTarget& aDrawTarget,
+ const ColorPattern& aColor,
+ const StrokeOptions& aStrokeOptions)
+{
+ if (mHasFocus) {
+ if (mNumCoords >= 6) {
+ // Where possible, we want all horizontal and vertical lines to align on
+ // pixel rows or columns, and to start at pixel boundaries so that one
+ // pixel dashing neatly sits on pixels to give us neat lines. To achieve
+ // that we draw each line segment as a separate path, snapping it to
+ // device pixels if applicable.
+ nsPresContext* pc = aFrame->PresContext();
+ Point p1(pc->CSSPixelsToDevPixels(mCoords[0]),
+ pc->CSSPixelsToDevPixels(mCoords[1]));
+ Point p2, p1snapped, p2snapped;
+ for (int32_t i = 2; i < mNumCoords; i += 2) {
+ p2.x = pc->CSSPixelsToDevPixels(mCoords[i]);
+ p2.y = pc->CSSPixelsToDevPixels(mCoords[i+1]);
+ p1snapped = p1;
+ p2snapped = p2;
+ SnapLineToDevicePixelsForStroking(p1snapped, p2snapped, aDrawTarget,
+ aStrokeOptions.mLineWidth);
+ aDrawTarget.StrokeLine(p1snapped, p2snapped, aColor, aStrokeOptions);
+ p1 = p2;
+ }
+ p2.x = pc->CSSPixelsToDevPixels(mCoords[0]);
+ p2.y = pc->CSSPixelsToDevPixels(mCoords[1]);
+ p1snapped = p1;
+ p2snapped = p2;
+ SnapLineToDevicePixelsForStroking(p1snapped, p2snapped, aDrawTarget,
+ aStrokeOptions.mLineWidth);
+ aDrawTarget.StrokeLine(p1snapped, p2snapped, aColor, aStrokeOptions);
+ }
+ }
+}
+
+void PolyArea::GetRect(nsIFrame* aFrame, nsRect& aRect)
+{
+ if (mNumCoords >= 6) {
+ nscoord x1, x2, y1, y2, xtmp, ytmp;
+ x1 = x2 = nsPresContext::CSSPixelsToAppUnits(mCoords[0]);
+ y1 = y2 = nsPresContext::CSSPixelsToAppUnits(mCoords[1]);
+ for (int32_t i = 2; i < mNumCoords; i += 2) {
+ xtmp = nsPresContext::CSSPixelsToAppUnits(mCoords[i]);
+ ytmp = nsPresContext::CSSPixelsToAppUnits(mCoords[i+1]);
+ x1 = x1 < xtmp ? x1 : xtmp;
+ y1 = y1 < ytmp ? y1 : ytmp;
+ x2 = x2 > xtmp ? x2 : xtmp;
+ y2 = y2 > ytmp ? y2 : ytmp;
+ }
+
+ aRect.SetRect(x1, y1, x2, y2);
+ }
+}
+
+//----------------------------------------------------------------------
+
+class CircleArea : public Area {
+public:
+ explicit CircleArea(nsIContent* aArea);
+
+ virtual void ParseCoords(const nsAString& aSpec) override;
+ virtual bool IsInside(nscoord x, nscoord y) const override;
+ virtual void Draw(nsIFrame* aFrame, DrawTarget& aDrawTarget,
+ const ColorPattern& aColor,
+ const StrokeOptions& aStrokeOptions) override;
+ virtual void GetRect(nsIFrame* aFrame, nsRect& aRect) override;
+};
+
+CircleArea::CircleArea(nsIContent* aArea)
+ : Area(aArea)
+{
+}
+
+void CircleArea::ParseCoords(const nsAString& aSpec)
+{
+ Area::ParseCoords(aSpec);
+
+ bool wrongNumberOfCoords = false;
+ int32_t flag = nsIScriptError::warningFlag;
+ if (mNumCoords >= 3) {
+ if (mCoords[2] < 0) {
+ logMessage(mArea,
+ aSpec,
+ nsIScriptError::errorFlag,
+ "ImageMapCircleNegativeRadius");
+ }
+
+ if (mNumCoords > 3) {
+ wrongNumberOfCoords = true;
+ }
+ } else {
+ wrongNumberOfCoords = true;
+ flag = nsIScriptError::errorFlag;
+ }
+
+ if (wrongNumberOfCoords) {
+ logMessage(mArea,
+ aSpec,
+ flag,
+ "ImageMapCircleWrongNumberOfCoords");
+ }
+}
+
+bool CircleArea::IsInside(nscoord x, nscoord y) const
+{
+ // Note: > is for nav compatibility
+ if (mNumCoords >= 3) {
+ nscoord x1 = mCoords[0];
+ nscoord y1 = mCoords[1];
+ nscoord radius = mCoords[2];
+ if (radius < 0) {
+ return false;
+ }
+ nscoord dx = x1 - x;
+ nscoord dy = y1 - y;
+ nscoord dist = (dx * dx) + (dy * dy);
+ if (dist <= (radius * radius)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+void CircleArea::Draw(nsIFrame* aFrame, DrawTarget& aDrawTarget,
+ const ColorPattern& aColor,
+ const StrokeOptions& aStrokeOptions)
+{
+ if (mHasFocus) {
+ if (mNumCoords >= 3) {
+ Point center(aFrame->PresContext()->CSSPixelsToDevPixels(mCoords[0]),
+ aFrame->PresContext()->CSSPixelsToDevPixels(mCoords[1]));
+ Float diameter =
+ 2 * aFrame->PresContext()->CSSPixelsToDevPixels(mCoords[2]);
+ if (diameter <= 0) {
+ return;
+ }
+ RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder();
+ AppendEllipseToPath(builder, center, Size(diameter, diameter));
+ RefPtr<Path> circle = builder->Finish();
+ aDrawTarget.Stroke(circle, aColor, aStrokeOptions);
+ }
+ }
+}
+
+void CircleArea::GetRect(nsIFrame* aFrame, nsRect& aRect)
+{
+ if (mNumCoords >= 3) {
+ nscoord x1 = nsPresContext::CSSPixelsToAppUnits(mCoords[0]);
+ nscoord y1 = nsPresContext::CSSPixelsToAppUnits(mCoords[1]);
+ nscoord radius = nsPresContext::CSSPixelsToAppUnits(mCoords[2]);
+ if (radius < 0) {
+ return;
+ }
+
+ aRect.SetRect(x1 - radius, y1 - radius, x1 + radius, y1 + radius);
+ }
+}
+
+//----------------------------------------------------------------------
+
+
+nsImageMap::nsImageMap() :
+ mImageFrame(nullptr),
+ mContainsBlockContents(false)
+{
+}
+
+nsImageMap::~nsImageMap()
+{
+ NS_ASSERTION(mAreas.Length() == 0, "Destroy was not called");
+}
+
+NS_IMPL_ISUPPORTS(nsImageMap,
+ nsIMutationObserver,
+ nsIDOMEventListener)
+
+nsresult
+nsImageMap::GetBoundsForAreaContent(nsIContent *aContent,
+ nsRect& aBounds)
+{
+ NS_ENSURE_TRUE(aContent && mImageFrame, NS_ERROR_INVALID_ARG);
+
+ // Find the Area struct associated with this content node, and return bounds
+ uint32_t i, n = mAreas.Length();
+ for (i = 0; i < n; i++) {
+ Area* area = mAreas.ElementAt(i);
+ if (area->mArea == aContent) {
+ aBounds = nsRect();
+ area->GetRect(mImageFrame, aBounds);
+ return NS_OK;
+ }
+ }
+ return NS_ERROR_FAILURE;
+}
+
+void
+nsImageMap::FreeAreas()
+{
+ uint32_t i, n = mAreas.Length();
+ for (i = 0; i < n; i++) {
+ Area* area = mAreas.ElementAt(i);
+ if (area->mArea->IsInUncomposedDoc()) {
+ NS_ASSERTION(area->mArea->GetPrimaryFrame() == mImageFrame,
+ "Unexpected primary frame");
+
+ area->mArea->SetPrimaryFrame(nullptr);
+ }
+
+ area->mArea->RemoveSystemEventListener(NS_LITERAL_STRING("focus"), this,
+ false);
+ area->mArea->RemoveSystemEventListener(NS_LITERAL_STRING("blur"), this,
+ false);
+ delete area;
+ }
+ mAreas.Clear();
+}
+
+nsresult
+nsImageMap::Init(nsImageFrame* aImageFrame, nsIContent* aMap)
+{
+ NS_PRECONDITION(aMap, "null ptr");
+ if (!aMap) {
+ return NS_ERROR_NULL_POINTER;
+ }
+ mImageFrame = aImageFrame;
+
+ mMap = aMap;
+ mMap->AddMutationObserver(this);
+
+ // "Compile" the areas in the map into faster access versions
+ return UpdateAreas();
+}
+
+
+nsresult
+nsImageMap::SearchForAreas(nsIContent* aParent, bool& aFoundArea,
+ bool& aFoundAnchor)
+{
+ nsresult rv = NS_OK;
+ uint32_t i, n = aParent->GetChildCount();
+
+ // Look for <area> or <a> elements. We'll use whichever type we find first.
+ for (i = 0; i < n; i++) {
+ nsIContent *child = aParent->GetChildAt(i);
+
+ // If we haven't determined that the map element contains an
+ // <a> element yet, then look for <area>.
+ if (!aFoundAnchor && child->IsHTMLElement(nsGkAtoms::area)) {
+ aFoundArea = true;
+ rv = AddArea(child);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Continue to next child. This stops mContainsBlockContents from
+ // getting set. It also makes us ignore children of <area>s which
+ // is consistent with how we react to dynamic insertion of such
+ // children.
+ continue;
+ }
+
+ // If we haven't determined that the map element contains an
+ // <area> element yet, then look for <a>.
+ if (!aFoundArea && child->IsHTMLElement(nsGkAtoms::a)) {
+ aFoundAnchor = true;
+ rv = AddArea(child);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ if (child->IsElement()) {
+ mContainsBlockContents = true;
+ rv = SearchForAreas(child, aFoundArea, aFoundAnchor);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult
+nsImageMap::UpdateAreas()
+{
+ // Get rid of old area data
+ FreeAreas();
+
+ bool foundArea = false;
+ bool foundAnchor = false;
+ mContainsBlockContents = false;
+
+ nsresult rv = SearchForAreas(mMap, foundArea, foundAnchor);
+#ifdef ACCESSIBILITY
+ if (NS_SUCCEEDED(rv)) {
+ nsAccessibilityService* accService = GetAccService();
+ if (accService) {
+ accService->UpdateImageMap(mImageFrame);
+ }
+ }
+#endif
+ return rv;
+}
+
+nsresult
+nsImageMap::AddArea(nsIContent* aArea)
+{
+ static nsIContent::AttrValuesArray strings[] =
+ {&nsGkAtoms::rect, &nsGkAtoms::rectangle,
+ &nsGkAtoms::circle, &nsGkAtoms::circ,
+ &nsGkAtoms::_default,
+ &nsGkAtoms::poly, &nsGkAtoms::polygon,
+ nullptr};
+
+ Area* area;
+ switch (aArea->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::shape,
+ strings, eIgnoreCase)) {
+ case nsIContent::ATTR_VALUE_NO_MATCH:
+ case nsIContent::ATTR_MISSING:
+ case 0:
+ case 1:
+ area = new RectArea(aArea);
+ break;
+ case 2:
+ case 3:
+ area = new CircleArea(aArea);
+ break;
+ case 4:
+ area = new DefaultArea(aArea);
+ break;
+ case 5:
+ case 6:
+ area = new PolyArea(aArea);
+ break;
+ default:
+ area = nullptr;
+ NS_NOTREACHED("FindAttrValueIn returned an unexpected value.");
+ break;
+ }
+ if (!area)
+ return NS_ERROR_OUT_OF_MEMORY;
+
+ //Add focus listener to track area focus changes
+ aArea->AddSystemEventListener(NS_LITERAL_STRING("focus"), this, false,
+ false);
+ aArea->AddSystemEventListener(NS_LITERAL_STRING("blur"), this, false,
+ false);
+
+ // This is a nasty hack. It needs to go away: see bug 135040. Once this is
+ // removed, the code added to RestyleManager::RestyleElement,
+ // nsCSSFrameConstructor::ContentRemoved (both hacks there), and
+ // RestyleManager::ProcessRestyledFrames to work around this issue can
+ // be removed.
+ aArea->SetPrimaryFrame(mImageFrame);
+
+ nsAutoString coords;
+ aArea->GetAttr(kNameSpaceID_None, nsGkAtoms::coords, coords);
+ area->ParseCoords(coords);
+ mAreas.AppendElement(area);
+ return NS_OK;
+}
+
+nsIContent*
+nsImageMap::GetArea(nscoord aX, nscoord aY) const
+{
+ NS_ASSERTION(mMap, "Not initialized");
+ uint32_t i, n = mAreas.Length();
+ for (i = 0; i < n; i++) {
+ Area* area = mAreas.ElementAt(i);
+ if (area->IsInside(aX, aY)) {
+ return area->mArea;
+ }
+ }
+
+ return nullptr;
+}
+
+nsIContent*
+nsImageMap::GetAreaAt(uint32_t aIndex) const
+{
+ return mAreas.ElementAt(aIndex)->mArea;
+}
+
+void
+nsImageMap::Draw(nsIFrame* aFrame, DrawTarget& aDrawTarget,
+ const ColorPattern& aColor,
+ const StrokeOptions& aStrokeOptions)
+{
+ uint32_t i, n = mAreas.Length();
+ for (i = 0; i < n; i++) {
+ Area* area = mAreas.ElementAt(i);
+ area->Draw(aFrame, aDrawTarget, aColor, aStrokeOptions);
+ }
+}
+
+void
+nsImageMap::MaybeUpdateAreas(nsIContent *aContent)
+{
+ if (aContent == mMap || mContainsBlockContents) {
+ UpdateAreas();
+ }
+}
+
+void
+nsImageMap::AttributeChanged(nsIDocument* aDocument,
+ dom::Element* aElement,
+ int32_t aNameSpaceID,
+ nsIAtom* aAttribute,
+ int32_t aModType,
+ const nsAttrValue* aOldValue)
+{
+ // If the parent of the changing content node is our map then update
+ // the map. But only do this if the node is an HTML <area> or <a>
+ // and the attribute that's changing is "shape" or "coords" -- those
+ // are the only cases we care about.
+ if ((aElement->NodeInfo()->Equals(nsGkAtoms::area) ||
+ aElement->NodeInfo()->Equals(nsGkAtoms::a)) &&
+ aElement->IsHTMLElement() &&
+ aNameSpaceID == kNameSpaceID_None &&
+ (aAttribute == nsGkAtoms::shape ||
+ aAttribute == nsGkAtoms::coords)) {
+ MaybeUpdateAreas(aElement->GetParent());
+ } else if (aElement == mMap &&
+ aNameSpaceID == kNameSpaceID_None &&
+ (aAttribute == nsGkAtoms::name ||
+ aAttribute == nsGkAtoms::id) &&
+ mImageFrame) {
+ // ID or name has changed. Let ImageFrame recreate ImageMap.
+ mImageFrame->DisconnectMap();
+ }
+}
+
+void
+nsImageMap::ContentAppended(nsIDocument *aDocument,
+ nsIContent* aContainer,
+ nsIContent* aFirstNewContent,
+ int32_t /* unused */)
+{
+ MaybeUpdateAreas(aContainer);
+}
+
+void
+nsImageMap::ContentInserted(nsIDocument *aDocument,
+ nsIContent* aContainer,
+ nsIContent* aChild,
+ int32_t /* unused */)
+{
+ MaybeUpdateAreas(aContainer);
+}
+
+void
+nsImageMap::ContentRemoved(nsIDocument *aDocument,
+ nsIContent* aContainer,
+ nsIContent* aChild,
+ int32_t aIndexInContainer,
+ nsIContent* aPreviousSibling)
+{
+ MaybeUpdateAreas(aContainer);
+}
+
+void
+nsImageMap::ParentChainChanged(nsIContent* aContent)
+{
+ NS_ASSERTION(aContent == mMap,
+ "Unexpected ParentChainChanged notification!");
+ if (mImageFrame) {
+ mImageFrame->DisconnectMap();
+ }
+}
+
+nsresult
+nsImageMap::HandleEvent(nsIDOMEvent* aEvent)
+{
+ nsAutoString eventType;
+ aEvent->GetType(eventType);
+ bool focus = eventType.EqualsLiteral("focus");
+ MOZ_ASSERT(focus == !eventType.EqualsLiteral("blur"),
+ "Unexpected event type");
+
+ //Set which one of our areas changed focus
+ nsCOMPtr<nsIContent> targetContent = do_QueryInterface(
+ aEvent->InternalDOMEvent()->GetTarget());
+ if (!targetContent) {
+ return NS_OK;
+ }
+ uint32_t i, n = mAreas.Length();
+ for (i = 0; i < n; i++) {
+ Area* area = mAreas.ElementAt(i);
+ if (area->mArea == targetContent) {
+ //Set or Remove internal focus
+ area->HasFocus(focus);
+ //Now invalidate the rect
+ if (mImageFrame) {
+ mImageFrame->InvalidateFrame();
+ }
+ break;
+ }
+ }
+ return NS_OK;
+}
+
+void
+nsImageMap::Destroy(void)
+{
+ FreeAreas();
+ mImageFrame = nullptr;
+ mMap->RemoveMutationObserver(this);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-19 04:15:10 +0000