Attachment #8356417 for bug #918189

Attachment #8356417: Part 1: Implement GeometryUtils.convertPointFromNode, convertRectFromNode, and convertQudFromNode918189-implement for bug #918189

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

(-)a/content/base/public/nsINode.h (-2 / +25 lines)

Line	Link Here

Lines 59-80 namespace dom {	Link Here

inline bool IsSpaceCharacter(PRUnichar aChar) {

inline bool IsSpaceCharacter(PRUnichar aChar) {

  return aChar == ' ' || aChar == '\t' || aChar == '\n' || aChar == '\r' ||

  return aChar == ' ' || aChar == '\t' || aChar == '\n' || aChar == '\r' ||

         aChar == '\f';

         aChar == '\f';

inline bool IsSpaceCharacter(char aChar) {

inline bool IsSpaceCharacter(char aChar) {

  return aChar == ' ' || aChar == '\t' || aChar == '\n' || aChar == '\r' ||

  return aChar == ' ' || aChar == '\t' || aChar == '\n' || aChar == '\r' ||

         aChar == '\f';

         aChar == '\f';

class BoxQuadOptions;

class ConvertCoordinateOptions;

class DOMPoint;

class DOMQuad;

class DOMRectReadOnly;

class Element;

class Element;

class BoxQuadOptions;

class DOMQuad;

class EventHandlerNonNull;

class EventHandlerNonNull;

class OnErrorEventHandlerNonNull;

class OnErrorEventHandlerNonNull;

template<typename T> class Optional;

template<typename T> class Optional;

class TextOrElementOrDocument;

struct DOMPointInit;

} // namespace dom

} // namespace dom

} // namespace mozilla

} // namespace mozilla

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

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

enum {

enum {

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

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

  NODE_HAS_LISTENERMANAGER =              NODE_FLAG_BIT(0),

  NODE_HAS_LISTENERMANAGER =              NODE_FLAG_BIT(0),

Lines 268-284 private:	Link Here

268

 * An internal interface that abstracts some DOMNode-related parts that both

273

 * An internal interface that abstracts some DOMNode-related parts that both

269

 * nsIContent and nsIDocument share.  An instance of this interface has a list

274

 * nsIContent and nsIDocument share.  An instance of this interface has a list

270

 * of nsIContent children and provides access to them.

275

 * of nsIContent children and provides access to them.

271

*/

276

*/

272

class nsINode : public mozilla::dom::EventTarget

277

class nsINode : public mozilla::dom::EventTarget

273

278

274

public:

279

public:

275

  typedef mozilla::dom::BoxQuadOptions BoxQuadOptions;

280

  typedef mozilla::dom::BoxQuadOptions BoxQuadOptions;

281

  typedef mozilla::dom::ConvertCoordinateOptions ConvertCoordinateOptions;

282

  typedef mozilla::dom::DOMPoint DOMPoint;

283

  typedef mozilla::dom::DOMPointInit DOMPointInit;

276

  typedef mozilla::dom::DOMQuad DOMQuad;

284

  typedef mozilla::dom::DOMQuad DOMQuad;

285

  typedef mozilla::dom::DOMRectReadOnly DOMRectReadOnly;

286

  typedef mozilla::dom::TextOrElementOrDocument TextOrElementOrDocument;

277

  typedef mozilla::ErrorResult ErrorResult;

287

  typedef mozilla::ErrorResult ErrorResult;

278

288

279

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_INODE_IID)

289

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_INODE_IID)

280

290

281

  // Among the sub-classes that inherit (directly or indirectly) from nsINode,

291

  // Among the sub-classes that inherit (directly or indirectly) from nsINode,

282

  // measurement of the following members may be added later if DMD finds it is

292

  // measurement of the following members may be added later if DMD finds it is

283

  // worthwhile:

293

  // worthwhile:

284

  // - nsGenericHTMLElement:  mForm, mFieldSet

294

  // - nsGenericHTMLElement:  mForm, mFieldSet

Lines 1606-1621 public:	Link Here

1606

  // ParentNode methods

1616

  // ParentNode methods

1607

  mozilla::dom::Element* GetFirstElementChild() const;

1617

  mozilla::dom::Element* GetFirstElementChild() const;

1608

  mozilla::dom::Element* GetLastElementChild() const;

1618

  mozilla::dom::Element* GetLastElementChild() const;

1609

1619

1610

  void GetBoxQuads(const BoxQuadOptions& aOptions,

1620

  void GetBoxQuads(const BoxQuadOptions& aOptions,

1611

                   nsTArray<nsRefPtr<DOMQuad> >& aResult,

1621

                   nsTArray<nsRefPtr<DOMQuad> >& aResult,

1612

                   mozilla::ErrorResult& aRv);

1622

                   mozilla::ErrorResult& aRv);

1613

1623

1624

  already_AddRefed<DOMQuad> ConvertQuadFromNode(DOMQuad& aQuad,

1625

                                                const TextOrElementOrDocument& aFrom,

1626

                                                const ConvertCoordinateOptions& aOptions,

1627

                                                ErrorResult& aRv);

1628

  already_AddRefed<DOMQuad> ConvertRectFromNode(DOMRectReadOnly& aRect,

1629

                                                const TextOrElementOrDocument& aFrom,

1630

                                                const ConvertCoordinateOptions& aOptions,

1631

                                                ErrorResult& aRv);

1632

  already_AddRefed<DOMPoint> ConvertPointFromNode(const DOMPointInit& aPoint,

1633

                                                  const TextOrElementOrDocument& aFrom,

1634

                                                  const ConvertCoordinateOptions& aOptions,

1635

                                                  ErrorResult& aRv);

1636

1614

protected:

1637

protected:

1615

1638

1616

  // Override this function to create a custom slots class.

1639

  // Override this function to create a custom slots class.

1617

  // Must not return null.

1640

  // Must not return null.

1618

  virtual nsINode::nsSlots* CreateSlots();

1641

  virtual nsINode::nsSlots* CreateSlots();

1619

1642

1620

  bool HasSlots() const

1643

  bool HasSlots() const

1621

1644





void
nsINode::GetBoxQuads(const BoxQuadOptions& aOptions,
                     nsTArray<nsRefPtr<DOMQuad> >& aResult,
                     mozilla::ErrorResult& aRv)
{
  mozilla::GetBoxQuads(this, aOptions, aResult, aRv);
}

already_AddRefed<DOMQuad>
nsINode::ConvertQuadFromNode(DOMQuad& aQuad,
                             const GeometryNode& aFrom,
                             const ConvertCoordinateOptions& aOptions,
                             ErrorResult& aRv)
{
  return mozilla::ConvertQuadFromNode(this, aQuad, aFrom, aOptions, aRv);
}

already_AddRefed<DOMQuad>
nsINode::ConvertRectFromNode(DOMRectReadOnly& aRect,
                             const GeometryNode& aFrom,
                             const ConvertCoordinateOptions& aOptions,
                             ErrorResult& aRv)
{
  return mozilla::ConvertRectFromNode(this, aRect, aFrom, aOptions, aRv);
}

already_AddRefed<DOMPoint>
nsINode::ConvertPointFromNode(const DOMPointInit& aPoint,
                              const GeometryNode& aFrom,
                              const ConvertCoordinateOptions& aOptions,
                              ErrorResult& aRv)
{
  return mozilla::ConvertPointFromNode(this, aPoint, aFrom, aOptions, aRv);
}

bool
EventTarget::DispatchEvent(nsDOMEvent& aEvent,
                           ErrorResult& aRv)
{
  bool result = false;
  aRv = DispatchEvent(&aEvent, &result);
  return result;
}





  CSSBoxType fromBox = "border";
  CSSBoxType toBox = "border";
};

