Attachment #8389631 for bug #917755

Attachment #8389631: Implement DOMRect (v2) for bug #917755

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





/* -*- 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 "mozilla/dom/DOMRect.h"

#include "nsPresContext.h"
#include "mozilla/dom/DOMRectListBinding.h"
#include "mozilla/dom/DOMRectBinding.h"

using namespace mozilla;
using namespace mozilla::dom;

NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_1(DOMRectReadOnly, mParent)
NS_IMPL_CYCLE_COLLECTING_ADDREF(DOMRectReadOnly)
NS_IMPL_CYCLE_COLLECTING_RELEASE(DOMRectReadOnly)
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DOMRectReadOnly)
  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  NS_INTERFACE_MAP_ENTRY(nsIDOMClientRect)
  NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_END

JSObject*
DOMRectReadOnly::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aScope)
{
  MOZ_ASSERT(mParent);
  return DOMRectReadOnlyBinding::Wrap(aCx, aScope, this);
}

// -----------------------------------------------------------------------------

NS_IMPL_ISUPPORTS_INHERITED1(DOMRect, DOMRectReadOnly, nsIDOMClientRect)

#define FORWARD_GETTER(_name)                                                   \
  NS_IMETHODIMP                                                                 \
  DOMRect::Get ## _name(float* aResult)                                         \
  {                                                                             \
    *aResult = float(_name());                                                  \
    return NS_OK;                                                               \
  }

FORWARD_GETTER(Left)
FORWARD_GETTER(Top)
FORWARD_GETTER(Right)
FORWARD_GETTER(Bottom)
FORWARD_GETTER(Width)


JSObject*
DOMRect::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aScope)
{
  MOZ_ASSERT(mParent);
  return DOMRectBinding::Wrap(aCx, aScope, this);
}

already_AddRefed<DOMRect>
DOMRect::Constructor(const GlobalObject& aGlobal, ErrorResult& aRV)
{
  nsRefPtr<DOMRect> obj =
    new DOMRect(aGlobal.GetAsSupports(), 0.0, 0.0, 0.0, 0.0);
  return obj.forget();
}

already_AddRefed<DOMRect>
DOMRect::Constructor(const GlobalObject& aGlobal, double aX, double aY,
                     double aWidth, double aHeight, ErrorResult& aRV)
{
  nsRefPtr<DOMRect> obj =
    new DOMRect(aGlobal.GetAsSupports(), aX, aY, aWidth, aHeight);
  return obj.forget();
}

// -----------------------------------------------------------------------------

NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_2(DOMRectList, mParent, mArray)

NS_INTERFACE_TABLE_HEAD(DOMRectList)
  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  NS_INTERFACE_TABLE1(DOMRectList, nsIDOMClientRectList)
  NS_INTERFACE_TABLE_TO_MAP_SEGUE_CYCLE_COLLECTION(DOMRectList)
NS_INTERFACE_MAP_END

NS_IMPL_CYCLE_COLLECTING_ADDREF(DOMRectList)
NS_IMPL_CYCLE_COLLECTING_RELEASE(DOMRectList)


NS_IMETHODIMP
DOMRectList::GetLength(uint32_t* aLength)
{
  *aLength = Length();
  return NS_OK;
}

NS_IMETHODIMP    
DOMRectList::Item(uint32_t aIndex, nsIDOMClientRect** aReturn)





#include "nsIDOMClientRect.h"
#include "nsIDOMClientRectList.h"
#include "nsTArray.h"
#include "nsCOMPtr.h"
#include "nsAutoPtr.h"
#include "nsWrapperCache.h"
#include "nsCycleCollectionParticipant.h"
#include "mozilla/Attributes.h"
#include "mozilla/dom/BindingDeclarations.h"
#include "mozilla/ErrorResult.h"
#include <algorithm>

struct nsRect;

namespace mozilla {
namespace dom {

class DOMRectReadOnly : public nsISupports
                      , public nsWrapperCache
{
public:
  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(DOMRectReadOnly)

  virtual ~DOMRectReadOnly() {}

  DOMRectReadOnly(nsISupports* aParent)
    : mParent(aParent)
  {
    SetIsDOMBinding();
  }
  virtual ~DOMRect() {}
  
  void SetRect(float aX, float aY, float aWidth, float aHeight) {
    mX = aX; mY = aY; mWidth = aWidth; mHeight = aHeight;
  }
  void SetLayoutRect(const nsRect& aLayoutRect);


  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(DOMRect)
  NS_DECL_NSIDOMCLIENTRECT


  nsISupports* GetParentObject() const
  {
    MOZ_ASSERT(mParent);
    return mParent;
  }
  virtual JSObject* WrapObject(JSContext* aCx,
                               JS::Handle<JSObject*> aScope) MOZ_OVERRIDE;

  virtual double X() const = 0;
  virtual double Y() const = 0;
  virtual double Width() const = 0;
  virtual double Height() const = 0;

  double Left() const
  {
    double x = X(), w = Width();
    return std::min(x, x + w);
  }
  double Top() const
  {
    double y = Y(), h = Height();
    return std::min(y, y + h);
  }
  double Right() const
  {
    double x = X(), w = Width();
    return std::max(x, x + w);
  }
  double Bottom() const
  {
    double y = Y(), h = Height();
    return std::max(y, y + h);
  }

protected:
  nsCOMPtr<nsISupports> mParent;
};

class DOMRect MOZ_FINAL : public DOMRectReadOnly
                        , public nsIDOMClientRect
{
public:
  DOMRect(nsISupports* aParent, double aX = 0, double aY = 0,
          double aWidth = 0, double aHeight = 0)
    : DOMRectReadOnly(aParent)
    , mX(aX)
    , mY(aY)
    , mWidth(aWidth)
    , mHeight(aHeight)
  {
  }
  
  NS_DECL_ISUPPORTS_INHERITED
  NS_DECL_NSIDOMCLIENTRECT

  static already_AddRefed<DOMRect>
  Constructor(const GlobalObject& aGlobal, ErrorResult& aRV);
  static already_AddRefed<DOMRect>
  Constructor(const GlobalObject& aGlobal, double aX, double aY,
              double aWidth, double aHeight, ErrorResult& aRV);

  virtual JSObject* WrapObject(JSContext* aCx,
                               JS::Handle<JSObject*> aScope) MOZ_OVERRIDE;

  void SetRect(float aX, float aY, float aWidth, float aHeight) {
    mX = aX; mY = aY; mWidth = aWidth; mHeight = aHeight;
  }
  void SetLayoutRect(const nsRect& aLayoutRect);

  virtual double X() const MOZ_OVERRIDE
  {
    return mX;
  }
  virtual double Y() const MOZ_OVERRIDE
  float Top() const
  {
    return mY;
  }
  virtual double Width() const MOZ_OVERRIDE
  float Right() const
  {
    return mX + mWidth;
  }

  float Bottom() const
  {
    return mY + mHeight;
  }

  float Width() const
  {
    return mWidth;
  }
  virtual double Height() const MOZ_OVERRIDE
  float Height() const
  {
    return mHeight;
  }

  void SetX(double aX)
  {
    mX = aX;
  }
  void SetY(double aY)
  {
    mY = aY;
  }
  void SetWidth(double aWidth)
  {
    mWidth = aWidth;
  }
  void SetHeight(double aHeight)
  {
    mHeight = aHeight;
  }

protected:
  double mX, mY, mWidth, mHeight;
  float mX, mY, mWidth, mHeight;
};

class DOMRectList MOZ_FINAL : public nsIDOMClientRectList,
                              public nsWrapperCache
{
public:
  DOMRectList(nsISupports *aParent) : mParent(aParent)
  {

    aFound = aIndex < mArray.Length();
    if (!aFound) {
      return nullptr;
    }
    return mArray[aIndex];
  }

protected:
  nsTArray<nsRefPtr<DOMRect> > mArray;

  nsTArray< nsRefPtr<DOMRect> > mArray;
  nsCOMPtr<nsISupports> mParent;
};

}
}

#endif /*MOZILLA_DOMRECT_H_*/





    'register': False,
},

