diff options
Diffstat (limited to 'dom/xul/XULResizerElement.cpp')
| -rw-r--r-- | dom/xul/XULResizerElement.cpp | 354 |
1 files changed, 354 insertions, 0 deletions
diff --git a/dom/xul/XULResizerElement.cpp b/dom/xul/XULResizerElement.cpp new file mode 100644 index 0000000000..a0dbb485d5 --- /dev/null +++ b/dom/xul/XULResizerElement.cpp @@ -0,0 +1,354 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/XULResizerElement.h" +#include "mozilla/dom/XULResizerElementBinding.h" + +#include "mozilla/EventDispatcher.h" +#include "mozilla/PresShell.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/DocumentInlines.h" +#include "mozilla/MouseEvents.h" +#include "nsContentUtils.h" +#include "nsICSSDeclaration.h" +#include "nsIFrame.h" +#include "nsLayoutUtils.h" +#include "nsPresContext.h" +#include "nsStyledElement.h" + +namespace mozilla::dom { + +nsXULElement* NS_NewXULResizerElement( + already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo) { + RefPtr<mozilla::dom::NodeInfo> nodeInfo(aNodeInfo); + auto* nim = nodeInfo->NodeInfoManager(); + return new (nim) XULResizerElement(nodeInfo.forget()); +} + +static bool GetEventPoint(const WidgetGUIEvent* aEvent, + LayoutDeviceIntPoint& aPoint) { + NS_ENSURE_TRUE(aEvent, false); + + const WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent(); + if (touchEvent) { + // return false if there is more than one touch on the page, or if + // we can't find a touch point + if (touchEvent->mTouches.Length() != 1) { + return false; + } + + const dom::Touch* touch = touchEvent->mTouches.SafeElementAt(0); + if (!touch) { + return false; + } + aPoint = touch->mRefPoint; + } else { + aPoint = aEvent->mRefPoint; + } + return true; +} + +JSObject* XULResizerElement::WrapNode(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return XULResizerElement_Binding::Wrap(aCx, this, aGivenProto); +} + +XULResizerElement::Direction XULResizerElement::GetDirection() { + static const mozilla::dom::Element::AttrValuesArray strings[] = { + // clang-format off + nsGkAtoms::topleft, nsGkAtoms::top, nsGkAtoms::topright, + nsGkAtoms::left, nsGkAtoms::right, + nsGkAtoms::bottomleft, nsGkAtoms::bottom, nsGkAtoms::bottomright, + nsGkAtoms::bottomstart, nsGkAtoms::bottomend, + nullptr + // clang-format on + }; + + static const Direction directions[] = { + // clang-format off + {-1, -1}, {0, -1}, {1, -1}, + {-1, 0}, {1, 0}, + {-1, 1}, {0, 1}, {1, 1}, + {-1, 1}, {1, 1} + // clang-format on + }; + + const auto* frame = GetPrimaryFrame(); + if (!frame) { + return directions[0]; // default: topleft + } + + int32_t index = + FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::dir, strings, eCaseMatters); + if (index < 0) { + return directions[0]; // default: topleft + } + + if (index >= 8) { + // Directions 8 and higher are RTL-aware directions and should reverse the + // horizontal component if RTL. + auto wm = frame->GetWritingMode(); + if (wm.IsPhysicalRTL()) { + Direction direction = directions[index]; + direction.mHorizontal *= -1; + return direction; + } + } + + return directions[index]; +} + +nsresult XULResizerElement::PostHandleEvent(EventChainPostVisitor& aVisitor) { + if (aVisitor.mEventStatus != nsEventStatus_eConsumeNoDefault) { + PostHandleEventInternal(aVisitor); + } + return nsXULElement::PostHandleEvent(aVisitor); +} + +Maybe<nsSize> XULResizerElement::GetCurrentSize() const { + nsIContent* contentToResize = GetContentToResize(); + if (!contentToResize) { + return Nothing(); + } + nsIFrame* frame = contentToResize->GetPrimaryFrame(); + if (!frame) { + return Nothing(); + } + return Some(frame->StylePosition()->mBoxSizing == StyleBoxSizing::Content + ? frame->GetContentRect().Size() + : frame->GetRect().Size()); +} + +void XULResizerElement::PostHandleEventInternal( + EventChainPostVisitor& aVisitor) { + bool doDefault = true; + const WidgetEvent& event = *aVisitor.mEvent; + switch (event.mMessage) { + case eTouchStart: + case eMouseDown: { + if (event.mClass == eTouchEventClass || + (event.mClass == eMouseEventClass && + event.AsMouseEvent()->mButton == MouseButton::ePrimary)) { + auto size = GetCurrentSize(); + if (!size) { + break; // don't do anything if there's nothing to resize + } + // cache the content rectangle for the frame to resize + mMouseDownSize = *size; + + // remember current mouse coordinates + auto* guiEvent = event.AsGUIEvent(); + if (!GetEventPoint(guiEvent, mMouseDownPoint)) { + break; + } + mTrackingMouseMove = true; + PresShell::SetCapturingContent(this, CaptureFlags::IgnoreAllowedState); + doDefault = false; + } + } break; + + case eTouchMove: + case eMouseMove: { + if (mTrackingMouseMove) { + nsCOMPtr<nsIContent> contentToResize = GetContentToResize(); + if (!contentToResize) { + break; // don't do anything if there's nothing to resize + } + nsIFrame* frame = contentToResize->GetPrimaryFrame(); + if (!frame) { + break; + } + + // both MouseMove and direction are negative when pointing to the + // top and left, and positive when pointing to the bottom and right + + // retrieve the offset of the mousemove event relative to the mousedown. + // The difference is how much the resize needs to be + LayoutDeviceIntPoint refPoint; + auto* guiEvent = event.AsGUIEvent(); + if (!GetEventPoint(guiEvent, refPoint)) { + break; + } + + const nsPoint oldPos = nsLayoutUtils::GetEventCoordinatesRelativeTo( + guiEvent->mWidget, mMouseDownPoint, RelativeTo{frame}); + const nsPoint newPos = nsLayoutUtils::GetEventCoordinatesRelativeTo( + guiEvent->mWidget, refPoint, RelativeTo{frame}); + + nsPoint mouseMove(newPos - oldPos); + + // Determine which direction to resize by checking the dir attribute. + // For windows and menus, ensure that it can be resized in that + // direction. + Direction direction = GetDirection(); + + const CSSIntSize newSize = [&] { + nsSize newAuSize = mMouseDownSize; + // Check if there are any size constraints on this window. + newAuSize.width += direction.mHorizontal * mouseMove.x; + newAuSize.height += direction.mVertical * mouseMove.y; + if (newAuSize.width < AppUnitsPerCSSPixel() && mouseMove.x != 0) { + newAuSize.width = AppUnitsPerCSSPixel(); + } + if (newAuSize.height < AppUnitsPerCSSPixel() && mouseMove.y != 0) { + newAuSize.height = AppUnitsPerCSSPixel(); + } + + // When changing the size in a direction, don't allow the new size to + // be less that the resizer's size. This ensures that content isn't + // resized too small as to make the resizer invisible. + if (auto* resizerFrame = GetPrimaryFrame()) { + nsRect resizerRect = resizerFrame->GetRect(); + if (newAuSize.width < resizerRect.width && mouseMove.x != 0) { + newAuSize.width = resizerRect.width; + } + if (newAuSize.height < resizerRect.height && mouseMove.y != 0) { + newAuSize.height = resizerRect.height; + } + } + + // Convert the rectangle into css pixels. + return CSSIntSize::FromAppUnitsRounded(newAuSize); + }(); + + // Only resize in a given direction if the new size doesn't match the + // current size. + if (auto currentSize = GetCurrentSize()) { + auto newAuSize = CSSIntSize::ToAppUnits(newSize); + if (newAuSize.width == currentSize->width) { + direction.mHorizontal = 0; + } + if (newAuSize.height == currentSize->height) { + direction.mVertical = 0; + } + } + + SizeInfo sizeInfo, originalSizeInfo; + sizeInfo.width.AppendInt(newSize.width); + sizeInfo.height.AppendInt(newSize.height); + ResizeContent(contentToResize, direction, sizeInfo, &originalSizeInfo); + MaybePersistOriginalSize(contentToResize, originalSizeInfo); + + doDefault = false; + } + } break; + + case eMouseClick: { + auto* mouseEvent = event.AsMouseEvent(); + if (mouseEvent->IsLeftClickEvent()) { + // Execute the oncommand event handler. + nsContentUtils::DispatchXULCommand( + this, false, nullptr, nullptr, mouseEvent->IsControl(), + mouseEvent->IsAlt(), mouseEvent->IsShift(), mouseEvent->IsMeta(), + mouseEvent->mInputSource, mouseEvent->mButton); + } + } break; + + case eTouchEnd: + case eMouseUp: { + if (event.mClass == eTouchEventClass || + (event.mClass == eMouseEventClass && + event.AsMouseEvent()->mButton == MouseButton::ePrimary)) { + mTrackingMouseMove = false; + PresShell::ReleaseCapturingContent(); + doDefault = false; + } + } break; + + case eMouseDoubleClick: { + if (event.AsMouseEvent()->mButton == MouseButton::ePrimary) { + if (nsIContent* contentToResize = GetContentToResize()) { + RestoreOriginalSize(contentToResize); + } + } + } break; + + default: + break; + } + + if (!doDefault) { + aVisitor.mEventStatus = nsEventStatus_eConsumeNoDefault; + } +} + +nsIContent* XULResizerElement::GetContentToResize() const { + if (!IsInComposedDoc()) { + return nullptr; + } + // Return the parent, but skip over native anonymous content + nsIContent* parent = GetParent(); + return parent ? parent->FindFirstNonChromeOnlyAccessContent() : nullptr; +} + +/* static */ +void XULResizerElement::ResizeContent(nsIContent* aContent, + const Direction& aDirection, + const SizeInfo& aSizeInfo, + SizeInfo* aOriginalSizeInfo) { + RefPtr inlineStyleContent = nsStyledElement::FromNode(aContent); + if (!inlineStyleContent) { + return; + } + nsCOMPtr<nsICSSDeclaration> decl = inlineStyleContent->Style(); + if (aOriginalSizeInfo) { + decl->GetPropertyValue("width"_ns, aOriginalSizeInfo->width); + decl->GetPropertyValue("height"_ns, aOriginalSizeInfo->height); + } + + // only set the property if the element could have changed in that + // direction + if (aDirection.mHorizontal) { + nsAutoCString widthstr(aSizeInfo.width); + if (!widthstr.IsEmpty() && !StringEndsWith(widthstr, "px"_ns)) { + widthstr.AppendLiteral("px"); + } + decl->SetProperty("width"_ns, widthstr, ""_ns, IgnoreErrors()); + } + + if (aDirection.mVertical) { + nsAutoCString heightstr(aSizeInfo.height); + if (!heightstr.IsEmpty() && !StringEndsWith(heightstr, "px"_ns)) { + heightstr.AppendLiteral("px"); + } + decl->SetProperty("height"_ns, heightstr, ""_ns, IgnoreErrors()); + } +} + +/* static */ +void XULResizerElement::MaybePersistOriginalSize(nsIContent* aContent, + const SizeInfo& aSizeInfo) { + nsresult rv; + aContent->GetProperty(nsGkAtoms::_moz_original_size, &rv); + if (rv != NS_PROPTABLE_PROP_NOT_THERE) { + return; + } + + UniquePtr<SizeInfo> sizeInfo(new SizeInfo(aSizeInfo)); + rv = aContent->SetProperty( + nsGkAtoms::_moz_original_size, sizeInfo.get(), + nsINode::DeleteProperty<XULResizerElement::SizeInfo>); + if (NS_SUCCEEDED(rv)) { + Unused << sizeInfo.release(); + } +} + +/* static */ +void XULResizerElement::RestoreOriginalSize(nsIContent* aContent) { + nsresult rv; + SizeInfo* sizeInfo = static_cast<SizeInfo*>( + aContent->GetProperty(nsGkAtoms::_moz_original_size, &rv)); + if (NS_FAILED(rv)) { + return; + } + + NS_ASSERTION(sizeInfo, "We set a null sizeInfo!?"); + Direction direction = {1, 1}; + ResizeContent(aContent, direction, *sizeInfo, nullptr); + aContent->RemoveProperty(nsGkAtoms::_moz_original_size); +} + +} // namespace mozilla::dom |