summaryrefslogtreecommitdiffstats
path: root/editor/libeditor/HTMLEditorObjectResizer.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'editor/libeditor/HTMLEditorObjectResizer.cpp')
-rw-r--r--editor/libeditor/HTMLEditorObjectResizer.cpp1479
1 files changed, 1479 insertions, 0 deletions
diff --git a/editor/libeditor/HTMLEditorObjectResizer.cpp b/editor/libeditor/HTMLEditorObjectResizer.cpp
new file mode 100644
index 0000000000..165cae02f1
--- /dev/null
+++ b/editor/libeditor/HTMLEditorObjectResizer.cpp
@@ -0,0 +1,1479 @@
+/* -*- 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 "HTMLEditor.h"
+
+#include "HTMLEditorEventListener.h"
+#include "HTMLEditUtils.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/LookAndFeel.h"
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/mozalloc.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/MouseEvent.h"
+#include "mozilla/dom/EventTarget.h"
+#include "nsAString.h"
+#include "nsAlgorithm.h"
+#include "nsCOMPtr.h"
+#include "nsDebug.h"
+#include "nsError.h"
+#include "nsGkAtoms.h"
+#include "nsAtom.h"
+#include "nsIContent.h"
+#include "nsID.h"
+#include "mozilla/dom/Document.h"
+#include "nsISupportsUtils.h"
+#include "nsPIDOMWindow.h"
+#include "nsReadableUtils.h"
+#include "nsString.h"
+#include "nsStringFwd.h"
+#include "nsStyledElement.h"
+#include "nsTextNode.h"
+#include "nscore.h"
+#include <algorithm>
+
+#define kTopLeft u"nw"_ns
+#define kTop u"n"_ns
+#define kTopRight u"ne"_ns
+#define kLeft u"w"_ns
+#define kRight u"e"_ns
+#define kBottomLeft u"sw"_ns
+#define kBottom u"s"_ns
+#define kBottomRight u"se"_ns
+
+namespace mozilla {
+
+using namespace dom;
+
+/******************************************************************************
+ * mozilla::HTMLEditor
+ ******************************************************************************/
+
+ManualNACPtr HTMLEditor::CreateResizer(int16_t aLocation,
+ nsIContent& aParentContent) {
+ ManualNACPtr resizer = CreateAnonymousElement(nsGkAtoms::span, aParentContent,
+ u"mozResizer"_ns, false);
+ if (!resizer) {
+ NS_WARNING(
+ "HTMLEditor::CreateAnonymousElement(nsGkAtoms::span, mozResizer) "
+ "failed");
+ return nullptr;
+ }
+
+ // add the mouse listener so we can detect a click on a resizer
+ DebugOnly<nsresult> rvIgnored =
+ resizer->AddEventListener(u"mousedown"_ns, mEventListener, true);
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rvIgnored),
+ "EventTarget::AddEventListener(mousedown) failed, but ignored");
+
+ nsAutoString locationStr;
+ switch (aLocation) {
+ case nsIHTMLObjectResizer::eTopLeft:
+ locationStr = kTopLeft;
+ break;
+ case nsIHTMLObjectResizer::eTop:
+ locationStr = kTop;
+ break;
+ case nsIHTMLObjectResizer::eTopRight:
+ locationStr = kTopRight;
+ break;
+
+ case nsIHTMLObjectResizer::eLeft:
+ locationStr = kLeft;
+ break;
+ case nsIHTMLObjectResizer::eRight:
+ locationStr = kRight;
+ break;
+
+ case nsIHTMLObjectResizer::eBottomLeft:
+ locationStr = kBottomLeft;
+ break;
+ case nsIHTMLObjectResizer::eBottom:
+ locationStr = kBottom;
+ break;
+ case nsIHTMLObjectResizer::eBottomRight:
+ locationStr = kBottomRight;
+ break;
+ }
+
+ if (NS_FAILED(resizer->SetAttr(kNameSpaceID_None, nsGkAtoms::anonlocation,
+ locationStr, true))) {
+ NS_WARNING("Element::SetAttr(nsGkAtoms::anonlocation) failed");
+ return nullptr;
+ }
+ return resizer;
+}
+
+ManualNACPtr HTMLEditor::CreateShadow(nsIContent& aParentContent,
+ Element& aOriginalObject) {
+ // let's create an image through the element factory
+ RefPtr<nsAtom> name;
+ if (HTMLEditUtils::IsImage(&aOriginalObject)) {
+ name = nsGkAtoms::img;
+ } else {
+ name = nsGkAtoms::span;
+ }
+
+ return CreateAnonymousElement(name, aParentContent, u"mozResizingShadow"_ns,
+ true);
+}
+
+ManualNACPtr HTMLEditor::CreateResizingInfo(nsIContent& aParentContent) {
+ // let's create an info box through the element factory
+ return CreateAnonymousElement(nsGkAtoms::span, aParentContent,
+ u"mozResizingInfo"_ns, true);
+}
+
+nsresult HTMLEditor::SetAllResizersPosition() {
+ if (NS_WARN_IF(!mTopLeftHandle)) {
+ return NS_ERROR_FAILURE; // There are no resizers.
+ }
+
+ int32_t x = mResizedObjectX;
+ int32_t y = mResizedObjectY;
+ int32_t w = mResizedObjectWidth;
+ int32_t h = mResizedObjectHeight;
+
+ nsAutoString value;
+ float resizerWidth, resizerHeight;
+ RefPtr<nsAtom> dummyUnit;
+ DebugOnly<nsresult> rvIgnored = NS_OK;
+ OwningNonNull<Element> topLeftHandle = *mTopLeftHandle.get();
+ // XXX Do we really need to computed value rather than specified value?
+ // Because it's an anonymous node.
+ rvIgnored = CSSEditUtils::GetComputedProperty(*topLeftHandle,
+ *nsGkAtoms::width, value);
+ if (NS_WARN_IF(Destroyed())) {
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ if (NS_WARN_IF(topLeftHandle != mTopLeftHandle)) {
+ return NS_ERROR_FAILURE;
+ }
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+ "CSSEditUtils::GetComputedProperty(nsGkAtoms::width) "
+ "failed, but ignored");
+ rvIgnored = CSSEditUtils::GetComputedProperty(*topLeftHandle,
+ *nsGkAtoms::height, value);
+ if (NS_WARN_IF(Destroyed())) {
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ if (NS_WARN_IF(topLeftHandle != mTopLeftHandle)) {
+ return NS_ERROR_FAILURE;
+ }
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+ "CSSEditUtils::GetComputedProperty(nsGkAtoms::height) "
+ "failed, but ignored");
+ CSSEditUtils::ParseLength(value, &resizerWidth, getter_AddRefs(dummyUnit));
+ CSSEditUtils::ParseLength(value, &resizerHeight, getter_AddRefs(dummyUnit));
+
+ int32_t rw = static_cast<int32_t>((resizerWidth + 1) / 2);
+ int32_t rh = static_cast<int32_t>((resizerHeight + 1) / 2);
+
+ // While moving each resizer, mutation event listener may hide the resizers.
+ // And in worst case, new resizers may be recreated. So, we need to store
+ // all resizers here, and then, if we detect a resizer is removed or replaced,
+ // we should do nothing anymore.
+ // FYI: Note that only checking if mTopLeftHandle is replaced is enough.
+ // We're may be in hot path if user resizes an element a lot. So,
+ // we should just add-ref mTopLeftHandle.
+ auto setHandlePosition =
+ [this](ManualNACPtr& aHandleElement, int32_t aNewX, int32_t aNewY)
+ MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION -> nsresult {
+ RefPtr<nsStyledElement> handleStyledElement =
+ nsStyledElement::FromNodeOrNull(aHandleElement.get());
+ if (!handleStyledElement) {
+ return NS_OK;
+ }
+ nsresult rv = SetAnonymousElementPositionWithoutTransaction(
+ *handleStyledElement, aNewX, aNewY);
+ if (NS_FAILED(rv)) {
+ NS_WARNING(
+ "HTMLEditor::SetAnonymousElementPositionWithoutTransaction() "
+ "failed");
+ return rv;
+ }
+ return NS_WARN_IF(handleStyledElement != aHandleElement.get())
+ ? NS_ERROR_FAILURE
+ : NS_OK;
+ };
+ nsresult rv;
+ rv = setHandlePosition(mTopLeftHandle, x - rw, y - rh);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("Failed to set top-left handle position");
+ return rv;
+ }
+ rv = setHandlePosition(mTopHandle, x + w / 2 - rw, y - rh);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("Failed to set top handle position");
+ return rv;
+ }
+ rv = setHandlePosition(mTopRightHandle, x + w - rw - 1, y - rh);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("Failed to set top-right handle position");
+ return rv;
+ }
+
+ rv = setHandlePosition(mLeftHandle, x - rw, y + h / 2 - rh);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("Failed to set left handle position");
+ return rv;
+ }
+ rv = setHandlePosition(mRightHandle, x + w - rw - 1, y + h / 2 - rh);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("Failed to set right handle position");
+ return rv;
+ }
+
+ rv = setHandlePosition(mBottomLeftHandle, x - rw, y + h - rh - 1);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("Failed to set bottom-left handle position");
+ return rv;
+ }
+ rv = setHandlePosition(mBottomHandle, x + w / 2 - rw, y + h - rh - 1);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("Failed to set bottom handle position");
+ return rv;
+ }
+ rv = setHandlePosition(mBottomRightHandle, x + w - rw - 1, y + h - rh - 1);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("Failed to set bottom-right handle position");
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP HTMLEditor::RefreshResizers() {
+ AutoEditActionDataSetter editActionData(*this, EditAction::eNotEditing);
+ if (NS_WARN_IF(!editActionData.CanHandle())) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ nsresult rv = RefreshResizersInternal();
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "HTMLEditor::RefreshResizersInternal() failed");
+ return EditorBase::ToGenericNSResult(rv);
+}
+
+nsresult HTMLEditor::RefreshResizersInternal() {
+ // Don't warn even if resizers are not visible since script cannot check
+ // if they are visible and this is non-virtual method. So, the cost of
+ // calling this can be ignored.
+ if (!mResizedObject) {
+ return NS_OK;
+ }
+
+ OwningNonNull<Element> resizedObject = *mResizedObject;
+ nsresult rv = GetPositionAndDimensions(
+ resizedObject, mResizedObjectX, mResizedObjectY, mResizedObjectWidth,
+ mResizedObjectHeight, mResizedObjectBorderLeft, mResizedObjectBorderTop,
+ mResizedObjectMarginLeft, mResizedObjectMarginTop);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("HTMLEditor::GetPositionAndDimensions() failed");
+ return rv;
+ }
+ if (NS_WARN_IF(resizedObject != mResizedObject)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ rv = SetAllResizersPosition();
+ if (NS_FAILED(rv)) {
+ NS_WARNING("HTMLEditor::SetAllResizersPosition() failed");
+ return rv;
+ }
+ if (NS_WARN_IF(resizedObject != mResizedObject)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ MOZ_ASSERT(
+ mResizingShadow,
+ "SetAllResizersPosition() should return error if resizers are hidden");
+ RefPtr<Element> resizingShadow = mResizingShadow.get();
+ rv = SetShadowPosition(*resizingShadow, resizedObject, mResizedObjectX,
+ mResizedObjectY);
+ if (NS_WARN_IF(resizedObject != mResizedObject)) {
+ return NS_ERROR_FAILURE;
+ }
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "HTMLEditor::SetShadowPosition() failed");
+ return rv;
+}
+
+nsresult HTMLEditor::ShowResizersInternal(Element& aResizedElement) {
+ // When we have visible resizers, we cannot show new resizers.
+ // So, the caller should call HideResizersInternal() first if this
+ // returns error.
+ if (NS_WARN_IF(mResizedObject)) {
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ nsCOMPtr<nsIContent> parentContent = aResizedElement.GetParent();
+ if (NS_WARN_IF(!parentContent)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ if (NS_WARN_IF(!IsDescendantOfEditorRoot(&aResizedElement))) {
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ // Let's create and setup resizers. If we failed something, we should
+ // cancel everything which we do in this method.
+ do {
+ mResizedObject = &aResizedElement;
+
+ // The resizers and the shadow will be anonymous siblings of the element.
+ // Note that creating a resizer or shadow may causes calling
+ // HideRisizersInternal() via a mutation event listener. So, we should
+ // store new resizer to a local variable, then, check:
+ // - whether creating resizer is already set to the member or not
+ // - whether resizing element is changed to another element
+ // If showing resizers are canceled, we hit the latter check.
+ // If resizers for another element is shown during this, we hit the latter
+ // check too.
+ // If resizers are just shown again for same element, we hit the former
+ // check.
+ ManualNACPtr newResizer =
+ CreateResizer(nsIHTMLObjectResizer::eTopLeft, *parentContent);
+ if (!newResizer) {
+ NS_WARNING("HTMLEditor::CreateResizer(eTopLeft) failed");
+ break;
+ }
+ if (NS_WARN_IF(mTopLeftHandle) ||
+ NS_WARN_IF(mResizedObject != &aResizedElement)) {
+ // Don't hide current resizers in this case because they are not what
+ // we're creating.
+ return NS_ERROR_FAILURE;
+ }
+ mTopLeftHandle = std::move(newResizer);
+ newResizer = CreateResizer(nsIHTMLObjectResizer::eTop, *parentContent);
+ if (!newResizer) {
+ NS_WARNING("HTMLEditor::CreateResizer(eTop) failed");
+ break;
+ }
+ if (NS_WARN_IF(mTopHandle) ||
+ NS_WARN_IF(mResizedObject != &aResizedElement)) {
+ return NS_ERROR_FAILURE;
+ }
+ mTopHandle = std::move(newResizer);
+ newResizer = CreateResizer(nsIHTMLObjectResizer::eTopRight, *parentContent);
+ if (!newResizer) {
+ NS_WARNING("HTMLEditor::CreateResizer(eTopRight) failed");
+ break;
+ }
+ if (NS_WARN_IF(mTopRightHandle) ||
+ NS_WARN_IF(mResizedObject != &aResizedElement)) {
+ return NS_ERROR_FAILURE;
+ }
+ mTopRightHandle = std::move(newResizer);
+
+ newResizer = CreateResizer(nsIHTMLObjectResizer::eLeft, *parentContent);
+ if (!newResizer) {
+ NS_WARNING("HTMLEditor::CreateResizer(eLeft) failed");
+ break;
+ }
+ if (NS_WARN_IF(mLeftHandle) ||
+ NS_WARN_IF(mResizedObject != &aResizedElement)) {
+ return NS_ERROR_FAILURE;
+ }
+ mLeftHandle = std::move(newResizer);
+ newResizer = CreateResizer(nsIHTMLObjectResizer::eRight, *parentContent);
+ if (!newResizer) {
+ NS_WARNING("HTMLEditor::CreateResizer(eRight) failed");
+ break;
+ }
+ if (NS_WARN_IF(mRightHandle) ||
+ NS_WARN_IF(mResizedObject != &aResizedElement)) {
+ return NS_ERROR_FAILURE;
+ }
+ mRightHandle = std::move(newResizer);
+
+ newResizer =
+ CreateResizer(nsIHTMLObjectResizer::eBottomLeft, *parentContent);
+ if (!newResizer) {
+ NS_WARNING("HTMLEditor::CreateResizer(eBottomLeft) failed");
+ break;
+ }
+ if (NS_WARN_IF(mBottomLeftHandle) ||
+ NS_WARN_IF(mResizedObject != &aResizedElement)) {
+ return NS_ERROR_FAILURE;
+ }
+ mBottomLeftHandle = std::move(newResizer);
+ newResizer = CreateResizer(nsIHTMLObjectResizer::eBottom, *parentContent);
+ if (!newResizer) {
+ NS_WARNING("HTMLEditor::CreateResizer(eBottom) failed");
+ break;
+ }
+ if (NS_WARN_IF(mBottomHandle) ||
+ NS_WARN_IF(mResizedObject != &aResizedElement)) {
+ return NS_ERROR_FAILURE;
+ }
+ mBottomHandle = std::move(newResizer);
+ newResizer =
+ CreateResizer(nsIHTMLObjectResizer::eBottomRight, *parentContent);
+ if (!newResizer) {
+ NS_WARNING("HTMLEditor::CreateResizer(eBottomRight) failed");
+ break;
+ }
+ if (NS_WARN_IF(mBottomRightHandle) ||
+ NS_WARN_IF(mResizedObject != &aResizedElement)) {
+ return NS_ERROR_FAILURE;
+ }
+ mBottomRightHandle = std::move(newResizer);
+
+ // Store the last resizer which we created. This is useful when we
+ // need to check whether our resizers are hiddedn and recreated another
+ // set of resizers or not.
+ RefPtr<Element> createdBottomRightHandle = mBottomRightHandle.get();
+
+ nsresult rv = GetPositionAndDimensions(
+ aResizedElement, mResizedObjectX, mResizedObjectY, mResizedObjectWidth,
+ mResizedObjectHeight, mResizedObjectBorderLeft, mResizedObjectBorderTop,
+ mResizedObjectMarginLeft, mResizedObjectMarginTop);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("HTMLEditor::GetPositionAndDimensions() failed");
+ break;
+ }
+
+ // and let's set their absolute positions in the document
+ rv = SetAllResizersPosition();
+ if (NS_FAILED(rv)) {
+ NS_WARNING("HTMLEditor::SetAllResizersPosition() failed");
+ if (NS_WARN_IF(mBottomRightHandle.get() != createdBottomRightHandle)) {
+ return NS_ERROR_FAILURE;
+ }
+ break;
+ }
+
+ // now, let's create the resizing shadow
+ ManualNACPtr newShadow = CreateShadow(*parentContent, aResizedElement);
+ if (!newShadow) {
+ NS_WARNING("HTMLEditor::CreateShadow() failed");
+ break;
+ }
+ if (NS_WARN_IF(mResizingShadow) ||
+ NS_WARN_IF(mResizedObject != &aResizedElement)) {
+ return NS_ERROR_FAILURE;
+ }
+ mResizingShadow = std::move(newShadow);
+
+ // and set its position
+ RefPtr<Element> resizingShadow = mResizingShadow.get();
+ rv = SetShadowPosition(*resizingShadow, aResizedElement, mResizedObjectX,
+ mResizedObjectY);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("HTMLEditor::SetShadowPosition() failed");
+ if (NS_WARN_IF(mBottomRightHandle.get() != createdBottomRightHandle)) {
+ return NS_ERROR_FAILURE;
+ }
+ break;
+ }
+
+ // and then the resizing info tooltip
+ ManualNACPtr newResizingInfo = CreateResizingInfo(*parentContent);
+ if (!newResizingInfo) {
+ NS_WARNING("HTMLEditor::CreateResizingInfo() failed");
+ break;
+ }
+ if (NS_WARN_IF(mResizingInfo) ||
+ NS_WARN_IF(mResizedObject != &aResizedElement)) {
+ return NS_ERROR_FAILURE;
+ }
+ mResizingInfo = std::move(newResizingInfo);
+
+ // and listen to the "resize" event on the window first, get the
+ // window from the document...
+ if (NS_WARN_IF(!mEventListener)) {
+ break;
+ }
+
+ rv = static_cast<HTMLEditorEventListener*>(mEventListener.get())
+ ->ListenToWindowResizeEvent(true);
+ if (NS_FAILED(rv)) {
+ NS_WARNING(
+ "HTMLEditorEventListener::ListenToWindowResizeEvent(true) failed");
+ break;
+ }
+
+ MOZ_ASSERT(mResizedObject == &aResizedElement);
+
+ // XXX Even when it failed to add event listener, should we need to set
+ // _moz_resizing attribute?
+ DebugOnly<nsresult> rvIgnored = aResizedElement.SetAttr(
+ kNameSpaceID_None, nsGkAtoms::_moz_resizing, u"true"_ns, true);
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rvIgnored),
+ "Element::SetAttr(nsGkAtoms::_moz_resizing, true) failed, but ignored");
+ return NS_OK;
+ } while (true);
+
+ DebugOnly<nsresult> rv = HideResizersInternal();
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "HTMLEditor::HideResizersInternal() failed to clean up");
+ return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP HTMLEditor::HideResizers() {
+ AutoEditActionDataSetter editActionData(*this, EditAction::eNotEditing);
+ if (NS_WARN_IF(!editActionData.CanHandle())) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ nsresult rv = HideResizersInternal();
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "HTMLEditor::HideResizersInternal() failed");
+ return EditorBase::ToGenericNSResult(rv);
+}
+
+nsresult HTMLEditor::HideResizersInternal() {
+ // Don't warn even if resizers are visible since script cannot check
+ // if they are visible and this is non-virtual method. So, the cost of
+ // calling this can be ignored.
+ if (!mResizedObject) {
+ return NS_OK;
+ }
+
+ // get the presshell's document observer interface.
+ RefPtr<PresShell> presShell = GetPresShell();
+ NS_WARNING_ASSERTION(presShell, "There is no presShell");
+ // We allow the pres shell to be null; when it is, we presume there
+ // are no document observers to notify, but we still want to
+ // UnbindFromTree.
+
+ constexpr auto mousedown = u"mousedown"_ns;
+
+ // HTMLEditor should forget all members related to resizers first since
+ // removing a part of UI may cause showing the resizers again. In such
+ // case, the members may be overwritten by ShowResizers() and this will
+ // lose the chance to release the old resizers.
+ ManualNACPtr topLeftHandle(std::move(mTopLeftHandle));
+ ManualNACPtr topHandle(std::move(mTopHandle));
+ ManualNACPtr topRightHandle(std::move(mTopRightHandle));
+ ManualNACPtr leftHandle(std::move(mLeftHandle));
+ ManualNACPtr rightHandle(std::move(mRightHandle));
+ ManualNACPtr bottomLeftHandle(std::move(mBottomLeftHandle));
+ ManualNACPtr bottomHandle(std::move(mBottomHandle));
+ ManualNACPtr bottomRightHandle(std::move(mBottomRightHandle));
+ ManualNACPtr resizingShadow(std::move(mResizingShadow));
+ ManualNACPtr resizingInfo(std::move(mResizingInfo));
+ RefPtr<Element> activatedHandle(std::move(mActivatedHandle));
+ RefPtr<Element> resizedObject(std::move(mResizedObject));
+
+ // Remvoe all handles.
+ RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
+ std::move(topLeftHandle), presShell);
+
+ RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
+ std::move(topHandle), presShell);
+
+ RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
+ std::move(topRightHandle), presShell);
+
+ RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
+ std::move(leftHandle), presShell);
+
+ RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
+ std::move(rightHandle), presShell);
+
+ RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
+ std::move(bottomLeftHandle), presShell);
+
+ RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
+ std::move(bottomHandle), presShell);
+
+ RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
+ std::move(bottomRightHandle), presShell);
+
+ RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
+ std::move(resizingShadow), presShell);
+
+ RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
+ std::move(resizingInfo), presShell);
+
+ // Remove active state of a resizer.
+ if (activatedHandle) {
+ DebugOnly<nsresult> rvIgnored = activatedHandle->UnsetAttr(
+ kNameSpaceID_None, nsGkAtoms::_moz_activated, true);
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rvIgnored),
+ "Element::UnsetAttr(nsGkAtoms::_moz_activated) failed, but ignored");
+ }
+
+ // Remove resizing state of the target element.
+ DebugOnly<nsresult> rvIgnored = resizedObject->UnsetAttr(
+ kNameSpaceID_None, nsGkAtoms::_moz_resizing, true);
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rvIgnored),
+ "Element::UnsetAttr(nsGkAtoms::_moz_resizing) failed, but ignored");
+
+ if (!mEventListener) {
+ return NS_OK;
+ }
+
+ nsresult rv = static_cast<HTMLEditorEventListener*>(mEventListener.get())
+ ->ListenToMouseMoveEventForResizers(false);
+ if (NS_FAILED(rv)) {
+ NS_WARNING(
+ "HTMLEditorEventListener::ListenToMouseMoveEventForResizers(false) "
+ "failed");
+ return rv;
+ }
+
+ // Remove resize event listener from the window.
+ if (!mEventListener) {
+ return NS_OK;
+ }
+
+ rv = static_cast<HTMLEditorEventListener*>(mEventListener.get())
+ ->ListenToWindowResizeEvent(false);
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "HTMLEditorEventListener::ListenToWindowResizeEvent(false) failed");
+ return rv;
+}
+
+void HTMLEditor::HideShadowAndInfo() {
+ if (mResizingShadow) {
+ DebugOnly<nsresult> rvIgnored = mResizingShadow->SetAttr(
+ kNameSpaceID_None, nsGkAtoms::_class, u"hidden"_ns, true);
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rvIgnored),
+ "Element::SetAttr(nsGkAtoms::_class, hidden) failed, but ignored");
+ }
+ if (mResizingInfo) {
+ DebugOnly<nsresult> rvIgnored = mResizingInfo->SetAttr(
+ kNameSpaceID_None, nsGkAtoms::_class, u"hidden"_ns, true);
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rvIgnored),
+ "Element::SetAttr(nsGkAtoms::_class, hidden) failed, but ignored");
+ }
+}
+
+nsresult HTMLEditor::StartResizing(Element& aHandleElement) {
+ mIsResizing = true;
+ mActivatedHandle = &aHandleElement;
+ DebugOnly<nsresult> rvIgnored = mActivatedHandle->SetAttr(
+ kNameSpaceID_None, nsGkAtoms::_moz_activated, u"true"_ns, true);
+ if (NS_WARN_IF(Destroyed())) {
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rvIgnored),
+ "Element::SetAttr(nsGkAtoms::_moz_activated, true) failed");
+
+ // do we want to preserve ratio or not?
+ bool preserveRatio =
+ HTMLEditUtils::IsImage(mResizedObject) &&
+ Preferences::GetBool("editor.resizing.preserve_ratio", true);
+
+ // the way we change the position/size of the shadow depends on
+ // the handle
+ nsAutoString locationStr;
+ mActivatedHandle->GetAttr(nsGkAtoms::anonlocation, locationStr);
+ if (locationStr.Equals(kTopLeft)) {
+ SetResizeIncrements(1, 1, -1, -1, preserveRatio);
+ } else if (locationStr.Equals(kTop)) {
+ SetResizeIncrements(0, 1, 0, -1, false);
+ } else if (locationStr.Equals(kTopRight)) {
+ SetResizeIncrements(0, 1, 1, -1, preserveRatio);
+ } else if (locationStr.Equals(kLeft)) {
+ SetResizeIncrements(1, 0, -1, 0, false);
+ } else if (locationStr.Equals(kRight)) {
+ SetResizeIncrements(0, 0, 1, 0, false);
+ } else if (locationStr.Equals(kBottomLeft)) {
+ SetResizeIncrements(1, 0, -1, 1, preserveRatio);
+ } else if (locationStr.Equals(kBottom)) {
+ SetResizeIncrements(0, 0, 0, 1, false);
+ } else if (locationStr.Equals(kBottomRight)) {
+ SetResizeIncrements(0, 0, 1, 1, preserveRatio);
+ }
+
+ // make the shadow appear
+ rvIgnored =
+ mResizingShadow->UnsetAttr(kNameSpaceID_None, nsGkAtoms::_class, true);
+ if (NS_WARN_IF(Destroyed())) {
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+ "Element::UnsetAttr(nsGkAtoms::_class) failed");
+
+ // position it
+ if (RefPtr<nsStyledElement> resizingShadowStyledElement =
+ nsStyledElement::FromNodeOrNull(mResizingShadow.get())) {
+ nsresult rv;
+ rv = mCSSEditUtils->SetCSSPropertyPixelsWithoutTransaction(
+ *resizingShadowStyledElement, *nsGkAtoms::width, mResizedObjectWidth);
+ if (rv == NS_ERROR_EDITOR_DESTROYED) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithoutTransaction("
+ "nsGkAtoms::width) destroyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixelsWithoutTransaction("
+ "nsGkAtoms::width) failed");
+ rv = mCSSEditUtils->SetCSSPropertyPixelsWithoutTransaction(
+ *resizingShadowStyledElement, *nsGkAtoms::height, mResizedObjectHeight);
+ if (rv == NS_ERROR_EDITOR_DESTROYED) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithoutTransaction("
+ "nsGkAtoms::height) destroyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixelsWithoutTransaction("
+ "nsGkAtoms::height) failed");
+ }
+
+ // add a mouse move listener to the editor
+ if (NS_WARN_IF(!mEventListener)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+ nsresult rv = static_cast<HTMLEditorEventListener*>(mEventListener.get())
+ ->ListenToMouseMoveEventForResizers(true);
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "HTMLEditorEventListener::"
+ "ListenToMouseMoveEventForResizers(true) failed");
+ return rv;
+}
+
+nsresult HTMLEditor::StartToDragResizerOrHandleDragGestureOnGrabber(
+ MouseEvent& aMouseDownEvent, Element& aEventTargetElement) {
+ MOZ_ASSERT(aMouseDownEvent.GetExplicitOriginalTarget() ==
+ &aEventTargetElement);
+ MOZ_ASSERT(!aMouseDownEvent.DefaultPrevented());
+ MOZ_ASSERT(aMouseDownEvent.WidgetEventPtr()->mMessage == eMouseDown);
+
+ nsAutoString anonclass;
+ aEventTargetElement.GetAttr(nsGkAtoms::_moz_anonclass, anonclass);
+
+ if (anonclass.EqualsLiteral("mozResizer")) {
+ AutoEditActionDataSetter editActionData(*this,
+ EditAction::eResizingElement);
+ if (NS_WARN_IF(!editActionData.CanHandle())) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ // If we have an anonymous element and that element is a resizer,
+ // let's start resizing!
+ aMouseDownEvent.PreventDefault();
+ mOriginalX = aMouseDownEvent.ClientX();
+ mOriginalY = aMouseDownEvent.ClientY();
+ nsresult rv = StartResizing(aEventTargetElement);
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "HTMLEditor::StartResizing() failed");
+ return EditorBase::ToGenericNSResult(rv);
+ }
+
+ if (anonclass.EqualsLiteral("mozGrabber")) {
+ AutoEditActionDataSetter editActionData(*this, EditAction::eMovingElement);
+ if (NS_WARN_IF(!editActionData.CanHandle())) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ // If we have an anonymous element and that element is a grabber,
+ // let's start moving the element!
+ mOriginalX = aMouseDownEvent.ClientX();
+ mOriginalY = aMouseDownEvent.ClientY();
+ nsresult rv = GrabberClicked();
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "HTMLEditor::GrabberClicked() failed");
+ return EditorBase::ToGenericNSResult(rv);
+ }
+
+ return NS_OK;
+}
+
+nsresult HTMLEditor::StopDraggingResizerOrGrabberAt(
+ const CSSIntPoint& aClientPoint) {
+ if (mIsResizing) {
+ AutoEditActionDataSetter editActionData(*this, EditAction::eResizeElement);
+ if (NS_WARN_IF(!editActionData.CanHandle())) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ // we are resizing and release the mouse button, so let's
+ // end the resizing process
+ mIsResizing = false;
+ HideShadowAndInfo();
+
+ nsresult rv = editActionData.MaybeDispatchBeforeInputEvent();
+ if (NS_FAILED(rv)) {
+ NS_WARNING_ASSERTION(
+ rv == NS_ERROR_EDITOR_ACTION_CANCELED,
+ "EditorBase::MaybeDispatchBeforeInputEvent(), failed");
+ return EditorBase::ToGenericNSResult(rv);
+ }
+
+ rv = SetFinalSizeWithTransaction(aClientPoint.x, aClientPoint.y);
+ if (rv == NS_ERROR_EDITOR_DESTROYED) {
+ NS_WARNING(
+ "HTMLEditor::SetFinalSizeWithTransaction() destroyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "HTMLEditor::SetFinalSizeWithTransaction() failed, but ignored");
+ return NS_OK;
+ }
+
+ if (mIsMoving || mGrabberClicked) {
+ AutoEditActionDataSetter editActionData(*this, EditAction::eMoveElement);
+ nsresult rv = editActionData.CanHandleAndMaybeDispatchBeforeInputEvent();
+ if (rv != NS_ERROR_EDITOR_ACTION_CANCELED && NS_WARN_IF(NS_FAILED(rv))) {
+ NS_WARNING("CanHandleAndMaybeDispatchBeforeInputEvent() failed");
+ return EditorBase::ToGenericNSResult(rv);
+ }
+
+ if (mIsMoving) {
+ DebugOnly<nsresult> rvIgnored = mPositioningShadow->SetAttr(
+ kNameSpaceID_None, nsGkAtoms::_class, u"hidden"_ns, true);
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rvIgnored),
+ "Element::SetAttr(nsGkAtoms::_class, hidden) failed");
+ if (rv != NS_ERROR_EDITOR_ACTION_CANCELED) {
+ SetFinalPosition(aClientPoint.x, aClientPoint.y);
+ }
+ }
+ if (mGrabberClicked) {
+ DebugOnly<nsresult> rvIgnored = EndMoving();
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+ "HTMLEditor::EndMoving() failed");
+ }
+ return EditorBase::ToGenericNSResult(rv);
+ }
+
+ return NS_OK;
+}
+
+void HTMLEditor::SetResizeIncrements(int32_t aX, int32_t aY, int32_t aW,
+ int32_t aH, bool aPreserveRatio) {
+ mXIncrementFactor = aX;
+ mYIncrementFactor = aY;
+ mWidthIncrementFactor = aW;
+ mHeightIncrementFactor = aH;
+ mPreserveRatio = aPreserveRatio;
+}
+
+nsresult HTMLEditor::SetResizingInfoPosition(int32_t aX, int32_t aY, int32_t aW,
+ int32_t aH) {
+ // Determine the position of the resizing info box based upon the new
+ // position and size of the element (aX, aY, aW, aH), and which
+ // resizer is the "activated handle". For example, place the resizing
+ // info box at the bottom-right corner of the new element, if the element
+ // is being resized by the bottom-right resizer.
+ int32_t infoXPosition;
+ int32_t infoYPosition;
+
+ if (mActivatedHandle == mTopLeftHandle || mActivatedHandle == mLeftHandle ||
+ mActivatedHandle == mBottomLeftHandle) {
+ infoXPosition = aX;
+ } else if (mActivatedHandle == mTopHandle ||
+ mActivatedHandle == mBottomHandle) {
+ infoXPosition = aX + (aW / 2);
+ } else {
+ // should only occur when mActivatedHandle is one of the 3 right-side
+ // handles, but this is a reasonable default if it isn't any of them (?)
+ infoXPosition = aX + aW;
+ }
+
+ if (mActivatedHandle == mTopLeftHandle || mActivatedHandle == mTopHandle ||
+ mActivatedHandle == mTopRightHandle) {
+ infoYPosition = aY;
+ } else if (mActivatedHandle == mLeftHandle ||
+ mActivatedHandle == mRightHandle) {
+ infoYPosition = aY + (aH / 2);
+ } else {
+ // should only occur when mActivatedHandle is one of the 3 bottom-side
+ // handles, but this is a reasonable default if it isn't any of them (?)
+ infoYPosition = aY + aH;
+ }
+
+ // Offset info box by 20 so it's not directly under the mouse cursor.
+ const int mouseCursorOffset = 20;
+ if (RefPtr<nsStyledElement> resizingInfoStyledElement =
+ nsStyledElement::FromNodeOrNull(mResizingInfo.get())) {
+ nsresult rv;
+ rv = mCSSEditUtils->SetCSSPropertyPixelsWithoutTransaction(
+ *resizingInfoStyledElement, *nsGkAtoms::left,
+ infoXPosition + mouseCursorOffset);
+ if (rv == NS_ERROR_EDITOR_DESTROYED) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::left) "
+ "destroyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::left) "
+ "failed, but ignored");
+ rv = mCSSEditUtils->SetCSSPropertyPixelsWithoutTransaction(
+ *resizingInfoStyledElement, *nsGkAtoms::top,
+ infoYPosition + mouseCursorOffset);
+ if (rv == NS_ERROR_EDITOR_DESTROYED) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::top) "
+ "destroyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::top) "
+ "failed, but ignored");
+ }
+
+ nsCOMPtr<nsIContent> textInfo = mResizingInfo->GetFirstChild();
+ ErrorResult error;
+ if (textInfo) {
+ mResizingInfo->RemoveChild(*textInfo, error);
+ if (error.Failed()) {
+ NS_WARNING("nsINode::RemoveChild() failed");
+ return error.StealNSResult();
+ }
+ textInfo = nullptr;
+ }
+
+ nsAutoString widthStr, heightStr, diffWidthStr, diffHeightStr;
+ widthStr.AppendInt(aW);
+ heightStr.AppendInt(aH);
+ int32_t diffWidth = aW - mResizedObjectWidth;
+ int32_t diffHeight = aH - mResizedObjectHeight;
+ if (diffWidth > 0) {
+ diffWidthStr.Assign('+');
+ }
+ if (diffHeight > 0) {
+ diffHeightStr.Assign('+');
+ }
+ diffWidthStr.AppendInt(diffWidth);
+ diffHeightStr.AppendInt(diffHeight);
+
+ nsAutoString info(widthStr + u" x "_ns + heightStr + u" ("_ns + diffWidthStr +
+ u", "_ns + diffHeightStr + u")"_ns);
+
+ RefPtr<Document> document = GetDocument();
+ textInfo = document->CreateTextNode(info);
+ if (!textInfo) {
+ NS_WARNING("Document::CreateTextNode() failed");
+ return NS_ERROR_FAILURE;
+ }
+ mResizingInfo->AppendChild(*textInfo, error);
+ if (error.Failed()) {
+ NS_WARNING("nsINode::AppendChild() failed");
+ return error.StealNSResult();
+ }
+
+ nsresult rv =
+ mResizingInfo->UnsetAttr(kNameSpaceID_None, nsGkAtoms::_class, true);
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "Element::UnsetAttr(nsGkAtoms::_class) failed");
+ return rv;
+}
+
+nsresult HTMLEditor::SetShadowPosition(Element& aShadowElement,
+ Element& aElement, int32_t aElementX,
+ int32_t aElementY) {
+ MOZ_ASSERT(&aShadowElement == mResizingShadow ||
+ &aShadowElement == mPositioningShadow);
+ RefPtr<Element> handlingShadowElement = &aShadowElement == mResizingShadow
+ ? mResizingShadow.get()
+ : mPositioningShadow.get();
+
+ if (nsStyledElement* styledShadowElement =
+ nsStyledElement::FromNode(&aShadowElement)) {
+ // MOZ_KnownLive(*styledShadowElement): It's aShadowElement whose lifetime
+ // must be guaranteed by caller because of MOZ_CAN_RUN_SCRIPT method.
+ nsresult rv = SetAnonymousElementPositionWithoutTransaction(
+ MOZ_KnownLive(*styledShadowElement), aElementX, aElementY);
+ if (NS_FAILED(rv)) {
+ NS_WARNING(
+ "HTMLEditor::SetAnonymousElementPositionWithoutTransaction() "
+ "failed");
+ return rv;
+ }
+ }
+
+ if (!HTMLEditUtils::IsImage(&aElement)) {
+ return NS_OK;
+ }
+
+ nsAutoString imageSource;
+ aElement.GetAttr(kNameSpaceID_None, nsGkAtoms::src, imageSource);
+ nsresult rv = aShadowElement.SetAttr(kNameSpaceID_None, nsGkAtoms::src,
+ imageSource, true);
+ if (NS_WARN_IF(Destroyed())) {
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ if (NS_FAILED(rv)) {
+ NS_WARNING("Element::SetAttr(nsGkAtoms::src) failed");
+ return NS_ERROR_FAILURE;
+ }
+ return NS_WARN_IF(&aShadowElement != handlingShadowElement) ? NS_ERROR_FAILURE
+ : NS_OK;
+}
+
+int32_t HTMLEditor::GetNewResizingIncrement(int32_t aX, int32_t aY,
+ ResizeAt aResizeAt) {
+ int32_t result = 0;
+ if (!mPreserveRatio) {
+ switch (aResizeAt) {
+ case ResizeAt::eX:
+ case ResizeAt::eWidth:
+ result = aX - mOriginalX;
+ break;
+ case ResizeAt::eY:
+ case ResizeAt::eHeight:
+ result = aY - mOriginalY;
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("Invalid resizing request");
+ }
+ return result;
+ }
+
+ int32_t xi = (aX - mOriginalX) * mWidthIncrementFactor;
+ int32_t yi = (aY - mOriginalY) * mHeightIncrementFactor;
+ float objectSizeRatio =
+ ((float)mResizedObjectWidth) / ((float)mResizedObjectHeight);
+ result = (xi > yi) ? xi : yi;
+ switch (aResizeAt) {
+ case ResizeAt::eX:
+ case ResizeAt::eWidth:
+ if (result == yi) result = (int32_t)(((float)result) * objectSizeRatio);
+ result = (int32_t)(((float)result) * mWidthIncrementFactor);
+ break;
+ case ResizeAt::eY:
+ case ResizeAt::eHeight:
+ if (result == xi) result = (int32_t)(((float)result) / objectSizeRatio);
+ result = (int32_t)(((float)result) * mHeightIncrementFactor);
+ break;
+ }
+ return result;
+}
+
+int32_t HTMLEditor::GetNewResizingX(int32_t aX, int32_t aY) {
+ int32_t resized =
+ mResizedObjectX +
+ GetNewResizingIncrement(aX, aY, ResizeAt::eX) * mXIncrementFactor;
+ int32_t max = mResizedObjectX + mResizedObjectWidth;
+ return std::min(resized, max);
+}
+
+int32_t HTMLEditor::GetNewResizingY(int32_t aX, int32_t aY) {
+ int32_t resized =
+ mResizedObjectY +
+ GetNewResizingIncrement(aX, aY, ResizeAt::eY) * mYIncrementFactor;
+ int32_t max = mResizedObjectY + mResizedObjectHeight;
+ return std::min(resized, max);
+}
+
+int32_t HTMLEditor::GetNewResizingWidth(int32_t aX, int32_t aY) {
+ int32_t resized =
+ mResizedObjectWidth +
+ GetNewResizingIncrement(aX, aY, ResizeAt::eWidth) * mWidthIncrementFactor;
+ return std::max(resized, 1);
+}
+
+int32_t HTMLEditor::GetNewResizingHeight(int32_t aX, int32_t aY) {
+ int32_t resized = mResizedObjectHeight +
+ GetNewResizingIncrement(aX, aY, ResizeAt::eHeight) *
+ mHeightIncrementFactor;
+ return std::max(resized, 1);
+}
+
+nsresult HTMLEditor::UpdateResizerOrGrabberPositionTo(
+ const CSSIntPoint& aClientPoint) {
+ if (mIsResizing) {
+ AutoEditActionDataSetter editActionData(*this,
+ EditAction::eResizingElement);
+ if (NS_WARN_IF(!editActionData.CanHandle())) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ // we are resizing and the mouse pointer's position has changed
+ // we have to resdisplay the shadow
+ const int32_t newX = GetNewResizingX(aClientPoint.x, aClientPoint.y);
+ const int32_t newY = GetNewResizingY(aClientPoint.x, aClientPoint.y);
+ const int32_t newWidth =
+ GetNewResizingWidth(aClientPoint.x, aClientPoint.y);
+ const int32_t newHeight =
+ GetNewResizingHeight(aClientPoint.x, aClientPoint.y);
+
+ if (RefPtr<nsStyledElement> resizingShadowStyledElement =
+ nsStyledElement::FromNodeOrNull(mResizingShadow.get())) {
+ nsresult rv;
+ rv = mCSSEditUtils->SetCSSPropertyPixelsWithoutTransaction(
+ *resizingShadowStyledElement, *nsGkAtoms::left, newX);
+ if (rv == NS_ERROR_EDITOR_DESTROYED) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::left)"
+ " destroyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::left) "
+ "failed, but ignored");
+ rv = mCSSEditUtils->SetCSSPropertyPixelsWithoutTransaction(
+ *resizingShadowStyledElement, *nsGkAtoms::top, newY);
+ if (rv == NS_ERROR_EDITOR_DESTROYED) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::top)"
+ " destroyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::top) "
+ "failed, but ignored");
+ rv = mCSSEditUtils->SetCSSPropertyPixelsWithoutTransaction(
+ *resizingShadowStyledElement, *nsGkAtoms::width, newWidth);
+ if (rv == NS_ERROR_EDITOR_DESTROYED) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::"
+ "width) destroyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::width) "
+ "failed, but ignored");
+ rv = mCSSEditUtils->SetCSSPropertyPixelsWithoutTransaction(
+ *resizingShadowStyledElement, *nsGkAtoms::height, newHeight);
+ if (rv == NS_ERROR_EDITOR_DESTROYED) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::"
+ "height) destroyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::height)"
+ " failed, but ignored");
+ }
+
+ nsresult rv = SetResizingInfoPosition(newX, newY, newWidth, newHeight);
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "HTMLEditor::SetResizingInfoPosition() failed");
+ return rv;
+ }
+
+ AutoEditActionDataSetter editActionData(*this, EditAction::eMovingElement);
+ if (NS_WARN_IF(!editActionData.CanHandle())) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ if (mGrabberClicked) {
+ int32_t xThreshold =
+ LookAndFeel::GetInt(LookAndFeel::IntID::DragThresholdX, 1);
+ int32_t yThreshold =
+ LookAndFeel::GetInt(LookAndFeel::IntID::DragThresholdY, 1);
+
+ if (DeprecatedAbs(aClientPoint.x - mOriginalX) * 2 >= xThreshold ||
+ DeprecatedAbs(aClientPoint.y - mOriginalY) * 2 >= yThreshold) {
+ mGrabberClicked = false;
+ DebugOnly<nsresult> rvIgnored = StartMoving();
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+ "HTMLEditor::StartMoving() failed, but ignored");
+ }
+ }
+ if (mIsMoving) {
+ int32_t newX = mPositionedObjectX + aClientPoint.x - mOriginalX;
+ int32_t newY = mPositionedObjectY + aClientPoint.y - mOriginalY;
+
+ // Maybe align newX and newY to the grid.
+ SnapToGrid(newX, newY);
+
+ if (RefPtr<nsStyledElement> positioningShadowStyledElement =
+ nsStyledElement::FromNodeOrNull(mPositioningShadow.get())) {
+ nsresult rv;
+ rv = mCSSEditUtils->SetCSSPropertyPixelsWithoutTransaction(
+ *positioningShadowStyledElement, *nsGkAtoms::left, newX);
+ if (rv == NS_ERROR_EDITOR_DESTROYED) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::left)"
+ " destroyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::left) "
+ "failed, but ignored");
+ rv = mCSSEditUtils->SetCSSPropertyPixelsWithoutTransaction(
+ *positioningShadowStyledElement, *nsGkAtoms::top, newY);
+ if (rv == NS_ERROR_EDITOR_DESTROYED) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::top) "
+ "destroyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::top) "
+ "failed, but ignored");
+ }
+ }
+ return NS_OK;
+}
+
+nsresult HTMLEditor::SetFinalSizeWithTransaction(int32_t aX, int32_t aY) {
+ if (!mResizedObject) {
+ // paranoia
+ return NS_OK;
+ }
+
+ if (mActivatedHandle) {
+ DebugOnly<nsresult> rvIgnored = mActivatedHandle->UnsetAttr(
+ kNameSpaceID_None, nsGkAtoms::_moz_activated, true);
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rvIgnored),
+ "Element::UnsetAttr(nsGkAtoms::_moz_activated) failed, but ignored");
+ mActivatedHandle = nullptr;
+ }
+
+ // we have now to set the new width and height of the resized object
+ // we don't set the x and y position because we don't control that in
+ // a normal HTML layout
+ int32_t left = GetNewResizingX(aX, aY);
+ int32_t top = GetNewResizingY(aX, aY);
+ int32_t width = GetNewResizingWidth(aX, aY);
+ int32_t height = GetNewResizingHeight(aX, aY);
+ bool setWidth =
+ !mResizedObjectIsAbsolutelyPositioned || (width != mResizedObjectWidth);
+ bool setHeight =
+ !mResizedObjectIsAbsolutelyPositioned || (height != mResizedObjectHeight);
+
+ int32_t x, y;
+ x = left - ((mResizedObjectIsAbsolutelyPositioned)
+ ? mResizedObjectBorderLeft + mResizedObjectMarginLeft
+ : 0);
+ y = top - ((mResizedObjectIsAbsolutelyPositioned)
+ ? mResizedObjectBorderTop + mResizedObjectMarginTop
+ : 0);
+
+ // we want one transaction only from a user's point of view
+ AutoPlaceholderBatch treatAsOneTransaction(*this,
+ ScrollSelectionIntoView::Yes);
+ RefPtr<Element> resizedElement(mResizedObject);
+ RefPtr<nsStyledElement> resizedStyleElement =
+ nsStyledElement::FromNodeOrNull(mResizedObject);
+
+ if (mResizedObjectIsAbsolutelyPositioned && resizedStyleElement) {
+ if (setHeight) {
+ nsresult rv = mCSSEditUtils->SetCSSPropertyPixelsWithTransaction(
+ *resizedStyleElement, *nsGkAtoms::top, y);
+ if (rv == NS_ERROR_EDITOR_DESTROYED) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::"
+ "top) destoyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::top) "
+ "failed, but ignored");
+ }
+ if (setWidth) {
+ nsresult rv = mCSSEditUtils->SetCSSPropertyPixelsWithTransaction(
+ *resizedStyleElement, *nsGkAtoms::left, x);
+ if (rv == NS_ERROR_EDITOR_DESTROYED) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::"
+ "left) destoyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::left)"
+ " "
+ "failed, but ignored");
+ }
+ }
+ if (IsCSSEnabled() || mResizedObjectIsAbsolutelyPositioned) {
+ if (setWidth &&
+ resizedElement->HasAttr(kNameSpaceID_None, nsGkAtoms::width)) {
+ DebugOnly<nsresult> rvIgnored =
+ RemoveAttributeWithTransaction(*resizedElement, *nsGkAtoms::width);
+ if (NS_WARN_IF(Destroyed())) {
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rvIgnored),
+ "EditorBase::RemoveAttributeWithTransaction(nsGkAtoms::width) "
+ "failed, but ignored");
+ }
+
+ if (setHeight &&
+ resizedElement->HasAttr(kNameSpaceID_None, nsGkAtoms::height)) {
+ DebugOnly<nsresult> rvIgnored =
+ RemoveAttributeWithTransaction(*resizedElement, *nsGkAtoms::height);
+ if (NS_WARN_IF(Destroyed())) {
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rvIgnored),
+ "EditorBase::RemoveAttributeWithTransaction(nsGkAtoms::height) "
+ "failed, but ignored");
+ }
+
+ if (resizedStyleElement) {
+ if (setWidth) {
+ nsresult rv = mCSSEditUtils->SetCSSPropertyPixelsWithTransaction(
+ *resizedStyleElement, *nsGkAtoms::width, width);
+ if (NS_FAILED(rv)) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::"
+ "width) destoyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixels(nsGkAtoms::width) "
+ "failed, but ignored");
+ }
+ if (setHeight) {
+ nsresult rv = mCSSEditUtils->SetCSSPropertyPixelsWithTransaction(
+ *resizedStyleElement, *nsGkAtoms::height, height);
+ if (NS_FAILED(rv)) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::"
+ "height) destoyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixels(nsGkAtoms::height) "
+ "failed, but ignored");
+ }
+ }
+ } else {
+ // we use HTML size and remove all equivalent CSS properties
+
+ // we set the CSS width and height to remove it later,
+ // triggering an immediate reflow; otherwise, we have problems
+ // with asynchronous reflow
+ if (resizedStyleElement) {
+ if (setWidth) {
+ nsresult rv = mCSSEditUtils->SetCSSPropertyPixelsWithTransaction(
+ *resizedStyleElement, *nsGkAtoms::width, width);
+ if (NS_FAILED(rv)) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::"
+ "width) destoyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::"
+ "width) failed, but ignored");
+ }
+ if (setHeight) {
+ nsresult rv = mCSSEditUtils->SetCSSPropertyPixelsWithTransaction(
+ *resizedStyleElement, *nsGkAtoms::height, height);
+ if (NS_FAILED(rv)) {
+ NS_WARNING(
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::"
+ "height) destoyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::SetCSSPropertyPixelsWithTransaction(nsGkAtoms::"
+ "height) failed, but ignored");
+ }
+ }
+ if (setWidth) {
+ nsAutoString w;
+ w.AppendInt(width);
+ DebugOnly<nsresult> rvIgnored =
+ SetAttributeWithTransaction(*resizedElement, *nsGkAtoms::width, w);
+ if (NS_WARN_IF(Destroyed())) {
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rvIgnored),
+ "EditorBase::SetAttributeWithTransaction(nsGkAtoms::width) "
+ "failed, but ignored");
+ }
+ if (setHeight) {
+ nsAutoString h;
+ h.AppendInt(height);
+ DebugOnly<nsresult> rvIgnored =
+ SetAttributeWithTransaction(*resizedElement, *nsGkAtoms::height, h);
+ if (NS_WARN_IF(Destroyed())) {
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rvIgnored),
+ "EditorBase::SetAttributeWithTransaction(nsGkAtoms::height) "
+ "failed, but ignored");
+ }
+
+ if (resizedStyleElement) {
+ if (setWidth) {
+ nsresult rv = mCSSEditUtils->RemoveCSSPropertyWithTransaction(
+ *resizedStyleElement, *nsGkAtoms::width, u""_ns);
+ if (rv == NS_ERROR_EDITOR_DESTROYED) {
+ NS_WARNING(
+ "CSSEditUtils::RemoveCSSPropertyWithTransaction(nsGkAtoms::width)"
+ " destroyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::RemoveCSSPropertyWithTransaction(nsGkAtoms::width) "
+ "failed, but ignored");
+ }
+ if (setHeight) {
+ nsresult rv = mCSSEditUtils->RemoveCSSPropertyWithTransaction(
+ *resizedStyleElement, *nsGkAtoms::height, u""_ns);
+ if (rv == NS_ERROR_EDITOR_DESTROYED) {
+ NS_WARNING(
+ "CSSEditUtils::RemoveCSSPropertyWithTransaction(nsGkAtoms::"
+ "height) destroyed the editor");
+ return NS_ERROR_EDITOR_DESTROYED;
+ }
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rv),
+ "CSSEditUtils::RemoveCSSPropertyWithTransaction(nsGkAtoms::height) "
+ "failed, but ignored");
+ }
+ }
+ }
+
+ // keep track of that size
+ mResizedObjectWidth = width;
+ mResizedObjectHeight = height;
+
+ DebugOnly<nsresult> rvIgnored = RefreshResizersInternal();
+ NS_WARNING_ASSERTION(
+ NS_SUCCEEDED(rvIgnored),
+ "HTMLEditor::RefreshResizersInternal() failed, but ignored");
+ return NS_WARN_IF(Destroyed()) ? NS_ERROR_EDITOR_DESTROYED : NS_OK;
+}
+
+NS_IMETHODIMP HTMLEditor::GetObjectResizingEnabled(
+ bool* aIsObjectResizingEnabled) {
+ *aIsObjectResizingEnabled = IsObjectResizerEnabled();
+ return NS_OK;
+}
+
+NS_IMETHODIMP HTMLEditor::SetObjectResizingEnabled(
+ bool aObjectResizingEnabled) {
+ EnableObjectResizer(aObjectResizingEnabled);
+ return NS_OK;
+}
+
+#undef kTopLeft
+#undef kTop
+#undef kTopRight
+#undef kLeft
+#undef kRight
+#undef kBottomLeft
+#undef kBottom
+#undef kBottomRight
+
+} // namespace mozilla
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 22:03:44 +0000