'ChromeWorker': {
    'headerFile': 'mozilla/dom/WorkerPrivate.h',
    'nativeType': 'mozilla::dom::workers::ChromeWorkerPrivate',
},

'DOMRectList': {
    'headerFile': 'mozilla/dom/DOMRect.h',
    'resultNotAddRefed': [ 'item' ]
},

'DOMPointReadOnly': {
    'headerFile': 'mozilla/dom/DOMPoint.h',
    'concrete': False,
},

'Console': {
    'implicitJSContext': [ 'trace', 'time', 'timeEnd' ],
},

'ConvolverNode': {
    'implicitJSContext': [ 'buffer' ],
    'resultNotAddRefed': [ 'buffer' ],
},

},

'DOMException': {
    'binaryNames': {
        'message': 'messageMoz',
    },
},

'DOMPointReadOnly': {
    'headerFile': 'mozilla/dom/DOMPoint.h',
    'concrete': False,
},

'DOMRectList': {
    'headerFile': 'mozilla/dom/DOMRect.h',
    'resultNotAddRefed': [ 'item' ]
},

'DOMRectReadOnly': {
    'headerFile': 'mozilla/dom/DOMRect.h',
},

'DOMSettableTokenList': {
    'nativeType': 'nsDOMSettableTokenList',
},

