Attachment #807614 for bug #918189

Attachment #807614: Part 1: Implement Node.convertPoint/Rect/QuadFromNode for bug #918189

View | Details | Raw Unified | Return to bug 918189
Collapse All | Expand All





}
inline bool IsSpaceCharacter(char aChar) {
  return aChar == ' ' || aChar == '\t' || aChar == '\n' || aChar == '\r' ||
         aChar == '\f';
}
class Element;
class EventHandlerNonNull;
class OnErrorEventHandlerNonNull;
class DOMPoint;
class DOMRect;
class DOMQuad;
struct BoxQuadOptions;
struct ConvertPointOptions;
template<typename T> class Optional;
} // namespace dom
} // namespace mozilla

#define NODE_FLAG_BIT(n_) (1U << (WRAPPER_CACHE_FLAGS_BITS_USED + (n_)))

enum {
  // This bit will be set if the node has a listener manager.

 * An internal interface that abstracts some DOMNode-related parts that both
 * nsIContent and nsIDocument share.  An instance of this interface has a list
 * of nsIContent children and provides access to them.
 */
class nsINode : public mozilla::dom::EventTarget
{
public:
  typedef mozilla::dom::BoxQuadOptions BoxQuadOptions;
  typedef mozilla::dom::ConvertPointOptions ConvertPointOptions;
  typedef mozilla::dom::DOMRect DOMRect;
  typedef mozilla::dom::DOMPoint DOMPoint;
  typedef mozilla::dom::DOMQuad DOMQuad;

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_INODE_IID)

  // Among the sub-classes that inherit (directly or indirectly) from nsINode,
  // measurement of the following members may be added later if DMD finds it is
  // worthwhile:
  // - nsGenericHTMLElement:  mForm, mFieldSet

  // ParentNode methods
  mozilla::dom::Element* GetFirstElementChild() const;
  mozilla::dom::Element* GetLastElementChild() const;


  void GetBoxQuads(const BoxQuadOptions& aOptions,
                   nsTArray<nsRefPtr<DOMQuad> >& aResult,
                   mozilla::ErrorResult& aRv);
  already_AddRefed<DOMPoint> ConvertPointFromNode(const DOMPoint& aPoint,
                                                  nsINode& aFrom,
                                                  const ConvertPointOptions& aOptions,
                                                  mozilla::ErrorResult& aRv);
  already_AddRefed<DOMQuad> ConvertRectFromNode(const DOMRect& aRect,
                                                nsINode& aFrom,
                                                const ConvertPointOptions& aOptions,
                                                mozilla::ErrorResult& aRv);
  already_AddRefed<DOMQuad> ConvertQuadFromNode(const DOMQuad& aQuad,
                                                nsINode& aFrom,
                                                const ConvertPointOptions& aOptions,
                                                mozilla::ErrorResult& aRv);

protected:

  // Override this function to create a custom slots class.
  // Must not return null.
  virtual nsINode::nsSlots* CreateSlots();