[NoInterfaceObject]
interface GeometryUtils {
  [Throws, Pref="layout.css.getBoxQuads.enabled"]
  sequence<DOMQuad> getBoxQuads(optional BoxQuadOptions options);
  [Throws, Pref="layout.css.convertFromNode.enabled"]
  DOMQuad convertQuadFromNode(DOMQuad quad, GeometryNode from, optional ConvertCoordinateOptions options);
  [Throws, Pref="layout.css.convertFromNode.enabled"]
  DOMQuad convertRectFromNode(DOMRectReadOnly rect, GeometryNode from, optional ConvertCoordinateOptions options);
  [Throws, Pref="layout.css.convertFromNode.enabled"]
  DOMPoint convertPointFromNode(DOMPointInit point, GeometryNode from, optional ConvertCoordinateOptions options);
};

Text implements GeometryUtils;
Element implements GeometryUtils;
// PseudoElement implements GeometryUtils;
Document implements GeometryUtils;

typedef (Text or Element /* or PseudoElement */ or Document) GeometryNode;





*         int32_t aRightOffset           offset in aRightBlock to move content from
*/
nsresult
nsHTMLEditRules::MoveBlock(nsIDOMNode *aLeftBlock, nsIDOMNode *aRightBlock, int32_t aLeftOffset, int32_t aRightOffset)
{
  nsCOMArray<nsIDOMNode> arrayOfNodes;
  nsCOMPtr<nsISupports> isupports;
  // GetNodesFromPoint is the workhorse that figures out what we wnat to move.
  nsresult res = GetNodesFromPoint(::DOMPoint(aRightBlock,aRightOffset),
                                   EditAction::makeList, arrayOfNodes, true);
  NS_ENSURE_SUCCESS(res, res);
  int32_t listCount = arrayOfNodes.Count();
  int32_t i;
  for (i=0; i<listCount; i++)
  {
    // get the node to act on
    nsIDOMNode* curNode = arrayOfNodes[i];

}


///////////////////////////////////////////////////////////////////////////
// GetNodesFromPoint: given a particular operation, construct a list  
//                     of nodes from a point that will be operated on. 
//                       
nsresult 
nsHTMLEditRules::GetNodesFromPoint(::DOMPoint point,
                                   EditAction operation,
                                   nsCOMArray<nsIDOMNode> &arrayOfNodes,
                                   bool dontTouchContent)
{
  nsresult res;

  // get our point
  nsCOMPtr<nsIDOMNode> node;





/* -*- 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/. */

#include "GeometryUtils.h"

#include "mozilla/dom/DOMPointBinding.h"
#include "mozilla/dom/GeometryUtilsBinding.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/Text.h"
#include "mozilla/dom/DOMPoint.h"
#include "mozilla/dom/DOMQuad.h"
#include "mozilla/dom/DOMRect.h"
#include "nsIFrame.h"
#include "nsGenericDOMDataNode.h"
#include "nsCSSFrameConstructor.h"
#include "nsLayoutUtils.h"
#include "nsSVGUtils.h"

using namespace mozilla;
using namespace mozilla::dom;

namespace mozilla {

typedef OwningTextOrElementOrDocument GeometryNode;

enum GeometryNodeType {
  GEOMETRY_NODE_ELEMENT,
  GEOMETRY_NODE_TEXT,
  GEOMETRY_NODE_DOCUMENT
};

static nsIFrame*
GetFrameForNode(nsINode* aNode, GeometryNodeType aType)

  }
  default:
    MOZ_ASSERT(false, "Unknown GeometryNodeType");
    return nullptr;
  }
}

