mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-21 17:25:36 +00:00
63856d6d6e
HTMLEditor::RefreshInlineTableEditingUI() is an XPCOM method. Therefore, we should create a non-virtual method for internal use. Additionally, this patch makes related methods safer for nested calls of ShowInlineTableEditingUI() and HideInlineTableEditingUI(). If ShowInlineTableEditingUI() and RefreshInlineTableEditingUIInternal() detects hiding or replacing current UI, they return error to make the callers stop handling anything for new UI. Differential Revision: https://phabricator.services.mozilla.com/D5428 --HG-- extra : moz-landing-system : lando
574 lines
19 KiB
C++
574 lines
19 KiB
C++
/* 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/HTMLEditor.h"
|
|
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "mozilla/dom/EventTarget.h"
|
|
#include "mozilla/mozalloc.h"
|
|
#include "nsAString.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsComputedDOMStyle.h"
|
|
#include "nsDebug.h"
|
|
#include "nsError.h"
|
|
#include "nsGenericHTMLElement.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsAtom.h"
|
|
#include "nsIContent.h"
|
|
#include "nsID.h"
|
|
#include "nsIDOMWindow.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsIDocumentObserver.h"
|
|
#include "nsIHTMLAbsPosEditor.h"
|
|
#include "nsIHTMLInlineTableEditor.h"
|
|
#include "nsIHTMLObjectResizer.h"
|
|
#include "nsStubMutationObserver.h"
|
|
#include "nsINode.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsISupportsImpl.h"
|
|
#include "nsISupportsUtils.h"
|
|
#include "nsLiteralString.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsReadableUtils.h"
|
|
#include "nsString.h"
|
|
#include "nsStringFwd.h"
|
|
#include "nsUnicharUtils.h"
|
|
#include "nscore.h"
|
|
#include "nsContentUtils.h" // for nsAutoScriptBlocker
|
|
#include "nsROCSSPrimitiveValue.h"
|
|
|
|
class nsIDOMEventListener;
|
|
|
|
namespace mozilla {
|
|
|
|
using namespace dom;
|
|
|
|
// Retrieve the rounded number of CSS pixels from a computed CSS property.
|
|
//
|
|
// Note that this should only be called for properties whose resolved value
|
|
// is CSS pixels (like width, height, left, top, right, bottom, margin, padding,
|
|
// border-*-width, ...).
|
|
//
|
|
// See: https://drafts.csswg.org/cssom/#resolved-values
|
|
static int32_t
|
|
GetCSSFloatValue(nsComputedDOMStyle* aComputedStyle,
|
|
const nsAString& aProperty)
|
|
{
|
|
MOZ_ASSERT(aComputedStyle);
|
|
|
|
// get the computed CSSValue of the property
|
|
nsAutoString value;
|
|
nsresult rv = aComputedStyle->GetPropertyValue(aProperty, value);
|
|
if (NS_FAILED(rv)) {
|
|
return 0;
|
|
}
|
|
|
|
// We only care about resolved values, not a big deal if the element is
|
|
// undisplayed, for example, and the value is "auto" or what not.
|
|
int32_t val = value.ToInteger(&rv);
|
|
return NS_SUCCEEDED(rv) ? val : 0;
|
|
}
|
|
|
|
class ElementDeletionObserver final : public nsStubMutationObserver
|
|
{
|
|
public:
|
|
ElementDeletionObserver(nsIContent* aNativeAnonNode,
|
|
nsIContent* aObservedNode)
|
|
: mNativeAnonNode(aNativeAnonNode)
|
|
, mObservedNode(aObservedNode)
|
|
{}
|
|
|
|
NS_DECL_ISUPPORTS
|
|
NS_DECL_NSIMUTATIONOBSERVER_PARENTCHAINCHANGED
|
|
NS_DECL_NSIMUTATIONOBSERVER_NODEWILLBEDESTROYED
|
|
|
|
protected:
|
|
~ElementDeletionObserver() {}
|
|
nsIContent* mNativeAnonNode;
|
|
nsIContent* mObservedNode;
|
|
};
|
|
|
|
NS_IMPL_ISUPPORTS(ElementDeletionObserver, nsIMutationObserver)
|
|
|
|
void
|
|
ElementDeletionObserver::ParentChainChanged(nsIContent* aContent)
|
|
{
|
|
// If the native anonymous content has been unbound already in
|
|
// DeleteRefToAnonymousNode, mNativeAnonNode's parentNode is null.
|
|
if (aContent == mObservedNode && mNativeAnonNode &&
|
|
mNativeAnonNode->GetParentNode() == aContent) {
|
|
// If the observed node has been moved to another document, there isn't much
|
|
// we can do easily. But at least be safe and unbind the native anonymous
|
|
// content and stop observing changes.
|
|
if (mNativeAnonNode->OwnerDoc() != mObservedNode->OwnerDoc()) {
|
|
mObservedNode->RemoveMutationObserver(this);
|
|
mObservedNode = nullptr;
|
|
mNativeAnonNode->RemoveMutationObserver(this);
|
|
mNativeAnonNode->UnbindFromTree();
|
|
mNativeAnonNode = nullptr;
|
|
NS_RELEASE_THIS();
|
|
return;
|
|
}
|
|
|
|
// We're staying in the same document, just rebind the native anonymous
|
|
// node so that the subtree root points to the right object etc.
|
|
mNativeAnonNode->UnbindFromTree();
|
|
mNativeAnonNode->BindToTree(mObservedNode->GetUncomposedDoc(),
|
|
mObservedNode,
|
|
mObservedNode);
|
|
}
|
|
}
|
|
|
|
void
|
|
ElementDeletionObserver::NodeWillBeDestroyed(const nsINode* aNode)
|
|
{
|
|
NS_ASSERTION(aNode == mNativeAnonNode || aNode == mObservedNode,
|
|
"Wrong aNode!");
|
|
if (aNode == mNativeAnonNode) {
|
|
mObservedNode->RemoveMutationObserver(this);
|
|
mObservedNode = nullptr;
|
|
} else {
|
|
mNativeAnonNode->RemoveMutationObserver(this);
|
|
mNativeAnonNode->UnbindFromTree();
|
|
mNativeAnonNode = nullptr;
|
|
}
|
|
|
|
NS_RELEASE_THIS();
|
|
}
|
|
|
|
ManualNACPtr
|
|
HTMLEditor::CreateAnonymousElement(nsAtom* aTag,
|
|
nsIContent& aParentContent,
|
|
const nsAString& aAnonClass,
|
|
bool aIsCreatedHidden)
|
|
{
|
|
// Don't put anonymous editor element into non-HTML element.
|
|
// It is mainly for avoiding other anonymous element being inserted
|
|
// into <svg:use>, but in general we probably don't want to insert
|
|
// some random HTML anonymous element into a non-HTML element.
|
|
if (!aParentContent.IsHTMLElement()) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<nsIDocument> doc = GetDocument();
|
|
if (NS_WARN_IF(!doc)) {
|
|
return nullptr;
|
|
}
|
|
|
|
// Get the pres shell
|
|
nsCOMPtr<nsIPresShell> ps = GetPresShell();
|
|
if (NS_WARN_IF(!ps)) {
|
|
return nullptr;
|
|
}
|
|
|
|
// Create a new node through the element factory
|
|
RefPtr<Element> newContentRaw = CreateHTMLContent(aTag);
|
|
if (NS_WARN_IF(!newContentRaw)) {
|
|
return nullptr;
|
|
}
|
|
|
|
// add the "hidden" class if needed
|
|
if (aIsCreatedHidden) {
|
|
nsresult rv =
|
|
newContentRaw->SetAttr(kNameSpaceID_None, nsGkAtoms::_class,
|
|
NS_LITERAL_STRING("hidden"), true);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
// add an _moz_anonclass attribute if needed
|
|
if (!aAnonClass.IsEmpty()) {
|
|
nsresult rv =
|
|
newContentRaw->SetAttr(kNameSpaceID_None, nsGkAtoms::_moz_anonclass,
|
|
aAnonClass, true);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
{
|
|
nsAutoScriptBlocker scriptBlocker;
|
|
|
|
// establish parenthood of the element
|
|
newContentRaw->SetIsNativeAnonymousRoot();
|
|
nsresult rv =
|
|
newContentRaw->BindToTree(doc, &aParentContent, &aParentContent);
|
|
if (NS_FAILED(rv)) {
|
|
newContentRaw->UnbindFromTree();
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
ManualNACPtr newContent(newContentRaw.forget());
|
|
|
|
// Must style the new element, otherwise the PostRecreateFramesFor call
|
|
// below will do nothing.
|
|
ServoStyleSet* styleSet = ps->StyleSet();
|
|
// Sometimes editor likes to append anonymous content to elements
|
|
// in display:none subtrees, so avoid styling in those cases.
|
|
if (ServoStyleSet::MayTraverseFrom(newContent)) {
|
|
styleSet->StyleNewSubtree(newContent);
|
|
}
|
|
|
|
ElementDeletionObserver* observer =
|
|
new ElementDeletionObserver(newContent, &aParentContent);
|
|
NS_ADDREF(observer); // NodeWillBeDestroyed releases.
|
|
aParentContent.AddMutationObserver(observer);
|
|
newContent->AddMutationObserver(observer);
|
|
|
|
#ifdef DEBUG
|
|
// Editor anonymous content gets passed to PostRecreateFramesFor... which
|
|
// can't _really_ deal with anonymous content (because it can't get the frame
|
|
// tree ordering right). But for us the ordering doesn't matter so this is
|
|
// sort of ok.
|
|
newContent->SetProperty(nsGkAtoms::restylableAnonymousNode,
|
|
reinterpret_cast<void*>(true));
|
|
#endif // DEBUG
|
|
|
|
// display the element
|
|
ps->PostRecreateFramesFor(newContent);
|
|
|
|
return newContent;
|
|
}
|
|
|
|
// Removes event listener and calls DeleteRefToAnonymousNode.
|
|
void
|
|
HTMLEditor::RemoveListenerAndDeleteRef(const nsAString& aEvent,
|
|
nsIDOMEventListener* aListener,
|
|
bool aUseCapture,
|
|
ManualNACPtr aElement,
|
|
nsIPresShell* aShell)
|
|
{
|
|
if (aElement) {
|
|
aElement->RemoveEventListener(aEvent, aListener, aUseCapture);
|
|
}
|
|
DeleteRefToAnonymousNode(std::move(aElement), aShell);
|
|
}
|
|
|
|
// Deletes all references to an anonymous element
|
|
void
|
|
HTMLEditor::DeleteRefToAnonymousNode(ManualNACPtr aContent,
|
|
nsIPresShell* aShell)
|
|
{
|
|
// call ContentRemoved() for the anonymous content
|
|
// node so its references get removed from the frame manager's
|
|
// undisplay map, and its layout frames get destroyed!
|
|
|
|
if (NS_WARN_IF(!aContent)) {
|
|
return;
|
|
}
|
|
|
|
nsIContent* parentContent = aContent->GetParent();
|
|
if (NS_WARN_IF(!parentContent)) {
|
|
// aContent was already removed?
|
|
return;
|
|
}
|
|
|
|
nsAutoScriptBlocker scriptBlocker;
|
|
// Need to check whether aShell has been destroyed (but not yet deleted).
|
|
// See bug 338129.
|
|
if (aContent->IsInComposedDoc() && aShell && !aShell->IsDestroying()) {
|
|
MOZ_ASSERT(aContent->IsRootOfAnonymousSubtree());
|
|
MOZ_ASSERT(!aContent->GetPreviousSibling(), "NAC has no siblings");
|
|
|
|
// FIXME(emilio): This is the only caller to PresShell::ContentRemoved that
|
|
// passes NAC into it. This is not great!
|
|
aShell->ContentRemoved(aContent, nullptr);
|
|
}
|
|
|
|
// The ManualNACPtr destructor will invoke UnbindFromTree.
|
|
}
|
|
|
|
void
|
|
HTMLEditor::HideAnonymousEditingUIs()
|
|
{
|
|
if (mAbsolutelyPositionedObject) {
|
|
HideGrabberInternal();
|
|
NS_ASSERTION(!mAbsolutelyPositionedObject, "HideGrabber failed");
|
|
}
|
|
if (mInlineEditedCell) {
|
|
HideInlineTableEditingUIInternal();
|
|
NS_ASSERTION(!mInlineEditedCell, "HideInlineTableEditingUIInternal failed");
|
|
}
|
|
if (mResizedObject) {
|
|
DebugOnly<nsresult> rv = HideResizersInternal();
|
|
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HideResizersInternal() failed");
|
|
NS_ASSERTION(!mResizedObject, "HideResizersInternal() failed");
|
|
}
|
|
}
|
|
|
|
void
|
|
HTMLEditor::HideAnonymousEditingUIsIfUnnecessary()
|
|
{
|
|
// XXX Perhaps, this is wrong approach to hide multiple UIs because
|
|
// hiding one UI may causes overwriting existing UI with newly
|
|
// created one. In such case, we will leak ovewritten UI.
|
|
if (!IsAbsolutePositionEditorEnabled() && mAbsolutelyPositionedObject) {
|
|
// XXX If we're moving something, we need to cancel or commit the
|
|
// operation now.
|
|
HideGrabberInternal();
|
|
NS_ASSERTION(!mAbsolutelyPositionedObject, "HideGrabber failed");
|
|
}
|
|
if (!IsInlineTableEditorEnabled() && mInlineEditedCell) {
|
|
// XXX If we're resizing a table element, we need to cancel or commit the
|
|
// operation now.
|
|
HideInlineTableEditingUIInternal();
|
|
NS_ASSERTION(!mInlineEditedCell, "HideInlineTableEditingUIInternal failed");
|
|
}
|
|
if (!IsObjectResizerEnabled() && mResizedObject) {
|
|
// XXX If we're resizing something, we need to cancel or commit the
|
|
// operation now.
|
|
DebugOnly<nsresult> rv = HideResizersInternal();
|
|
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "HideResizersInternal() failed");
|
|
NS_ASSERTION(!mResizedObject, "HideResizersInternal() failed");
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLEditor::CheckSelectionStateForAnonymousButtons(Selection* aSelection)
|
|
{
|
|
if (NS_WARN_IF(!aSelection)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
nsresult rv = RefereshEditingUI(*aSelection);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
HTMLEditor::RefereshEditingUI(Selection& aSelection)
|
|
{
|
|
// First, we need to remove unnecessary editing UI now since some of them
|
|
// may be disabled while them are visible.
|
|
HideAnonymousEditingUIsIfUnnecessary();
|
|
|
|
// early way out if all contextual UI extensions are disabled
|
|
if (!IsObjectResizerEnabled() &&
|
|
!IsAbsolutePositionEditorEnabled() &&
|
|
!IsInlineTableEditorEnabled()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// Don't change selection state if we're moving.
|
|
if (mIsMoving) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// let's get the containing element of the selection
|
|
RefPtr<Element> focusElement = GetSelectionContainerElement(aSelection);
|
|
if (NS_WARN_IF(!focusElement)) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// If we're not in a document, don't try to add resizers
|
|
if (!focusElement->IsInUncomposedDoc()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// what's its tag?
|
|
nsAtom* focusTagAtom = focusElement->NodeInfo()->NameAtom();
|
|
|
|
RefPtr<Element> absPosElement;
|
|
if (IsAbsolutePositionEditorEnabled()) {
|
|
// Absolute Positioning support is enabled, is the selection contained
|
|
// in an absolutely positioned element ?
|
|
absPosElement = GetAbsolutelyPositionedSelectionContainer();
|
|
}
|
|
|
|
RefPtr<Element> cellElement;
|
|
if (IsObjectResizerEnabled() || IsInlineTableEditorEnabled()) {
|
|
// Resizing or Inline Table Editing is enabled, we need to check if the
|
|
// selection is contained in a table cell
|
|
cellElement =
|
|
GetElementOrParentByTagNameAtSelection(aSelection, *nsGkAtoms::td);
|
|
}
|
|
|
|
if (IsObjectResizerEnabled() && cellElement) {
|
|
// we are here because Resizing is enabled AND selection is contained in
|
|
// a cell
|
|
|
|
// get the enclosing table
|
|
if (nsGkAtoms::img != focusTagAtom) {
|
|
// the element container of the selection is not an image, so we'll show
|
|
// the resizers around the table
|
|
// XXX There may be a bug. cellElement may be not in <table> in invalid
|
|
// tree. So, perhaps, GetEnclosingTable() returns nullptr, we should
|
|
// not set focusTagAtom to nsGkAtoms::table.
|
|
focusElement = GetEnclosingTable(cellElement);
|
|
focusTagAtom = nsGkAtoms::table;
|
|
}
|
|
}
|
|
|
|
// we allow resizers only around images, tables, and absolutely positioned
|
|
// elements. If we don't have image/table, let's look at the latter case.
|
|
if (nsGkAtoms::img != focusTagAtom && nsGkAtoms::table != focusTagAtom) {
|
|
focusElement = absPosElement;
|
|
}
|
|
|
|
// at this point, focusElement contains the element for Resizing,
|
|
// cellElement contains the element for InlineTableEditing
|
|
// absPosElement contains the element for Positioning
|
|
|
|
// Note: All the Hide/Show methods below may change attributes on real
|
|
// content which means a DOMAttrModified handler may cause arbitrary
|
|
// side effects while this code runs (bug 420439).
|
|
|
|
if (IsAbsolutePositionEditorEnabled() && mAbsolutelyPositionedObject &&
|
|
absPosElement != mAbsolutelyPositionedObject) {
|
|
HideGrabberInternal();
|
|
NS_ASSERTION(!mAbsolutelyPositionedObject, "HideGrabber failed");
|
|
}
|
|
|
|
if (IsObjectResizerEnabled() && mResizedObject &&
|
|
mResizedObject != focusElement) {
|
|
// Perhaps, even if HideResizersInternal() failed, we should try to hide
|
|
// inline table editing UI. However, it returns error only when we cannot
|
|
// do anything. So, it's okay for now.
|
|
nsresult rv = HideResizersInternal();
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
NS_ASSERTION(!mResizedObject, "HideResizersInternal() failed");
|
|
}
|
|
|
|
if (IsInlineTableEditorEnabled() && mInlineEditedCell &&
|
|
mInlineEditedCell != cellElement) {
|
|
HideInlineTableEditingUIInternal();
|
|
NS_ASSERTION(!mInlineEditedCell, "HideInlineTableEditingUIInternal failed");
|
|
}
|
|
|
|
// now, let's display all contextual UI for good
|
|
nsIContent* hostContent = GetActiveEditingHost();
|
|
|
|
if (IsObjectResizerEnabled() && focusElement &&
|
|
IsModifiableNode(*focusElement) && focusElement != hostContent) {
|
|
if (nsGkAtoms::img == focusTagAtom) {
|
|
mResizedObjectIsAnImage = true;
|
|
}
|
|
if (mResizedObject) {
|
|
nsresult rv = RefreshResizersInternal();
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
} else {
|
|
nsresult rv = ShowResizersInternal(*focusElement);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (IsAbsolutePositionEditorEnabled() && absPosElement &&
|
|
IsModifiableNode(*absPosElement) && absPosElement != hostContent) {
|
|
if (mAbsolutelyPositionedObject) {
|
|
nsresult rv = RefreshGrabberInternal();
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
} else {
|
|
nsresult rv = ShowGrabberInternal(*absPosElement);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (IsInlineTableEditorEnabled() && cellElement &&
|
|
IsModifiableNode(*cellElement) && cellElement != hostContent) {
|
|
if (mInlineEditedCell) {
|
|
nsresult rv = RefreshInlineTableEditingUIInternal();
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
} else {
|
|
nsresult rv = ShowInlineTableEditingUIInternal(*cellElement);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// Resizing and Absolute Positioning need to know everything about the
|
|
// containing box of the element: position, size, margins, borders
|
|
nsresult
|
|
HTMLEditor::GetPositionAndDimensions(Element& aElement,
|
|
int32_t& aX,
|
|
int32_t& aY,
|
|
int32_t& aW,
|
|
int32_t& aH,
|
|
int32_t& aBorderLeft,
|
|
int32_t& aBorderTop,
|
|
int32_t& aMarginLeft,
|
|
int32_t& aMarginTop)
|
|
{
|
|
// Is the element positioned ? let's check the cheap way first...
|
|
bool isPositioned =
|
|
aElement.HasAttr(kNameSpaceID_None, nsGkAtoms::_moz_abspos);
|
|
if (!isPositioned) {
|
|
// hmmm... the expensive way now...
|
|
nsAutoString positionStr;
|
|
CSSEditUtils::GetComputedProperty(aElement, *nsGkAtoms::position,
|
|
positionStr);
|
|
isPositioned = positionStr.EqualsLiteral("absolute");
|
|
}
|
|
|
|
if (isPositioned) {
|
|
// Yes, it is absolutely positioned
|
|
mResizedObjectIsAbsolutelyPositioned = true;
|
|
|
|
// Get the all the computed css styles attached to the element node
|
|
RefPtr<nsComputedDOMStyle> cssDecl =
|
|
CSSEditUtils::GetComputedStyle(&aElement);
|
|
NS_ENSURE_STATE(cssDecl);
|
|
|
|
aBorderLeft = GetCSSFloatValue(cssDecl, NS_LITERAL_STRING("border-left-width"));
|
|
aBorderTop = GetCSSFloatValue(cssDecl, NS_LITERAL_STRING("border-top-width"));
|
|
aMarginLeft = GetCSSFloatValue(cssDecl, NS_LITERAL_STRING("margin-left"));
|
|
aMarginTop = GetCSSFloatValue(cssDecl, NS_LITERAL_STRING("margin-top"));
|
|
|
|
aX = GetCSSFloatValue(cssDecl, NS_LITERAL_STRING("left")) +
|
|
aMarginLeft + aBorderLeft;
|
|
aY = GetCSSFloatValue(cssDecl, NS_LITERAL_STRING("top")) +
|
|
aMarginTop + aBorderTop;
|
|
aW = GetCSSFloatValue(cssDecl, NS_LITERAL_STRING("width"));
|
|
aH = GetCSSFloatValue(cssDecl, NS_LITERAL_STRING("height"));
|
|
} else {
|
|
mResizedObjectIsAbsolutelyPositioned = false;
|
|
RefPtr<nsGenericHTMLElement> htmlElement =
|
|
nsGenericHTMLElement::FromNode(aElement);
|
|
if (!htmlElement) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
GetElementOrigin(aElement, aX, aY);
|
|
|
|
aW = htmlElement->OffsetWidth();
|
|
aH = htmlElement->OffsetHeight();
|
|
|
|
aBorderLeft = 0;
|
|
aBorderTop = 0;
|
|
aMarginLeft = 0;
|
|
aMarginTop = 0;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
// self-explanatory
|
|
void
|
|
HTMLEditor::SetAnonymousElementPosition(int32_t aX,
|
|
int32_t aY,
|
|
Element* aElement)
|
|
{
|
|
mCSSEditUtils->SetCSSPropertyPixels(*aElement, *nsGkAtoms::left, aX);
|
|
mCSSEditUtils->SetCSSPropertyPixels(*aElement, *nsGkAtoms::top, aY);
|
|
}
|
|
|
|
} // namespace mozilla
|