mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-10 11:54:40 +00:00
1046 lines
31 KiB
C++
1046 lines
31 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/. */
|
|
|
|
//
|
|
// Eric Vaughan
|
|
// Netscape Communications
|
|
//
|
|
// See documentation in associated header file
|
|
//
|
|
|
|
#include "nsSplitterFrame.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsIDOMElement.h"
|
|
#include "nsIDOMXULElement.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsRenderingContext.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsNameSpaceManager.h"
|
|
#include "nsScrollbarButtonFrame.h"
|
|
#include "nsIDOMEventListener.h"
|
|
#include "nsIDOMMouseEvent.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsFrameList.h"
|
|
#include "nsHTMLParts.h"
|
|
#include "nsStyleContext.h"
|
|
#include "nsBoxLayoutState.h"
|
|
#include "nsIServiceManager.h"
|
|
#include "nsContainerFrame.h"
|
|
#include "nsAutoPtr.h"
|
|
#include "nsContentCID.h"
|
|
#include "nsStyleSet.h"
|
|
#include "nsLayoutUtils.h"
|
|
#include "nsDisplayList.h"
|
|
#include "nsContentUtils.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "mozilla/MouseEvents.h"
|
|
#include "mozilla/UniquePtr.h"
|
|
|
|
using namespace mozilla;
|
|
|
|
class nsSplitterInfo {
|
|
public:
|
|
nscoord min;
|
|
nscoord max;
|
|
nscoord current;
|
|
nscoord changed;
|
|
nsCOMPtr<nsIContent> childElem;
|
|
int32_t flex;
|
|
int32_t index;
|
|
};
|
|
|
|
class nsSplitterFrameInner final : public nsIDOMEventListener
|
|
{
|
|
protected:
|
|
virtual ~nsSplitterFrameInner();
|
|
|
|
public:
|
|
|
|
NS_DECL_ISUPPORTS
|
|
NS_DECL_NSIDOMEVENTLISTENER
|
|
|
|
explicit nsSplitterFrameInner(nsSplitterFrame* aSplitter)
|
|
{
|
|
mOuter = aSplitter;
|
|
mPressed = false;
|
|
}
|
|
|
|
void Disconnect() { mOuter = nullptr; }
|
|
|
|
nsresult MouseDown(nsIDOMEvent* aMouseEvent);
|
|
nsresult MouseUp(nsIDOMEvent* aMouseEvent);
|
|
nsresult MouseMove(nsIDOMEvent* aMouseEvent);
|
|
|
|
void MouseDrag(nsPresContext* aPresContext, WidgetGUIEvent* aEvent);
|
|
void MouseUp(nsPresContext* aPresContext, WidgetGUIEvent* aEvent);
|
|
|
|
void AdjustChildren(nsPresContext* aPresContext);
|
|
void AdjustChildren(nsPresContext* aPresContext, nsSplitterInfo* aChildInfos, int32_t aCount, bool aIsHorizontal);
|
|
|
|
void AddRemoveSpace(nscoord aDiff,
|
|
nsSplitterInfo* aChildInfos,
|
|
int32_t aCount,
|
|
int32_t& aSpaceLeft);
|
|
|
|
void ResizeChildTo(nscoord& aDiff,
|
|
nsSplitterInfo* aChildrenBeforeInfos,
|
|
nsSplitterInfo* aChildrenAfterInfos,
|
|
int32_t aChildrenBeforeCount,
|
|
int32_t aChildrenAfterCount,
|
|
bool aBounded);
|
|
|
|
void UpdateState();
|
|
|
|
void AddListener();
|
|
void RemoveListener();
|
|
|
|
enum ResizeType { Closest, Farthest, Flex, Grow };
|
|
enum State { Open, CollapsedBefore, CollapsedAfter, Dragging };
|
|
enum CollapseDirection { Before, After };
|
|
|
|
ResizeType GetResizeBefore();
|
|
ResizeType GetResizeAfter();
|
|
State GetState();
|
|
|
|
void Reverse(UniquePtr<nsSplitterInfo[]>& aIndexes, int32_t aCount);
|
|
bool SupportsCollapseDirection(CollapseDirection aDirection);
|
|
|
|
void EnsureOrient();
|
|
void SetPreferredSize(nsBoxLayoutState& aState, nsIFrame* aChildBox, nscoord aOnePixel, bool aIsHorizontal, nscoord* aSize);
|
|
|
|
nsSplitterFrame* mOuter;
|
|
bool mDidDrag;
|
|
nscoord mDragStart;
|
|
nscoord mCurrentPos;
|
|
nsIFrame* mParentBox;
|
|
bool mPressed;
|
|
UniquePtr<nsSplitterInfo[]> mChildInfosBefore;
|
|
UniquePtr<nsSplitterInfo[]> mChildInfosAfter;
|
|
int32_t mChildInfosBeforeCount;
|
|
int32_t mChildInfosAfterCount;
|
|
State mState;
|
|
nscoord mSplitterPos;
|
|
bool mDragging;
|
|
|
|
};
|
|
|
|
NS_IMPL_ISUPPORTS(nsSplitterFrameInner, nsIDOMEventListener)
|
|
|
|
nsSplitterFrameInner::ResizeType
|
|
nsSplitterFrameInner::GetResizeBefore()
|
|
{
|
|
static nsIContent::AttrValuesArray strings[] =
|
|
{&nsGkAtoms::farthest, &nsGkAtoms::flex, nullptr};
|
|
switch (mOuter->GetContent()->FindAttrValueIn(kNameSpaceID_None,
|
|
nsGkAtoms::resizebefore,
|
|
strings, eCaseMatters)) {
|
|
case 0: return Farthest;
|
|
case 1: return Flex;
|
|
}
|
|
return Closest;
|
|
}
|
|
|
|
nsSplitterFrameInner::~nsSplitterFrameInner()
|
|
{
|
|
}
|
|
|
|
nsSplitterFrameInner::ResizeType
|
|
nsSplitterFrameInner::GetResizeAfter()
|
|
{
|
|
static nsIContent::AttrValuesArray strings[] =
|
|
{&nsGkAtoms::farthest, &nsGkAtoms::flex, &nsGkAtoms::grow, nullptr};
|
|
switch (mOuter->GetContent()->FindAttrValueIn(kNameSpaceID_None,
|
|
nsGkAtoms::resizeafter,
|
|
strings, eCaseMatters)) {
|
|
case 0: return Farthest;
|
|
case 1: return Flex;
|
|
case 2: return Grow;
|
|
}
|
|
return Closest;
|
|
}
|
|
|
|
nsSplitterFrameInner::State
|
|
nsSplitterFrameInner::GetState()
|
|
{
|
|
static nsIContent::AttrValuesArray strings[] =
|
|
{&nsGkAtoms::dragging, &nsGkAtoms::collapsed, nullptr};
|
|
static nsIContent::AttrValuesArray strings_substate[] =
|
|
{&nsGkAtoms::before, &nsGkAtoms::after, nullptr};
|
|
switch (mOuter->GetContent()->FindAttrValueIn(kNameSpaceID_None,
|
|
nsGkAtoms::state,
|
|
strings, eCaseMatters)) {
|
|
case 0: return Dragging;
|
|
case 1:
|
|
switch (mOuter->GetContent()->FindAttrValueIn(kNameSpaceID_None,
|
|
nsGkAtoms::substate,
|
|
strings_substate,
|
|
eCaseMatters)) {
|
|
case 0: return CollapsedBefore;
|
|
case 1: return CollapsedAfter;
|
|
default:
|
|
if (SupportsCollapseDirection(After))
|
|
return CollapsedAfter;
|
|
return CollapsedBefore;
|
|
}
|
|
}
|
|
return Open;
|
|
}
|
|
|
|
//
|
|
// NS_NewSplitterFrame
|
|
//
|
|
// Creates a new Toolbar frame and returns it
|
|
//
|
|
nsIFrame*
|
|
NS_NewSplitterFrame (nsIPresShell* aPresShell, nsStyleContext* aContext)
|
|
{
|
|
return new (aPresShell) nsSplitterFrame(aContext);
|
|
}
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsSplitterFrame)
|
|
|
|
nsSplitterFrame::nsSplitterFrame(nsStyleContext* aContext)
|
|
: nsBoxFrame(aContext),
|
|
mInner(0)
|
|
{
|
|
}
|
|
|
|
void
|
|
nsSplitterFrame::DestroyFrom(nsIFrame* aDestructRoot)
|
|
{
|
|
if (mInner) {
|
|
mInner->RemoveListener();
|
|
mInner->Disconnect();
|
|
mInner->Release();
|
|
mInner = nullptr;
|
|
}
|
|
nsBoxFrame::DestroyFrom(aDestructRoot);
|
|
}
|
|
|
|
|
|
nsresult
|
|
nsSplitterFrame::GetCursor(const nsPoint& aPoint,
|
|
nsIFrame::Cursor& aCursor)
|
|
{
|
|
return nsBoxFrame::GetCursor(aPoint, aCursor);
|
|
|
|
/*
|
|
if (IsHorizontal())
|
|
aCursor = NS_STYLE_CURSOR_N_RESIZE;
|
|
else
|
|
aCursor = NS_STYLE_CURSOR_W_RESIZE;
|
|
|
|
return NS_OK;
|
|
*/
|
|
}
|
|
|
|
nsresult
|
|
nsSplitterFrame::AttributeChanged(int32_t aNameSpaceID,
|
|
nsIAtom* aAttribute,
|
|
int32_t aModType)
|
|
{
|
|
nsresult rv = nsBoxFrame::AttributeChanged(aNameSpaceID, aAttribute,
|
|
aModType);
|
|
// if the alignment changed. Let the grippy know
|
|
if (aAttribute == nsGkAtoms::align) {
|
|
// tell the slider its attribute changed so it can
|
|
// update itself
|
|
nsIFrame* grippy = nullptr;
|
|
nsScrollbarButtonFrame::GetChildWithTag(nsGkAtoms::grippy, this, grippy);
|
|
if (grippy)
|
|
grippy->AttributeChanged(aNameSpaceID, aAttribute, aModType);
|
|
} else if (aAttribute == nsGkAtoms::state) {
|
|
mInner->UpdateState();
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/**
|
|
* Initialize us. If we are in a box get our alignment so we know what direction we are
|
|
*/
|
|
void
|
|
nsSplitterFrame::Init(nsIContent* aContent,
|
|
nsContainerFrame* aParent,
|
|
nsIFrame* aPrevInFlow)
|
|
{
|
|
MOZ_ASSERT(!mInner);
|
|
mInner = new nsSplitterFrameInner(this);
|
|
|
|
mInner->AddRef();
|
|
mInner->mState = nsSplitterFrameInner::Open;
|
|
mInner->mDragging = false;
|
|
|
|
// determine orientation of parent, and if vertical, set orient to vertical
|
|
// on splitter content, then re-resolve style
|
|
// XXXbz this is pretty messed up, since this can change whether we should
|
|
// have a frame at all. This really needs a better solution.
|
|
if (aParent && aParent->IsBoxFrame()) {
|
|
if (!aParent->IsHorizontal()) {
|
|
if (!nsContentUtils::HasNonEmptyAttr(aContent, kNameSpaceID_None,
|
|
nsGkAtoms::orient)) {
|
|
aContent->SetAttr(kNameSpaceID_None, nsGkAtoms::orient,
|
|
NS_LITERAL_STRING("vertical"), false);
|
|
nsStyleContext* parentStyleContext = StyleContext()->GetParent();
|
|
RefPtr<nsStyleContext> newContext = PresContext()->StyleSet()->
|
|
ResolveStyleFor(aContent->AsElement(), parentStyleContext);
|
|
SetStyleContextWithoutNotification(newContext);
|
|
}
|
|
}
|
|
}
|
|
|
|
nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
|
|
|
|
mInner->mState = nsSplitterFrameInner::Open;
|
|
mInner->AddListener();
|
|
mInner->mParentBox = nullptr;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSplitterFrame::DoLayout(nsBoxLayoutState& aState)
|
|
{
|
|
if (GetStateBits() & NS_FRAME_FIRST_REFLOW)
|
|
{
|
|
mInner->mParentBox = nsBox::GetParentBox(this);
|
|
mInner->UpdateState();
|
|
}
|
|
|
|
return nsBoxFrame::DoLayout(aState);
|
|
}
|
|
|
|
|
|
void
|
|
nsSplitterFrame::GetInitialOrientation(bool& aIsHorizontal)
|
|
{
|
|
nsIFrame* box = nsBox::GetParentBox(this);
|
|
if (box) {
|
|
aIsHorizontal = !box->IsHorizontal();
|
|
}
|
|
else
|
|
nsBoxFrame::GetInitialOrientation(aIsHorizontal);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSplitterFrame::HandlePress(nsPresContext* aPresContext,
|
|
WidgetGUIEvent* aEvent,
|
|
nsEventStatus* aEventStatus)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSplitterFrame::HandleMultiplePress(nsPresContext* aPresContext,
|
|
WidgetGUIEvent* aEvent,
|
|
nsEventStatus* aEventStatus,
|
|
bool aControlHeld)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSplitterFrame::HandleDrag(nsPresContext* aPresContext,
|
|
WidgetGUIEvent* aEvent,
|
|
nsEventStatus* aEventStatus)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSplitterFrame::HandleRelease(nsPresContext* aPresContext,
|
|
WidgetGUIEvent* aEvent,
|
|
nsEventStatus* aEventStatus)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsSplitterFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
const nsRect& aDirtyRect,
|
|
const nsDisplayListSet& aLists)
|
|
{
|
|
nsBoxFrame::BuildDisplayList(aBuilder, aDirtyRect, aLists);
|
|
|
|
// if the mouse is captured always return us as the frame.
|
|
if (mInner->mDragging)
|
|
{
|
|
// XXX It's probably better not to check visibility here, right?
|
|
aLists.Outlines()->AppendNewToTop(new (aBuilder)
|
|
nsDisplayEventReceiver(aBuilder, this));
|
|
return;
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
nsSplitterFrame::HandleEvent(nsPresContext* aPresContext,
|
|
WidgetGUIEvent* aEvent,
|
|
nsEventStatus* aEventStatus)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aEventStatus);
|
|
if (nsEventStatus_eConsumeNoDefault == *aEventStatus) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsWeakFrame weakFrame(this);
|
|
RefPtr<nsSplitterFrameInner> kungFuDeathGrip(mInner);
|
|
switch (aEvent->mMessage) {
|
|
case eMouseMove:
|
|
kungFuDeathGrip->MouseDrag(aPresContext, aEvent);
|
|
break;
|
|
|
|
case eMouseUp:
|
|
if (aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton) {
|
|
kungFuDeathGrip->MouseUp(aPresContext, aEvent);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
NS_ENSURE_STATE(weakFrame.IsAlive());
|
|
return nsBoxFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
|
|
}
|
|
|
|
void
|
|
nsSplitterFrameInner::MouseUp(nsPresContext* aPresContext,
|
|
WidgetGUIEvent* aEvent)
|
|
{
|
|
if (mDragging && mOuter) {
|
|
AdjustChildren(aPresContext);
|
|
AddListener();
|
|
nsIPresShell::SetCapturingContent(nullptr, 0); // XXXndeakin is this needed?
|
|
mDragging = false;
|
|
State newState = GetState();
|
|
// if the state is dragging then make it Open.
|
|
if (newState == Dragging)
|
|
mOuter->mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::state, EmptyString(), true);
|
|
|
|
mPressed = false;
|
|
|
|
// if we dragged then fire a command event.
|
|
if (mDidDrag) {
|
|
nsCOMPtr<nsIDOMXULElement> element = do_QueryInterface(mOuter->GetContent());
|
|
element->DoCommand();
|
|
}
|
|
|
|
//printf("MouseUp\n");
|
|
}
|
|
|
|
mChildInfosBefore = nullptr;
|
|
mChildInfosAfter = nullptr;
|
|
mChildInfosBeforeCount = 0;
|
|
mChildInfosAfterCount = 0;
|
|
}
|
|
|
|
void
|
|
nsSplitterFrameInner::MouseDrag(nsPresContext* aPresContext,
|
|
WidgetGUIEvent* aEvent)
|
|
{
|
|
if (mDragging && mOuter) {
|
|
|
|
//printf("Dragging\n");
|
|
|
|
bool isHorizontal = !mOuter->IsHorizontal();
|
|
// convert coord to pixels
|
|
nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent,
|
|
mParentBox);
|
|
nscoord pos = isHorizontal ? pt.x : pt.y;
|
|
|
|
// mDragStart is in frame coordinates
|
|
nscoord start = mDragStart;
|
|
|
|
// take our current position and subtract the start location
|
|
pos -= start;
|
|
|
|
//printf("Diff=%d\n", pos);
|
|
|
|
ResizeType resizeAfter = GetResizeAfter();
|
|
|
|
bool bounded;
|
|
|
|
if (resizeAfter == nsSplitterFrameInner::Grow)
|
|
bounded = false;
|
|
else
|
|
bounded = true;
|
|
|
|
int i;
|
|
for (i=0; i < mChildInfosBeforeCount; i++)
|
|
mChildInfosBefore[i].changed = mChildInfosBefore[i].current;
|
|
|
|
for (i=0; i < mChildInfosAfterCount; i++)
|
|
mChildInfosAfter[i].changed = mChildInfosAfter[i].current;
|
|
|
|
nscoord oldPos = pos;
|
|
|
|
ResizeChildTo(pos,
|
|
mChildInfosBefore.get(), mChildInfosAfter.get(),
|
|
mChildInfosBeforeCount, mChildInfosAfterCount, bounded);
|
|
|
|
State currentState = GetState();
|
|
bool supportsBefore = SupportsCollapseDirection(Before);
|
|
bool supportsAfter = SupportsCollapseDirection(After);
|
|
|
|
const bool isRTL = mOuter->StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL;
|
|
bool pastEnd = oldPos > 0 && oldPos > pos;
|
|
bool pastBegin = oldPos < 0 && oldPos < pos;
|
|
if (isRTL) {
|
|
// Swap the boundary checks in RTL mode
|
|
bool tmp = pastEnd;
|
|
pastEnd = pastBegin;
|
|
pastBegin = tmp;
|
|
}
|
|
const bool isCollapsedBefore = pastBegin && supportsBefore;
|
|
const bool isCollapsedAfter = pastEnd && supportsAfter;
|
|
|
|
// if we are in a collapsed position
|
|
if (isCollapsedBefore || isCollapsedAfter)
|
|
{
|
|
// and we are not collapsed then collapse
|
|
if (currentState == Dragging) {
|
|
if (pastEnd)
|
|
{
|
|
//printf("Collapse right\n");
|
|
if (supportsAfter)
|
|
{
|
|
nsCOMPtr<nsIContent> outer = mOuter->mContent;
|
|
outer->SetAttr(kNameSpaceID_None, nsGkAtoms::substate,
|
|
NS_LITERAL_STRING("after"),
|
|
true);
|
|
outer->SetAttr(kNameSpaceID_None, nsGkAtoms::state,
|
|
NS_LITERAL_STRING("collapsed"),
|
|
true);
|
|
}
|
|
|
|
} else if (pastBegin)
|
|
{
|
|
//printf("Collapse left\n");
|
|
if (supportsBefore)
|
|
{
|
|
nsCOMPtr<nsIContent> outer = mOuter->mContent;
|
|
outer->SetAttr(kNameSpaceID_None, nsGkAtoms::substate,
|
|
NS_LITERAL_STRING("before"),
|
|
true);
|
|
outer->SetAttr(kNameSpaceID_None, nsGkAtoms::state,
|
|
NS_LITERAL_STRING("collapsed"),
|
|
true);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// if we are not in a collapsed position and we are not dragging make sure
|
|
// we are dragging.
|
|
if (currentState != Dragging)
|
|
mOuter->mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::state, NS_LITERAL_STRING("dragging"), true);
|
|
AdjustChildren(aPresContext);
|
|
}
|
|
|
|
mDidDrag = true;
|
|
}
|
|
}
|
|
|
|
void
|
|
nsSplitterFrameInner::AddListener()
|
|
{
|
|
mOuter->GetContent()->
|
|
AddEventListener(NS_LITERAL_STRING("mouseup"), this, false, false);
|
|
mOuter->GetContent()->
|
|
AddEventListener(NS_LITERAL_STRING("mousedown"), this, false, false);
|
|
mOuter->GetContent()->
|
|
AddEventListener(NS_LITERAL_STRING("mousemove"), this, false, false);
|
|
mOuter->GetContent()->
|
|
AddEventListener(NS_LITERAL_STRING("mouseout"), this, false, false);
|
|
}
|
|
|
|
void
|
|
nsSplitterFrameInner::RemoveListener()
|
|
{
|
|
ENSURE_TRUE(mOuter);
|
|
mOuter->GetContent()->
|
|
RemoveEventListener(NS_LITERAL_STRING("mouseup"), this, false);
|
|
mOuter->GetContent()->
|
|
RemoveEventListener(NS_LITERAL_STRING("mousedown"), this, false);
|
|
mOuter->GetContent()->
|
|
RemoveEventListener(NS_LITERAL_STRING("mousemove"), this, false);
|
|
mOuter->GetContent()->
|
|
RemoveEventListener(NS_LITERAL_STRING("mouseout"), this, false);
|
|
}
|
|
|
|
nsresult
|
|
nsSplitterFrameInner::HandleEvent(nsIDOMEvent* aEvent)
|
|
{
|
|
nsAutoString eventType;
|
|
aEvent->GetType(eventType);
|
|
if (eventType.EqualsLiteral("mouseup"))
|
|
return MouseUp(aEvent);
|
|
if (eventType.EqualsLiteral("mousedown"))
|
|
return MouseDown(aEvent);
|
|
if (eventType.EqualsLiteral("mousemove") ||
|
|
eventType.EqualsLiteral("mouseout"))
|
|
return MouseMove(aEvent);
|
|
|
|
NS_ABORT();
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsSplitterFrameInner::MouseUp(nsIDOMEvent* aMouseEvent)
|
|
{
|
|
NS_ENSURE_TRUE(mOuter, NS_OK);
|
|
mPressed = false;
|
|
|
|
nsIPresShell::SetCapturingContent(nullptr, 0);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsSplitterFrameInner::MouseDown(nsIDOMEvent* aMouseEvent)
|
|
{
|
|
NS_ENSURE_TRUE(mOuter, NS_OK);
|
|
nsCOMPtr<nsIDOMMouseEvent> mouseEvent(do_QueryInterface(aMouseEvent));
|
|
if (!mouseEvent)
|
|
return NS_OK;
|
|
|
|
int16_t button = 0;
|
|
mouseEvent->GetButton(&button);
|
|
|
|
// only if left button
|
|
if (button != 0)
|
|
return NS_OK;
|
|
|
|
if (mOuter->GetContent()->
|
|
AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
|
|
nsGkAtoms::_true, eCaseMatters))
|
|
return NS_OK;
|
|
|
|
mParentBox = nsBox::GetParentBox(mOuter);
|
|
if (!mParentBox)
|
|
return NS_OK;
|
|
|
|
// get our index
|
|
nsPresContext* outerPresContext = mOuter->PresContext();
|
|
const nsFrameList& siblingList(mParentBox->PrincipalChildList());
|
|
int32_t childIndex = siblingList.IndexOf(mOuter);
|
|
// if it's 0 (or not found) then stop right here.
|
|
// It might be not found if we're not in the parent's primary frame list.
|
|
if (childIndex <= 0)
|
|
return NS_OK;
|
|
|
|
int32_t childCount = siblingList.GetLength();
|
|
// if it's the last index then we need to allow for resizeafter="grow"
|
|
if (childIndex == childCount - 1 && GetResizeAfter() != Grow)
|
|
return NS_OK;
|
|
|
|
nsRenderingContext rc(
|
|
outerPresContext->PresShell()->CreateReferenceRenderingContext());
|
|
nsBoxLayoutState state(outerPresContext, &rc);
|
|
mCurrentPos = 0;
|
|
mPressed = true;
|
|
|
|
mDidDrag = false;
|
|
|
|
EnsureOrient();
|
|
bool isHorizontal = !mOuter->IsHorizontal();
|
|
|
|
ResizeType resizeBefore = GetResizeBefore();
|
|
ResizeType resizeAfter = GetResizeAfter();
|
|
|
|
mChildInfosBefore = MakeUnique<nsSplitterInfo[]>(childCount);
|
|
mChildInfosAfter = MakeUnique<nsSplitterInfo[]>(childCount);
|
|
|
|
// create info 2 lists. One of the children before us and one after.
|
|
int32_t count = 0;
|
|
mChildInfosBeforeCount = 0;
|
|
mChildInfosAfterCount = 0;
|
|
|
|
nsIFrame* childBox = nsBox::GetChildBox(mParentBox);
|
|
|
|
while (nullptr != childBox)
|
|
{
|
|
nsIContent* content = childBox->GetContent();
|
|
nsIDocument* doc = content->OwnerDoc();
|
|
int32_t dummy;
|
|
nsIAtom* atom = doc->BindingManager()->ResolveTag(content, &dummy);
|
|
|
|
// skip over any splitters
|
|
if (atom != nsGkAtoms::splitter) {
|
|
nsSize prefSize = childBox->GetPrefSize(state);
|
|
nsSize minSize = childBox->GetMinSize(state);
|
|
nsSize maxSize = nsBox::BoundsCheckMinMax(minSize, childBox->GetMaxSize(state));
|
|
prefSize = nsBox::BoundsCheck(minSize, prefSize, maxSize);
|
|
|
|
mOuter->AddMargin(childBox, minSize);
|
|
mOuter->AddMargin(childBox, prefSize);
|
|
mOuter->AddMargin(childBox, maxSize);
|
|
|
|
nscoord flex = childBox->GetFlex(state);
|
|
|
|
nsMargin margin(0,0,0,0);
|
|
childBox->GetMargin(margin);
|
|
nsRect r(childBox->GetRect());
|
|
r.Inflate(margin);
|
|
|
|
// We need to check for hidden attribute too, since treecols with
|
|
// the hidden="true" attribute are not really hidden, just collapsed
|
|
if (!content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::fixed,
|
|
nsGkAtoms::_true, eCaseMatters) &&
|
|
!content->AttrValueIs(kNameSpaceID_None, nsGkAtoms::hidden,
|
|
nsGkAtoms::_true, eCaseMatters)) {
|
|
if (count < childIndex && (resizeBefore != Flex || flex > 0)) {
|
|
mChildInfosBefore[mChildInfosBeforeCount].childElem = content;
|
|
mChildInfosBefore[mChildInfosBeforeCount].min = isHorizontal ? minSize.width : minSize.height;
|
|
mChildInfosBefore[mChildInfosBeforeCount].max = isHorizontal ? maxSize.width : maxSize.height;
|
|
mChildInfosBefore[mChildInfosBeforeCount].current = isHorizontal ? r.width : r.height;
|
|
mChildInfosBefore[mChildInfosBeforeCount].flex = flex;
|
|
mChildInfosBefore[mChildInfosBeforeCount].index = count;
|
|
mChildInfosBefore[mChildInfosBeforeCount].changed = mChildInfosBefore[mChildInfosBeforeCount].current;
|
|
mChildInfosBeforeCount++;
|
|
} else if (count > childIndex && (resizeAfter != Flex || flex > 0)) {
|
|
mChildInfosAfter[mChildInfosAfterCount].childElem = content;
|
|
mChildInfosAfter[mChildInfosAfterCount].min = isHorizontal ? minSize.width : minSize.height;
|
|
mChildInfosAfter[mChildInfosAfterCount].max = isHorizontal ? maxSize.width : maxSize.height;
|
|
mChildInfosAfter[mChildInfosAfterCount].current = isHorizontal ? r.width : r.height;
|
|
mChildInfosAfter[mChildInfosAfterCount].flex = flex;
|
|
mChildInfosAfter[mChildInfosAfterCount].index = count;
|
|
mChildInfosAfter[mChildInfosAfterCount].changed = mChildInfosAfter[mChildInfosAfterCount].current;
|
|
mChildInfosAfterCount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
childBox = nsBox::GetNextBox(childBox);
|
|
count++;
|
|
}
|
|
|
|
if (!mParentBox->IsNormalDirection()) {
|
|
// The before array is really the after array, and the order needs to be reversed.
|
|
// First reverse both arrays.
|
|
Reverse(mChildInfosBefore, mChildInfosBeforeCount);
|
|
Reverse(mChildInfosAfter, mChildInfosAfterCount);
|
|
|
|
// Now swap the two arrays.
|
|
Swap(mChildInfosBeforeCount, mChildInfosAfterCount);
|
|
Swap(mChildInfosBefore, mChildInfosAfter);
|
|
}
|
|
|
|
// if resizebefore is not Farthest, reverse the list because the first child
|
|
// in the list is the farthest, and we want the first child to be the closest.
|
|
if (resizeBefore != Farthest)
|
|
Reverse(mChildInfosBefore, mChildInfosBeforeCount);
|
|
|
|
// if the resizeafter is the Farthest we must reverse the list because the first child in the list
|
|
// is the closest we want the first child to be the Farthest.
|
|
if (resizeAfter == Farthest)
|
|
Reverse(mChildInfosAfter, mChildInfosAfterCount);
|
|
|
|
// grow only applys to the children after. If grow is set then no space should be taken out of any children after
|
|
// us. To do this we just set the size of that list to be 0.
|
|
if (resizeAfter == Grow)
|
|
mChildInfosAfterCount = 0;
|
|
|
|
int32_t c;
|
|
nsPoint pt = nsLayoutUtils::GetDOMEventCoordinatesRelativeTo(mouseEvent,
|
|
mParentBox);
|
|
if (isHorizontal) {
|
|
c = pt.x;
|
|
mSplitterPos = mOuter->mRect.x;
|
|
} else {
|
|
c = pt.y;
|
|
mSplitterPos = mOuter->mRect.y;
|
|
}
|
|
|
|
mDragStart = c;
|
|
|
|
//printf("Pressed mDragStart=%d\n",mDragStart);
|
|
|
|
nsIPresShell::SetCapturingContent(mOuter->GetContent(), CAPTURE_IGNOREALLOWED);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsSplitterFrameInner::MouseMove(nsIDOMEvent* aMouseEvent)
|
|
{
|
|
NS_ENSURE_TRUE(mOuter, NS_OK);
|
|
if (!mPressed)
|
|
return NS_OK;
|
|
|
|
if (mDragging)
|
|
return NS_OK;
|
|
|
|
nsCOMPtr<nsIDOMEventListener> kungfuDeathGrip(this);
|
|
mOuter->mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::state,
|
|
NS_LITERAL_STRING("dragging"), true);
|
|
|
|
RemoveListener();
|
|
mDragging = true;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsSplitterFrameInner::Reverse(UniquePtr<nsSplitterInfo[]>& aChildInfos, int32_t aCount)
|
|
{
|
|
UniquePtr<nsSplitterInfo[]> infos(new nsSplitterInfo[aCount]);
|
|
|
|
for (int i=0; i < aCount; i++)
|
|
infos[i] = aChildInfos[aCount - 1 - i];
|
|
|
|
aChildInfos = Move(infos);
|
|
}
|
|
|
|
bool
|
|
nsSplitterFrameInner::SupportsCollapseDirection
|
|
(
|
|
nsSplitterFrameInner::CollapseDirection aDirection
|
|
)
|
|
{
|
|
static nsIContent::AttrValuesArray strings[] =
|
|
{&nsGkAtoms::before, &nsGkAtoms::after, &nsGkAtoms::both, nullptr};
|
|
|
|
switch (mOuter->mContent->FindAttrValueIn(kNameSpaceID_None,
|
|
nsGkAtoms::collapse,
|
|
strings, eCaseMatters)) {
|
|
case 0:
|
|
return (aDirection == Before);
|
|
case 1:
|
|
return (aDirection == After);
|
|
case 2:
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void
|
|
nsSplitterFrameInner::UpdateState()
|
|
{
|
|
// State Transitions:
|
|
// Open -> Dragging
|
|
// Open -> CollapsedBefore
|
|
// Open -> CollapsedAfter
|
|
// CollapsedBefore -> Open
|
|
// CollapsedBefore -> Dragging
|
|
// CollapsedAfter -> Open
|
|
// CollapsedAfter -> Dragging
|
|
// Dragging -> Open
|
|
// Dragging -> CollapsedBefore (auto collapse)
|
|
// Dragging -> CollapsedAfter (auto collapse)
|
|
|
|
State newState = GetState();
|
|
|
|
if (newState == mState) {
|
|
// No change.
|
|
return;
|
|
}
|
|
|
|
if ((SupportsCollapseDirection(Before) || SupportsCollapseDirection(After)) &&
|
|
mOuter->GetParent()->IsBoxFrame()) {
|
|
// Find the splitter's immediate sibling.
|
|
nsIFrame* splitterSibling;
|
|
if (newState == CollapsedBefore || mState == CollapsedBefore) {
|
|
splitterSibling = mOuter->GetPrevSibling();
|
|
} else {
|
|
splitterSibling = mOuter->GetNextSibling();
|
|
}
|
|
|
|
if (splitterSibling) {
|
|
nsCOMPtr<nsIContent> sibling = splitterSibling->GetContent();
|
|
if (sibling) {
|
|
if (mState == CollapsedBefore || mState == CollapsedAfter) {
|
|
// CollapsedBefore -> Open
|
|
// CollapsedBefore -> Dragging
|
|
// CollapsedAfter -> Open
|
|
// CollapsedAfter -> Dragging
|
|
nsContentUtils::AddScriptRunner(
|
|
new nsUnsetAttrRunnable(sibling, nsGkAtoms::collapsed));
|
|
} else if ((mState == Open || mState == Dragging)
|
|
&& (newState == CollapsedBefore ||
|
|
newState == CollapsedAfter)) {
|
|
// Open -> CollapsedBefore / CollapsedAfter
|
|
// Dragging -> CollapsedBefore / CollapsedAfter
|
|
nsContentUtils::AddScriptRunner(
|
|
new nsSetAttrRunnable(sibling, nsGkAtoms::collapsed,
|
|
NS_LITERAL_STRING("true")));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
mState = newState;
|
|
}
|
|
|
|
void
|
|
nsSplitterFrameInner::EnsureOrient()
|
|
{
|
|
bool isHorizontal = !(mParentBox->GetStateBits() & NS_STATE_IS_HORIZONTAL);
|
|
if (isHorizontal)
|
|
mOuter->mState |= NS_STATE_IS_HORIZONTAL;
|
|
else
|
|
mOuter->mState &= ~NS_STATE_IS_HORIZONTAL;
|
|
}
|
|
|
|
void
|
|
nsSplitterFrameInner::AdjustChildren(nsPresContext* aPresContext)
|
|
{
|
|
EnsureOrient();
|
|
bool isHorizontal = !mOuter->IsHorizontal();
|
|
|
|
AdjustChildren(aPresContext, mChildInfosBefore.get(),
|
|
mChildInfosBeforeCount, isHorizontal);
|
|
AdjustChildren(aPresContext, mChildInfosAfter.get(),
|
|
mChildInfosAfterCount, isHorizontal);
|
|
}
|
|
|
|
static nsIFrame* GetChildBoxForContent(nsIFrame* aParentBox, nsIContent* aContent)
|
|
{
|
|
nsIFrame* childBox = nsBox::GetChildBox(aParentBox);
|
|
|
|
while (nullptr != childBox) {
|
|
if (childBox->GetContent() == aContent) {
|
|
return childBox;
|
|
}
|
|
childBox = nsBox::GetNextBox(childBox);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void
|
|
nsSplitterFrameInner::AdjustChildren(nsPresContext* aPresContext, nsSplitterInfo* aChildInfos, int32_t aCount, bool aIsHorizontal)
|
|
{
|
|
///printf("------- AdjustChildren------\n");
|
|
|
|
nsBoxLayoutState state(aPresContext);
|
|
|
|
nscoord onePixel = nsPresContext::CSSPixelsToAppUnits(1);
|
|
|
|
// first set all the widths.
|
|
nsIFrame* child = nsBox::GetChildBox(mOuter);
|
|
while(child)
|
|
{
|
|
SetPreferredSize(state, child, onePixel, aIsHorizontal, nullptr);
|
|
child = nsBox::GetNextBox(child);
|
|
}
|
|
|
|
// now set our changed widths.
|
|
for (int i=0; i < aCount; i++)
|
|
{
|
|
nscoord pref = aChildInfos[i].changed;
|
|
nsIFrame* childBox = GetChildBoxForContent(mParentBox, aChildInfos[i].childElem);
|
|
|
|
if (childBox) {
|
|
SetPreferredSize(state, childBox, onePixel, aIsHorizontal, &pref);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsSplitterFrameInner::SetPreferredSize(nsBoxLayoutState& aState, nsIFrame* aChildBox, nscoord aOnePixel, bool aIsHorizontal, nscoord* aSize)
|
|
{
|
|
nsRect rect(aChildBox->GetRect());
|
|
nscoord pref = 0;
|
|
|
|
if (!aSize)
|
|
{
|
|
if (aIsHorizontal)
|
|
pref = rect.width;
|
|
else
|
|
pref = rect.height;
|
|
} else {
|
|
pref = *aSize;
|
|
}
|
|
|
|
nsMargin margin(0,0,0,0);
|
|
aChildBox->GetMargin(margin);
|
|
|
|
nsCOMPtr<nsIAtom> attribute;
|
|
|
|
if (aIsHorizontal) {
|
|
pref -= (margin.left + margin.right);
|
|
attribute = nsGkAtoms::width;
|
|
} else {
|
|
pref -= (margin.top + margin.bottom);
|
|
attribute = nsGkAtoms::height;
|
|
}
|
|
|
|
nsIContent* content = aChildBox->GetContent();
|
|
|
|
// set its preferred size.
|
|
nsAutoString prefValue;
|
|
prefValue.AppendInt(pref/aOnePixel);
|
|
if (content->AttrValueIs(kNameSpaceID_None, attribute,
|
|
prefValue, eCaseMatters))
|
|
return;
|
|
|
|
nsWeakFrame weakBox(aChildBox);
|
|
content->SetAttr(kNameSpaceID_None, attribute, prefValue, true);
|
|
ENSURE_TRUE(weakBox.IsAlive());
|
|
aState.PresShell()->FrameNeedsReflow(aChildBox, nsIPresShell::eStyleChange,
|
|
NS_FRAME_IS_DIRTY);
|
|
}
|
|
|
|
|
|
void
|
|
nsSplitterFrameInner::AddRemoveSpace(nscoord aDiff,
|
|
nsSplitterInfo* aChildInfos,
|
|
int32_t aCount,
|
|
int32_t& aSpaceLeft)
|
|
{
|
|
aSpaceLeft = 0;
|
|
|
|
for (int i=0; i < aCount; i++) {
|
|
nscoord min = aChildInfos[i].min;
|
|
nscoord max = aChildInfos[i].max;
|
|
nscoord& c = aChildInfos[i].changed;
|
|
|
|
// figure our how much space to add or remove
|
|
if (c + aDiff < min) {
|
|
aDiff += (c - min);
|
|
c = min;
|
|
} else if (c + aDiff > max) {
|
|
aDiff -= (max - c);
|
|
c = max;
|
|
} else {
|
|
c += aDiff;
|
|
aDiff = 0;
|
|
}
|
|
|
|
// there is not space left? We are done
|
|
if (aDiff == 0)
|
|
break;
|
|
}
|
|
|
|
aSpaceLeft = aDiff;
|
|
}
|
|
|
|
/**
|
|
* Ok if we want to resize a child we will know the actual size in pixels we want it to be.
|
|
* This is not the preferred size. But they only way we can change a child is my manipulating its
|
|
* preferred size. So give the actual pixel size this return method will return figure out the preferred
|
|
* size and set it.
|
|
*/
|
|
|
|
void
|
|
nsSplitterFrameInner::ResizeChildTo(nscoord& aDiff,
|
|
nsSplitterInfo* aChildrenBeforeInfos,
|
|
nsSplitterInfo* aChildrenAfterInfos,
|
|
int32_t aChildrenBeforeCount,
|
|
int32_t aChildrenAfterCount,
|
|
bool aBounded)
|
|
{
|
|
nscoord spaceLeft;
|
|
AddRemoveSpace(aDiff, aChildrenBeforeInfos,aChildrenBeforeCount,spaceLeft);
|
|
|
|
// if there is any space left over remove it from the dif we were originally given
|
|
aDiff -= spaceLeft;
|
|
AddRemoveSpace(-aDiff, aChildrenAfterInfos,aChildrenAfterCount,spaceLeft);
|
|
|
|
if (spaceLeft != 0) {
|
|
if (aBounded) {
|
|
aDiff += spaceLeft;
|
|
AddRemoveSpace(spaceLeft, aChildrenBeforeInfos,aChildrenBeforeCount,spaceLeft);
|
|
}
|
|
}
|
|
}
|