static nsIFrame*
GetFrameForGeometryNode(const Optional<OwningGeometryNode>& aGeometryNode,
                        nsINode* aDefaultNode)
{
  if (!aGeometryNode.WasPassed()) {
    return GetFrameForNode(aDefaultNode->OwnerDoc(), GEOMETRY_NODE_DOCUMENT);
  }

  const OwningGeometryNode& value = aGeometryNode.Value();
  if (value.IsElement()) {
    return GetFrameForNode(value.GetAsElement(), GEOMETRY_NODE_ELEMENT);
  }
  if (value.IsDocument()) {
    return GetFrameForNode(value.GetAsDocument(), GEOMETRY_NODE_DOCUMENT);
  }
  return GetFrameForNode(value.GetAsText(), GEOMETRY_NODE_TEXT);
}

static nsIFrame*
GetFrameForGeometryNode(const GeometryNode& aGeometryNode)
{
  if (aGeometryNode.IsElement()) {
    return GetFrameForNode(&aGeometryNode.GetAsElement(), GEOMETRY_NODE_ELEMENT);
  }
  if (aGeometryNode.IsDocument()) {
    return GetFrameForNode(&aGeometryNode.GetAsDocument(), GEOMETRY_NODE_DOCUMENT);
  }
  return GetFrameForNode(&aGeometryNode.GetAsText(), GEOMETRY_NODE_TEXT);
}

static nsIFrame*
GetFrameForNode(nsINode* aNode)
{
  if (aNode->IsElement()) {
    return GetFrameForNode(aNode, GEOMETRY_NODE_ELEMENT);
  }
  if (aNode == aNode->OwnerDoc()) {
    return GetFrameForNode(aNode, GEOMETRY_NODE_DOCUMENT);
  }
  NS_ASSERTION(aNode->IsNodeOfType(nsINode::eTEXT), "Unknown node type");
  return GetFrameForNode(aNode, GEOMETRY_NODE_TEXT);
}