  bool HasSlots() const





#include "HTMLLegendElement.h"
#include "nsWrapperCacheInlines.h"
#include "WrapperFactory.h"
#include "DocumentType.h"
#include <algorithm>
#include "nsDOMEvent.h"
#include "nsGlobalWindow.h"
#include "nsDOMMutationObserver.h"
#include "mozilla/dom/DOMPoint.h"
#include "mozilla/dom/DOMRect.h"
#include "mozilla/dom/DOMQuad.h"
#include "mozilla/CoordinateTransformations.h"

using namespace mozilla;
using namespace mozilla::dom;

nsINode::nsSlots::~nsSlots()
{

                     ErrorResult& aRv)
{
  nsAutoTArray<Quad2D,1> quads;
  mozilla::GetBoxQuads(this, aOptions, quads, aRv);
  for (uint32_t i = 0; i < quads.Length(); ++i) {
    aResult.AppendElement(new DOMQuad(OwnerDoc(), quads[i].mPoints));
  }
}

already_AddRefed<DOMPoint>
nsINode::ConvertPointFromNode(const DOMPoint& aPoint,
                              nsINode& aFrom,
                              const ConvertPointOptions& aOptions,
                              ErrorResult& aRv)
{
  gfxPoint pt(aPoint.X(), aPoint.Y());
  TransformCSSPoints(this, &aFrom, 1, &pt, aOptions, aRv);
  nsRefPtr<DOMPoint> result = new DOMPoint(OwnerDoc(), pt.x, pt.y);
  return result.forget();
}

already_AddRefed<DOMQuad>
nsINode::ConvertRectFromNode(const DOMRect& aRect,
                             nsINode& aFrom,
                             const ConvertPointOptions& aOptions,
                             ErrorResult& aRv)
{
  gfxPoint pts[4] = {
    gfxPoint(aRect.Left(), aRect.Top()),
    gfxPoint(aRect.Right(), aRect.Top()),
    gfxPoint(aRect.Right(), aRect.Bottom()),
    gfxPoint(aRect.Left(), aRect.Bottom())
  };
  TransformCSSPoints(this, &aFrom, 4, pts, aOptions, aRv);
  nsRefPtr<DOMQuad> result = new DOMQuad(OwnerDoc(), pts);
  return result.forget();
}

static gfxPoint
DOMPointToGfxPoint(DOMPoint* aPoint)
{
  MOZ_ASSERT(aPoint->W() == 0.0, "W not supported");
  return gfxPoint(aPoint->X(), aPoint->Y());
}

already_AddRefed<DOMQuad>
nsINode::ConvertQuadFromNode(const DOMQuad& aQuad,
                             nsINode& aFrom,
                             const ConvertPointOptions& aOptions,
                             ErrorResult& aRv)
{
  gfxPoint pts[4] = {
    DOMPointToGfxPoint(aQuad.P1()),
    DOMPointToGfxPoint(aQuad.P2()),
    DOMPointToGfxPoint(aQuad.P3()),
    DOMPointToGfxPoint(aQuad.P4())
  };
  TransformCSSPoints(this, &aFrom, 4, pts, aOptions, aRv);
  nsRefPtr<DOMQuad> result = new DOMQuad(OwnerDoc(), pts);
  return result.forget();
}

(-)a/dom/webidl/Node.webidl (+11 lines)

Line	Link Here

Lines 111-122 interface Node : EventTarget {	Link Here

111

enum BoxType { "content", "padding", "border", "margin" };

111

enum BoxType { "content", "padding", "border", "margin" };

112

113

dictionary BoxQuadOptions {

113

dictionary BoxQuadOptions {

114

  BoxType box = "border";

114

  BoxType box = "border";

115

  Node? relativeTo = null;

115

  Node? relativeTo = null;

116

  BoxType relativeToBox = "border";

116

  BoxType relativeToBox = "border";

117

};

117

};

118

119

dictionary ConvertPointOptions {

120

  BoxType fromBox = "border";

121

  BoxType toBox = "border";

122

};

123

119

partial interface Node {

124

partial interface Node {

120

  [Throws]

125

  [Throws]

121

  sequence<DOMQuad> getBoxQuads(optional BoxQuadOptions options);

126

  sequence<DOMQuad> getBoxQuads(optional BoxQuadOptions options);

127

  [Throws]

128

  DOMPoint convertPointFromNode(DOMPoint point, Node fromNode, optional ConvertPointOptions options);

129

  [Throws]

130

  DOMQuad convertRectFromNode(DOMRect rect, Node fromNode, optional ConvertPointOptions options);

131

  [Throws]

132

  DOMQuad convertQuadFromNode(DOMQuad quad, Node fromNode, optional ConvertPointOptions options);

122

};

133

};

-      Line
+  Link Here
-       Lines 183-191
      GetBoxQuads(nsINode* aNode, const BoxQua
+  Link Here
   // GetBoxRectForFrame can modify relativeToFrame so call it first.
   nsPoint relativeToTopLeft =
       GetBoxRectForFrame(&relativeToFrame, aOptions.mRelativeToBox).TopLeft();
   AccumulateQuadCallback callback(ownerDoc, aResult, relativeToFrame,
                                   relativeToTopLeft, aOptions.mBox);
   nsLayoutUtils::GetAllInFlowBoxes(frame, &callback);
+}
+void
+TransformCSSPoints(nsINode* aTo, nsINode* aFrom,
+                   uint32_t aPointCount, gfxPoint* aPoints,
+                   const ConvertPointOptions& aOptions, ErrorResult& aRv)
+{
+  nsIFrame* fromFrame = GetFirstNonAnonymousLayoutFrameForNode(aFrom, aRv);
+  nsIFrame* toFrame = GetFirstNonAnonymousLayoutFrameForNode(aTo, aRv);
+  if (fromFrame && toFrame) {
+    if (!CheckFramesInSameTopLevelBrowsingContext(fromFrame, toFrame, aRv)) {
+      return;
+    }
+    nsPoint fromOffset = GetBoxRectForFrame(&fromFrame, aOptions.mFromBox).TopLeft();
+    nsPoint toOffset = GetBoxRectForFrame(&toFrame, aOptions.mToBox).TopLeft();
+    gfxPoint fromOffsetGfx(nsPresContext::AppUnitsToFloatCSSPixels(fromOffset.x),
+                           nsPresContext::AppUnitsToFloatCSSPixels(fromOffset.y));
+    for (uint32_t i = 0; i < aPointCount; ++i) {
+      aPoints[i] += fromOffsetGfx;
+    }
+    nsLayoutUtils::TransformResult rv =
+      nsLayoutUtils::TransformCSSPoints(fromFrame, toFrame, aPointCount, aPoints);
+    if (rv == nsLayoutUtils::TRANSFORM_SUCCEEDED) {
+      gfxPoint toOffsetGfx(nsPresContext::AppUnitsToFloatCSSPixels(toOffset.x),
+                           nsPresContext::AppUnitsToFloatCSSPixels(toOffset.y));
+      for (uint32_t i = 0; i < aPointCount; ++i) {
+        aPoints[i] -= toOffsetGfx;
+      }
+      return;
+    }
+  }
+  for (uint32_t i = 0; i < aPointCount; ++i) {
+    aPoints[i] = gfxPoint(0.0, 0.0);
+  }
+}
+}





 */

class nsINode;

namespace mozilla {

namespace dom {
struct BoxQuadOptions;
struct ConvertPointOptions;
}

/**
 * Converts points from being relative to aTo to relative to aFrom, following
 * the rules for Node.convertPointFromNode. May set an error in aRv.
 */
void TransformCSSPoints(nsINode* aTo, nsINode* aFrom,
                        uint32_t aPointCount, gfxPoint* aPoints,
                        const dom::ConvertPointOptions& aOptions, ErrorResult& aRv);

struct Quad2D {
  gfxPoint mPoints[4];
};
/**
 * Computes quads for aNode using aOptions, according to Node.getBoxQuads.
 * May set an error in aRv.
 */
void GetBoxQuads(nsINode* aNode,

Return to bug 918189