Add m-esr52 at 52.6.0

1 files changed, 538 insertions, 0 deletions

diff --git a/layout/xul/nsResizerFrame.cpp b/layout/xul/nsResizerFrame.cpp
new file mode 100644
index 000000000..b32b84fe5
--- /dev/null
+++ b/layout/xul/nsResizerFrame.cpp
@@ -0,0 +1,538 @@
+/* -*- 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 "nsAutoPtr.h"
+#include "nsCOMPtr.h"
+#include "nsIServiceManager.h"
+#include "nsResizerFrame.h"
+#include "nsIContent.h"
+#include "nsIDocument.h"
+#include "nsIDOMNodeList.h"
+#include "nsGkAtoms.h"
+#include "nsNameSpaceManager.h"
+#include "nsIDOMCSSStyleDeclaration.h"
+
+#include "nsPresContext.h"
+#include "nsFrameManager.h"
+#include "nsIDocShell.h"
+#include "nsIDocShellTreeOwner.h"
+#include "nsIBaseWindow.h"
+#include "nsPIDOMWindow.h"
+#include "mozilla/MouseEvents.h"
+#include "nsContentUtils.h"
+#include "nsMenuPopupFrame.h"
+#include "nsIScreenManager.h"
+#include "mozilla/dom/Element.h"
+#include "nsError.h"
+#include "nsICSSDeclaration.h"
+#include "nsStyledElement.h"
+#include <algorithm>
+
+using namespace mozilla;
+
+//
+// NS_NewResizerFrame
+//
+// Creates a new Resizer frame and returns it
+//
+nsIFrame*
+NS_NewResizerFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+  return new (aPresShell) nsResizerFrame(aContext);
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsResizerFrame)
+
+nsResizerFrame::nsResizerFrame(nsStyleContext* aContext)
+:nsTitleBarFrame(aContext)
+{
+}
+
+nsresult
+nsResizerFrame::HandleEvent(nsPresContext* aPresContext,
+                            WidgetGUIEvent* aEvent,
+                            nsEventStatus* aEventStatus)
+{
+  NS_ENSURE_ARG_POINTER(aEventStatus);
+  if (nsEventStatus_eConsumeNoDefault == *aEventStatus) {
+    return NS_OK;
+  }
+
+  nsWeakFrame weakFrame(this);
+  bool doDefault = true;
+
+  switch (aEvent->mMessage) {
+    case eTouchStart:
+    case eMouseDown: {
+      if (aEvent->mClass == eTouchEventClass ||
+          (aEvent->mClass == eMouseEventClass &&
+           aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton)) {
+        nsCOMPtr<nsIBaseWindow> window;
+        nsIPresShell* presShell = aPresContext->GetPresShell();
+        nsIContent* contentToResize =
+          GetContentToResize(presShell, getter_AddRefs(window));
+        if (contentToResize) {
+          nsIFrame* frameToResize = contentToResize->GetPrimaryFrame();
+          if (!frameToResize)
+            break;
+
+          // cache the content rectangle for the frame to resize
+          // GetScreenRectInAppUnits returns the border box rectangle, so
+          // adjust to get the desired content rectangle.
+          nsRect rect = frameToResize->GetScreenRectInAppUnits();
+          if (frameToResize->StylePosition()->mBoxSizing == StyleBoxSizing::Content) {
+            rect.Deflate(frameToResize->GetUsedBorderAndPadding());
+          }
+
+          mMouseDownRect =
+            LayoutDeviceIntRect::FromAppUnitsToNearest(rect, aPresContext->AppUnitsPerDevPixel());
+          doDefault = false;
+        }
+        else {
+          // If there is no window, then resizing isn't allowed.
+          if (!window)
+            break;
+
+          doDefault = false;
+
+          // ask the widget implementation to begin a resize drag if it can
+          Direction direction = GetDirection();
+          nsresult rv = aEvent->mWidget->BeginResizeDrag(aEvent,
+                        direction.mHorizontal, direction.mVertical);
+          // for native drags, don't set the fields below
+          if (rv != NS_ERROR_NOT_IMPLEMENTED)
+             break;
+             
+          // if there's no native resize support, we need to do window
+          // resizing ourselves
+          window->GetPositionAndSize(&mMouseDownRect.x, &mMouseDownRect.y,
+                                     &mMouseDownRect.width, &mMouseDownRect.height);
+        }
+
+        // remember current mouse coordinates
+        LayoutDeviceIntPoint refPoint;
+        if (!GetEventPoint(aEvent, refPoint))
+          return NS_OK;
+        mMouseDownPoint = refPoint + aEvent->mWidget->WidgetToScreenOffset();
+
+        // we're tracking
+        mTrackingMouseMove = true;
+
+        nsIPresShell::SetCapturingContent(GetContent(), CAPTURE_IGNOREALLOWED);
+      }
+    }
+    break;
+
+  case eTouchEnd:
+  case eMouseUp: {
+    if (aEvent->mClass == eTouchEventClass ||
+        (aEvent->mClass == eMouseEventClass &&
+         aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton)) {
+      // we're done tracking.
+      mTrackingMouseMove = false;
+
+      nsIPresShell::SetCapturingContent(nullptr, 0);
+
+      doDefault = false;
+    }
+  }
+  break;
+
+  case eTouchMove:
+  case eMouseMove: {
+    if (mTrackingMouseMove)
+    {
+      nsCOMPtr<nsIBaseWindow> window;
+      nsIPresShell* presShell = aPresContext->GetPresShell();
+      nsCOMPtr<nsIContent> contentToResize =
+        GetContentToResize(presShell, getter_AddRefs(window));
+
+      // check if the returned content really is a menupopup
+      nsMenuPopupFrame* menuPopupFrame = nullptr;
+      if (contentToResize) {
+        menuPopupFrame = do_QueryFrame(contentToResize->GetPrimaryFrame());
+      }
+
+      // 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;
+      if (!GetEventPoint(aEvent, refPoint))
+        return NS_OK;
+      LayoutDeviceIntPoint screenPoint =
+        refPoint + aEvent->mWidget->WidgetToScreenOffset();
+      LayoutDeviceIntPoint mouseMove(screenPoint - mMouseDownPoint);
+
+      // 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();
+      if (window || menuPopupFrame) {
+        if (menuPopupFrame) {
+          menuPopupFrame->CanAdjustEdges(
+            (direction.mHorizontal == -1) ? NS_SIDE_LEFT : NS_SIDE_RIGHT,
+            (direction.mVertical == -1) ? NS_SIDE_TOP : NS_SIDE_BOTTOM, mouseMove);
+        }
+      }
+      else if (!contentToResize) {
+        break; // don't do anything if there's nothing to resize
+      }
+
+      LayoutDeviceIntRect rect = mMouseDownRect;
+
+      // Check if there are any size constraints on this window.
+      widget::SizeConstraints sizeConstraints;
+      if (window) {
+        nsCOMPtr<nsIWidget> widget;
+        window->GetMainWidget(getter_AddRefs(widget));
+        sizeConstraints = widget->GetSizeConstraints();
+      }
+
+      AdjustDimensions(&rect.x, &rect.width, sizeConstraints.mMinSize.width,
+                       sizeConstraints.mMaxSize.width, mouseMove.x, direction.mHorizontal);
+      AdjustDimensions(&rect.y, &rect.height, sizeConstraints.mMinSize.height,
+                       sizeConstraints.mMaxSize.height, mouseMove.y, direction.mVertical);
+
+      // Don't allow resizing a window or a popup past the edge of the screen,
+      // so adjust the rectangle to fit within the available screen area.
+      if (window) {
+        nsCOMPtr<nsIScreen> screen;
+        nsCOMPtr<nsIScreenManager> sm(do_GetService("@mozilla.org/gfx/screenmanager;1"));
+        if (sm) {
+          nsIntRect frameRect = GetScreenRect();
+          // ScreenForRect requires display pixels, so scale from device pix
+          double scale;
+          window->GetUnscaledDevicePixelsPerCSSPixel(&scale);
+          sm->ScreenForRect(NSToIntRound(frameRect.x / scale),
+                            NSToIntRound(frameRect.y / scale), 1, 1,
+                            getter_AddRefs(screen));
+          if (screen) {
+            LayoutDeviceIntRect screenRect;
+            screen->GetRect(&screenRect.x, &screenRect.y,
+                            &screenRect.width, &screenRect.height);
+            rect.IntersectRect(rect, screenRect);
+          }
+        }
+      }
+      else if (menuPopupFrame) {
+        nsRect frameRect = menuPopupFrame->GetScreenRectInAppUnits();
+        nsIFrame* rootFrame = aPresContext->PresShell()->FrameManager()->GetRootFrame();
+        nsRect rootScreenRect = rootFrame->GetScreenRectInAppUnits();
+
+        nsPopupLevel popupLevel = menuPopupFrame->PopupLevel();
+        int32_t appPerDev = aPresContext->AppUnitsPerDevPixel();
+        LayoutDeviceIntRect screenRect = menuPopupFrame->GetConstraintRect
+          (LayoutDeviceIntRect::FromAppUnitsToNearest(frameRect, appPerDev),
+           // round using ...ToInside as it's better to be a pixel too small
+           // than be too large. If the popup is too large it could get flipped
+           // to the opposite side of the anchor point while resizing.
+           LayoutDeviceIntRect::FromAppUnitsToInside(rootScreenRect, appPerDev),
+           popupLevel);
+        rect.IntersectRect(rect, screenRect);
+      }
+
+      if (contentToResize) {
+        // convert the rectangle into css pixels. 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.
+        nsRect appUnitsRect = ToAppUnits(rect.ToUnknownRect(), aPresContext->AppUnitsPerDevPixel());
+        if (appUnitsRect.width < mRect.width && mouseMove.x)
+          appUnitsRect.width = mRect.width;
+        if (appUnitsRect.height < mRect.height && mouseMove.y)
+          appUnitsRect.height = mRect.height;
+        nsIntRect cssRect = appUnitsRect.ToInsidePixels(nsPresContext::AppUnitsPerCSSPixel());
+
+        LayoutDeviceIntRect oldRect;
+        nsWeakFrame weakFrame(menuPopupFrame);
+        if (menuPopupFrame) {
+          nsCOMPtr<nsIWidget> widget = menuPopupFrame->GetWidget();
+          if (widget)
+            oldRect = widget->GetScreenBounds();
+
+          // convert the new rectangle into outer window coordinates
+          LayoutDeviceIntPoint clientOffset = widget->GetClientOffset();
+          rect.x -= clientOffset.x;
+          rect.y -= clientOffset.y;
+        }
+
+        SizeInfo sizeInfo, originalSizeInfo;
+        sizeInfo.width.AppendInt(cssRect.width);
+        sizeInfo.height.AppendInt(cssRect.height);
+        ResizeContent(contentToResize, direction, sizeInfo, &originalSizeInfo);
+        MaybePersistOriginalSize(contentToResize, originalSizeInfo);
+
+        // Move the popup to the new location unless it is anchored, since
+        // the position shouldn't change. nsMenuPopupFrame::SetPopupPosition
+        // will instead ensure that the popup's position is anchored at the
+        // right place.
+        if (weakFrame.IsAlive() &&
+            (oldRect.x != rect.x || oldRect.y != rect.y) &&
+            (!menuPopupFrame->IsAnchored() ||
+             menuPopupFrame->PopupLevel() != ePopupLevelParent)) {
+
+          CSSPoint cssPos = rect.TopLeft() / aPresContext->CSSToDevPixelScale();
+          menuPopupFrame->MoveTo(RoundedToInt(cssPos), true);
+        }
+      }
+      else {
+        window->SetPositionAndSize(rect.x, rect.y, rect.width, rect.height,
+                                   nsIBaseWindow::eRepaint); // do the repaint.
+      }
+
+      doDefault = false;
+    }
+  }
+  break;
+
+  case eMouseClick: {
+    WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
+    if (mouseEvent->IsLeftClickEvent()) {
+      MouseClicked(mouseEvent);
+    }
+    break;
+  }
+  case eMouseDoubleClick:
+    if (aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton) {
+      nsCOMPtr<nsIBaseWindow> window;
+      nsIPresShell* presShell = aPresContext->GetPresShell();
+      nsIContent* contentToResize =
+        GetContentToResize(presShell, getter_AddRefs(window));
+      if (contentToResize) {
+        nsMenuPopupFrame* menuPopupFrame = do_QueryFrame(contentToResize->GetPrimaryFrame());
+        if (menuPopupFrame)
+          break; // Don't restore original sizing for menupopup frames until
+                 // we handle screen constraints here. (Bug 357725)
+
+        RestoreOriginalSize(contentToResize);
+      }
+    }
+    break;
+
+  default:
+    break;
+  }
+
+  if (!doDefault)
+    *aEventStatus = nsEventStatus_eConsumeNoDefault;
+
+  if (doDefault && weakFrame.IsAlive())
+    return nsTitleBarFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
+
+  return NS_OK;
+}
+
+nsIContent*
+nsResizerFrame::GetContentToResize(nsIPresShell* aPresShell, nsIBaseWindow** aWindow)
+{
+  *aWindow = nullptr;
+
+  nsAutoString elementid;
+  mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::element, elementid);
+  if (elementid.IsEmpty()) {
+    // If the resizer is in a popup, resize the popup's widget, otherwise
+    // resize the widget associated with the window.
+    nsIFrame* popup = GetParent();
+    while (popup) {
+      nsMenuPopupFrame* popupFrame = do_QueryFrame(popup);
+      if (popupFrame) {
+        return popupFrame->GetContent();
+      }
+      popup = popup->GetParent();
+    }
+
+    // don't allow resizing windows in content shells
+    nsCOMPtr<nsIDocShellTreeItem> dsti = aPresShell->GetPresContext()->GetDocShell();
+    if (!dsti || dsti->ItemType() != nsIDocShellTreeItem::typeChrome) {
+      // don't allow resizers in content shells, except for the viewport
+      // scrollbar which doesn't have a parent
+      nsIContent* nonNativeAnon = mContent->FindFirstNonChromeOnlyAccessContent();
+      if (!nonNativeAnon || nonNativeAnon->GetParent()) {
+        return nullptr;
+      }
+    }
+
+    // get the document and the window - should this be cached?
+    if (nsPIDOMWindowOuter* domWindow = aPresShell->GetDocument()->GetWindow()) {
+      nsCOMPtr<nsIDocShell> docShell = domWindow->GetDocShell();
+      if (docShell) {
+        nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
+        docShell->GetTreeOwner(getter_AddRefs(treeOwner));
+        if (treeOwner) {
+          CallQueryInterface(treeOwner, aWindow);
+        }
+      }
+    }
+
+    return nullptr;
+  }
+
+  if (elementid.EqualsLiteral("_parent")) {
+    // return the parent, but skip over native anonymous content
+    nsIContent* parent = mContent->GetParent();
+    return parent ? parent->FindFirstNonChromeOnlyAccessContent() : nullptr;
+  }
+
+  return aPresShell->GetDocument()->GetElementById(elementid);
+}
+
+void
+nsResizerFrame::AdjustDimensions(int32_t* aPos, int32_t* aSize,
+                                 int32_t aMinSize, int32_t aMaxSize,
+                                 int32_t aMovement, int8_t aResizerDirection)
+{
+  int32_t oldSize = *aSize;
+
+  *aSize += aResizerDirection * aMovement;
+  // use one as a minimum size or the element could disappear
+  if (*aSize < 1)
+    *aSize = 1;
+
+  // Constrain the size within the minimum and maximum size.
+  *aSize = std::max(aMinSize, std::min(aMaxSize, *aSize));
+
+  // For left and top resizers, the window must be moved left by the same
+  // amount that the window was resized.
+  if (aResizerDirection == -1)
+    *aPos += oldSize - *aSize;
+}
+
+/* static */ void
+nsResizerFrame::ResizeContent(nsIContent* aContent, const Direction& aDirection,
+                              const SizeInfo& aSizeInfo, SizeInfo* aOriginalSizeInfo)
+{
+  // for XUL elements, just set the width and height attributes. For
+  // other elements, set style.width and style.height
+  if (aContent->IsXULElement()) {
+    if (aOriginalSizeInfo) {
+      aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::width,
+                        aOriginalSizeInfo->width);
+      aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::height,
+                        aOriginalSizeInfo->height);
+    }
+    // only set the property if the element could have changed in that direction
+    if (aDirection.mHorizontal) {
+      aContent->SetAttr(kNameSpaceID_None, nsGkAtoms::width, aSizeInfo.width, true);
+    }
+    if (aDirection.mVertical) {
+      aContent->SetAttr(kNameSpaceID_None, nsGkAtoms::height, aSizeInfo.height, true);
+    }
+  }
+  else {
+    nsCOMPtr<nsStyledElement> inlineStyleContent =
+      do_QueryInterface(aContent);
+    if (inlineStyleContent) {
+      nsICSSDeclaration* decl = inlineStyleContent->Style();
+
+      if (aOriginalSizeInfo) {
+        decl->GetPropertyValue(NS_LITERAL_STRING("width"),
+                               aOriginalSizeInfo->width);
+        decl->GetPropertyValue(NS_LITERAL_STRING("height"),
+                               aOriginalSizeInfo->height);
+      }
+
+      // only set the property if the element could have changed in that direction
+      if (aDirection.mHorizontal) {
+        nsAutoString widthstr(aSizeInfo.width);
+        if (!widthstr.IsEmpty() &&
+            !Substring(widthstr, widthstr.Length() - 2, 2).EqualsLiteral("px"))
+          widthstr.AppendLiteral("px");
+        decl->SetProperty(NS_LITERAL_STRING("width"), widthstr, EmptyString());
+      }
+      if (aDirection.mVertical) {
+        nsAutoString heightstr(aSizeInfo.height);
+        if (!heightstr.IsEmpty() &&
+            !Substring(heightstr, heightstr.Length() - 2, 2).EqualsLiteral("px"))
+          heightstr.AppendLiteral("px");
+        decl->SetProperty(NS_LITERAL_STRING("height"), heightstr, EmptyString());
+      }
+    }
+  }
+}
+
+/* static */ void
+nsResizerFrame::MaybePersistOriginalSize(nsIContent* aContent,
+                                         const SizeInfo& aSizeInfo)
+{
+  nsresult rv;
+
+  aContent->GetProperty(nsGkAtoms::_moz_original_size, &rv);
+  if (rv != NS_PROPTABLE_PROP_NOT_THERE)
+    return;
+
+  nsAutoPtr<SizeInfo> sizeInfo(new SizeInfo(aSizeInfo));
+  rv = aContent->SetProperty(nsGkAtoms::_moz_original_size, sizeInfo.get(),
+                             nsINode::DeleteProperty<nsResizerFrame::SizeInfo>);
+  if (NS_SUCCEEDED(rv))
+    sizeInfo.forget();
+}
+
+/* static */ void
+nsResizerFrame::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->DeleteProperty(nsGkAtoms::_moz_original_size);
+}
+
+/* returns a Direction struct containing the horizontal and vertical direction
+ */
+nsResizerFrame::Direction
+nsResizerFrame::GetDirection()
+{
+  static const nsIContent::AttrValuesArray strings[] =
+    {&nsGkAtoms::topleft,    &nsGkAtoms::top,    &nsGkAtoms::topright,
+     &nsGkAtoms::left,                           &nsGkAtoms::right,
+     &nsGkAtoms::bottomleft, &nsGkAtoms::bottom, &nsGkAtoms::bottomright,
+     &nsGkAtoms::bottomstart,                    &nsGkAtoms::bottomend,
+     nullptr};
+
+  static const Direction directions[] =
+    {{-1, -1}, {0, -1}, {1, -1},
+     {-1,  0},          {1,  0},
+     {-1,  1}, {0,  1}, {1,  1},
+     {-1,  1},          {1,  1}
+    };
+
+  if (!GetContent()) {
+    return directions[0]; // default: topleft
+  }
+
+  int32_t index = GetContent()->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.
+    WritingMode wm = GetWritingMode();
+    if (!(wm.IsVertical() ? wm.IsVerticalLR() : wm.IsBidiLTR())) {
+      Direction direction = directions[index];
+      direction.mHorizontal *= -1;
+      return direction;
+    }
+  }
+
+  return directions[index];
+}
+
+void
+nsResizerFrame::MouseClicked(WidgetMouseEvent* aEvent)
+{
+  // Execute the oncommand event handler.
+  nsContentUtils::DispatchXULCommand(mContent, aEvent && aEvent->IsTrusted());
+}