'DOMStringMap': {
    'nativeType': 'nsDOMStringMap'
},






    "DOMPoint",
// IMPORTANT: Do not change this list without review from a DOM peer!
    "DOMPointReadOnly",
// IMPORTANT: Do not change this list without review from a DOM peer!
    "DOMRect",
// IMPORTANT: Do not change this list without review from a DOM peer!
    "DOMRectList",
// IMPORTANT: Do not change this list without review from a DOM peer!
    "DOMRectReadOnly",
// IMPORTANT: Do not change this list without review from a DOM peer!
    "DOMRequest",
// IMPORTANT: Do not change this list without review from a DOM peer!
    "DOMSettableTokenList",
// IMPORTANT: Do not change this list without review from a DOM peer!
    "DOMStringList",
// IMPORTANT: Do not change this list without review from a DOM peer!
    "DOMStringMap",
// IMPORTANT: Do not change this list without review from a DOM peer!





/* -*- Mode: IDL; 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/.
 *
 * The origin of this IDL file is
 * http://dev.w3.org/fxtf/geometry/
 *
 * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
 * liability, trademark and document use rules apply.
 */

[Constructor,
 Constructor(unrestricted double x, unrestricted double y,
             unrestricted double width, unrestricted double height)]
interface DOMRect : DOMRectReadOnly {
    inherit attribute unrestricted double x;
    inherit attribute unrestricted double y;
    inherit attribute unrestricted double width;
    inherit attribute unrestricted double height;
};

interface DOMRectReadOnly {
    readonly attribute unrestricted double x;
    readonly attribute unrestricted double y;
    readonly attribute unrestricted double width;
    readonly attribute unrestricted double height;
    readonly attribute unrestricted double top;
    readonly attribute unrestricted double right;
    readonly attribute unrestricted double bottom;
    readonly attribute unrestricted double left;
};





CaretPosition implements LegacyQueryInterface;
Comment implements LegacyQueryInterface;
Crypto implements LegacyQueryInterface;
CSSPrimitiveValue implements LegacyQueryInterface;
CSSStyleDeclaration implements LegacyQueryInterface;
CSSValueList implements LegacyQueryInterface;
DOMImplementation implements LegacyQueryInterface;
DOMParser implements LegacyQueryInterface;
DOMRect implements LegacyQueryInterface;
DOMRectList implements LegacyQueryInterface;
DOMStringMap implements LegacyQueryInterface;
DOMTokenList implements LegacyQueryInterface;
Document implements LegacyQueryInterface;
DocumentFragment implements LegacyQueryInterface;
DocumentType implements LegacyQueryInterface;
Element implements LegacyQueryInterface;
Event implements LegacyQueryInterface;
EventSource implements LegacyQueryInterface;

Return to bug 917755

Bugzilla

Quick Search

Attachment #8389631: Implement DOMRect (v2) for bug #917755