static nsIFrame*
GetFirstNonAnonymousFrameForGeometryNode(const Optional<OwningGeometryNode>& aNode,
                                         nsINode* aDefaultNode)
{
  nsIFrame* f = GetFrameForGeometryNode(aNode, aDefaultNode);
  if (f) {
    f = nsLayoutUtils::GetFirstNonAnonymousFrame(f);
  }
  return f;
}

static nsIFrame*
GetFirstNonAnonymousFrameForGeometryNode(const GeometryNode& aNode)
{
  nsIFrame* f = GetFrameForGeometryNode(aNode);
  if (f) {
    f = nsLayoutUtils::GetFirstNonAnonymousFrame(f);
  }
  return f;
}

static nsIFrame*
GetFirstNonAnonymousFrameForNode(nsINode* aNode)
{
  nsIFrame* f = GetFrameForNode(aNode);
  if (f) {
    f = nsLayoutUtils::GetFirstNonAnonymousFrame(f);
  }
  return f;
}

/**
 * This can modify aFrame to point to a different frame. This is needed to
 * handle SVG, where SVG elements can only compute a rect that's valid with
 * respect to the "outer SVG" frame.
 */
static nsRect
GetBoxRectForFrame(nsIFrame** aFrame, CSSBoxType aType)
{

  // GetBoxRectForFrame can modify relativeToFrame so call it first.
  nsPoint relativeToTopLeft =
      GetBoxRectForFrame(&relativeToFrame, CSSBoxType::Border).TopLeft();
  AccumulateQuadCallback callback(ownerDoc, aResult, relativeToFrame,
                                  relativeToTopLeft, aOptions.mBox);
  nsLayoutUtils::GetAllInFlowBoxes(frame, &callback);
}

static void
TransformCSSPoints(nsINode* aTo, const GeometryNode& aFrom,
                   uint32_t aPointCount, gfxPoint* aPoints,
                   const ConvertCoordinateOptions& aOptions, ErrorResult& aRv)
{
  nsIFrame* fromFrame = GetFirstNonAnonymousFrameForGeometryNode(aFrom);
  nsIFrame* toFrame = GetFirstNonAnonymousFrameForNode(aTo);
  if (!fromFrame || !toFrame) {
    aRv.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
    return;
  }
  if (!CheckFramesInSameTopLevelBrowsingContext(fromFrame, toFrame)) {
    aRv.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
    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;
    }
  } else {
    PodZero(aPoints, aPointCount);
  }
}

already_AddRefed<DOMQuad>
ConvertQuadFromNode(nsINode* aTo, dom::DOMQuad& aQuad,
                    const GeometryNode& aFrom,
                    const dom::ConvertCoordinateOptions& aOptions,
                    ErrorResult& aRv)
{
  gfxPoint points[4];
  for (uint32_t i = 0; i < 4; ++i) {
    DOMPoint* p = aQuad.Point(i);
    if (p->W() != 1.0 || p->Z() != 0.0) {
      aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
      return nullptr;
    }
    points[i] = gfxPoint(p->X(), p->Y());
  }
  TransformCSSPoints(aTo, aFrom, 4, points, aOptions, aRv);
  if (aRv.Failed()) {
    return nullptr;
  }
  nsRefPtr<DOMQuad> result = new DOMQuad(aTo->GetParentObject(), points);
  return result.forget();
}

already_AddRefed<DOMQuad>
ConvertRectFromNode(nsINode* aTo, dom::DOMRectReadOnly& aRect,
                    const GeometryNode& aFrom,
                    const dom::ConvertCoordinateOptions& aOptions,
                    ErrorResult& aRv)
{
  gfxPoint points[4];
  double x = aRect.X(), y = aRect.Y(), w = aRect.Width(), h = aRect.Height();
  points[0] = gfxPoint(x, y);
  points[1] = gfxPoint(x + w, y);
  points[2] = gfxPoint(x + w, y + h);
  points[3] = gfxPoint(x, y + h);
  TransformCSSPoints(aTo, aFrom, 4, points, aOptions, aRv);
  if (aRv.Failed()) {
    return nullptr;
  }
  nsRefPtr<DOMQuad> result = new DOMQuad(aTo->GetParentObject(), points);
  return result.forget();
}

