mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-10 11:54:40 +00:00
545 lines
19 KiB
C++
545 lines
19 KiB
C++
/* -*- 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 "nsCOMPtr.h"
|
|
#include "nsIServiceManager.h"
|
|
#include "nsResizerFrame.h"
|
|
#include "nsIContent.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsIDOMNodeList.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsNameSpaceManager.h"
|
|
#include "nsIDOMElementCSSInlineStyle.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 <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();
|
|
switch (frameToResize->StylePosition()->mBoxSizing) {
|
|
case StyleBoxSizing::Content:
|
|
rect.Deflate(frameToResize->GetUsedPadding());
|
|
// fall through
|
|
case StyleBoxSizing::Padding:
|
|
rect.Deflate(frameToResize->GetUsedBorder());
|
|
// fall through
|
|
case StyleBoxSizing::Border:
|
|
// nothing
|
|
break;
|
|
}
|
|
|
|
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->widget->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->widget->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->widget->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();
|
|
nsRect screenRect = menuPopupFrame->GetConstraintRect(frameRect, rootScreenRect, popupLevel);
|
|
// round using ToInsidePixels 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.
|
|
nsIntRect screenRectPixels = screenRect.ToInsidePixels(aPresContext->AppUnitsPerDevPixel());
|
|
rect.IntersectRect(rect, LayoutDeviceIntRect::FromUnknownRect(screenRectPixels));
|
|
}
|
|
|
|
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)
|
|
widget->GetScreenBounds(oldRect);
|
|
|
|
// 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(aPresContext, 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?
|
|
nsPIDOMWindow *domWindow = aPresShell->GetDocument()->GetWindow();
|
|
if (domWindow) {
|
|
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<nsIDOMElementCSSInlineStyle> inlineStyleContent =
|
|
do_QueryInterface(aContent);
|
|
if (inlineStyleContent) {
|
|
nsCOMPtr<nsIDOMCSSStyleDeclaration> decl;
|
|
inlineStyleContent->GetStyle(getter_AddRefs(decl));
|
|
|
|
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(nsPresContext* aPresContext,
|
|
WidgetMouseEvent* aEvent)
|
|
{
|
|
// Execute the oncommand event handler.
|
|
nsContentUtils::DispatchXULCommand(mContent,
|
|
aEvent && aEvent->mFlags.mIsTrusted);
|
|
}
|