already_AddRefed<DOMPoint>
ConvertPointFromNode(nsINode* aTo, const dom::DOMPointInit& aPoint,
                     const GeometryNode& aFrom,
                     const dom::ConvertCoordinateOptions& aOptions,
                     ErrorResult& aRv)
{
  if (aPoint.mW != 1.0 || aPoint.mZ != 0.0) {
    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
    return nullptr;
  }
  gfxPoint point(aPoint.mX, aPoint.mY);
  TransformCSSPoints(aTo, aFrom, 1, &point, aOptions, aRv);
  if (aRv.Failed()) {
    return nullptr;
  }
  nsRefPtr<DOMPoint> result = new DOMPoint(aTo->GetParentObject(), point.x, point.y);
  return result.forget();
}

}

(-)a/layout/base/GeometryUtils.h (-2 / +26 lines)

Line	Link Here

Lines 17-41	Link Here

class nsINode;

class nsINode;

class nsIDocument;

class nsIDocument;

namespace mozilla {

namespace mozilla {

namespace dom {

namespace dom {

struct BoxQuadOptions;

struct BoxQuadOptions;

struct ConvertCoordinateOptions;

class DOMQuad;

class DOMQuad;

class Element;

class DOMRectReadOnly;

class Text;

class DOMPointInit;

class OwningTextOrElementOrDocument;

class TextOrElementOrDocument;

typedef dom::TextOrElementOrDocument GeometryNode;

typedef dom::OwningTextOrElementOrDocument OwningGeometryNode;

/**

/**

 * Computes quads for aNode using aOptions, according to GeometryUtils.getBoxQuads.

 * Computes quads for aNode using aOptions, according to GeometryUtils.getBoxQuads.

 * May set an error in aRv.

 * May set an error in aRv.

*/

*/

void GetBoxQuads(nsINode* aNode,

void GetBoxQuads(nsINode* aNode,

                 const dom::BoxQuadOptions& aOptions,

                 const dom::BoxQuadOptions& aOptions,

                 nsTArray<nsRefPtr<dom::DOMQuad> >& aResult,

                 nsTArray<nsRefPtr<dom::DOMQuad> >& aResult,

                 ErrorResult& aRv);

                 ErrorResult& aRv);

already_AddRefed<dom::DOMQuad>

ConvertQuadFromNode(nsINode* aTo, dom::DOMQuad& aQuad,

                    const GeometryNode& aFrom,

                    const dom::ConvertCoordinateOptions& aOptions,

                    ErrorResult& aRv);

already_AddRefed<dom::DOMQuad>

ConvertRectFromNode(nsINode* aTo, dom::DOMRectReadOnly& aRect,

                    const GeometryNode& aFrom,

                    const dom::ConvertCoordinateOptions& aOptions,

                    ErrorResult& aRv);

already_AddRefed<dom::DOMPoint>

ConvertPointFromNode(nsINode* aTo, const dom::DOMPointInit& aPoint,

                     const GeometryNode& aFrom,

                     const dom::ConvertCoordinateOptions& aOptions,

                     ErrorResult& aRv);

#endif /* MOZILLA_GEOMETRYUTILS_H_ */

#endif /* MOZILLA_GEOMETRYUTILS_H_ */





<script>
SimpleTest.waitForExplicitFinish();

window.scrollTo(0,0);

function startTest() {
  SpecialPowers.pushPrefEnv({"set": [["layout.css.DOMPoint.enabled", true],
                                     ["layout.css.DOMQuad.enabled", true],
                                     ["layout.css.getBoxQuads.enabled", true],
                                     ["layout.css.convertFromNode.enabled", true]]}, runTest);
}

function runTest() {
  // Setup globals
  f1d = f1.contentWindow.f1d;
  text = textContainer.firstChild;
  suppressedText = suppressedTextContainer.firstChild;







// Is support for GeometryUtils.getBoxQuads enabled?
#ifdef RELEASE_BUILD
pref("layout.css.getBoxQuads.enabled", false);
#else
pref("layout.css.getBoxQuads.enabled", true);
#endif

// Is support for GeometryUtils.getBoxQuads enabled?
#ifdef RELEASE_BUILD
pref("layout.css.convertFromNode.enabled", false);
#else
pref("layout.css.convertFromNode.enabled", true);
#endif

// Is support for CSS "text-align: true X" enabled?
pref("layout.css.text-align-true-value.enabled", false);

// Is support for the CSS4 image-orientation property enabled?
pref("layout.css.image-orientation.enabled", true);

// Is support for CSS3 Fonts features enabled?
// (includes font-variant-*, font-kerning, font-synthesis

Return to bug 918189

Bugzilla

Quick Search

Attachment #8356417: Part 1: Implement GeometryUtils.convertPointFromNode, convertRectFromNode, and convertQudFromNode918189-implement for bug #918189