forked from mirrors/gecko-dev
647 lines
25 KiB
C++
647 lines
25 KiB
C++
/* -*- 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/. */
|
|
|
|
#ifndef nsTreeBodyFrame_h
|
|
#define nsTreeBodyFrame_h
|
|
|
|
#include "mozilla/AtomArray.h"
|
|
#include "mozilla/Attributes.h"
|
|
|
|
#include "nsLeafBoxFrame.h"
|
|
#include "nsITreeView.h"
|
|
#include "nsIScrollbarMediator.h"
|
|
#include "nsITimer.h"
|
|
#include "nsIReflowCallback.h"
|
|
#include "nsTArray.h"
|
|
#include "nsTreeStyleCache.h"
|
|
#include "nsTreeColumns.h"
|
|
#include "nsDataHashtable.h"
|
|
#include "imgIRequest.h"
|
|
#include "imgINotificationObserver.h"
|
|
#include "nsScrollbarFrame.h"
|
|
#include "nsThreadUtils.h"
|
|
#include "mozilla/LookAndFeel.h"
|
|
|
|
class nsFontMetrics;
|
|
class nsOverflowChecker;
|
|
class nsTreeImageListener;
|
|
|
|
namespace mozilla {
|
|
namespace layout {
|
|
class ScrollbarActivity;
|
|
} // namespace layout
|
|
} // namespace mozilla
|
|
|
|
// An entry in the tree's image cache
|
|
struct nsTreeImageCacheEntry
|
|
{
|
|
nsTreeImageCacheEntry() = default;
|
|
nsTreeImageCacheEntry(imgIRequest* aRequest,
|
|
imgINotificationObserver* aListener)
|
|
: request(aRequest)
|
|
, listener(aListener)
|
|
{ }
|
|
|
|
nsCOMPtr<imgIRequest> request;
|
|
nsCOMPtr<imgINotificationObserver> listener;
|
|
};
|
|
|
|
// The actual frame that paints the cells and rows.
|
|
class nsTreeBodyFrame final
|
|
: public nsLeafBoxFrame
|
|
, public nsIScrollbarMediator
|
|
, public nsIReflowCallback
|
|
{
|
|
typedef mozilla::layout::ScrollbarActivity ScrollbarActivity;
|
|
typedef mozilla::image::ImgDrawResult ImgDrawResult;
|
|
|
|
public:
|
|
explicit nsTreeBodyFrame(ComputedStyle* aStyle);
|
|
~nsTreeBodyFrame();
|
|
|
|
NS_DECL_QUERYFRAME
|
|
NS_DECL_FRAMEARENA_HELPERS(nsTreeBodyFrame)
|
|
|
|
// Callback handler methods for refresh driver based animations.
|
|
// Calls to these functions are forwarded from nsTreeImageListener. These
|
|
// mirror how nsImageFrame works.
|
|
nsresult OnImageIsAnimated(imgIRequest* aRequest);
|
|
|
|
// non-virtual signatures like nsITreeBodyFrame
|
|
already_AddRefed<nsTreeColumns> Columns() const
|
|
{
|
|
RefPtr<nsTreeColumns> cols = mColumns;
|
|
return cols.forget();
|
|
}
|
|
already_AddRefed<nsITreeView> GetExistingView() const
|
|
{
|
|
nsCOMPtr<nsITreeView> view = mView;
|
|
return view.forget();
|
|
}
|
|
nsresult GetView(nsITreeView **aView);
|
|
nsresult SetView(nsITreeView *aView);
|
|
bool GetFocused() const { return mFocused; }
|
|
nsresult SetFocused(bool aFocused);
|
|
nsresult GetTreeBody(mozilla::dom::Element **aElement);
|
|
int32_t RowHeight() const;
|
|
int32_t RowWidth();
|
|
int32_t GetHorizontalPosition() const;
|
|
mozilla::Maybe<mozilla::CSSIntRegion> GetSelectionRegion();
|
|
int32_t FirstVisibleRow() const { return mTopRowIndex; }
|
|
int32_t LastVisibleRow() const { return mTopRowIndex + mPageLength; }
|
|
int32_t PageLength() const { return mPageLength; }
|
|
nsresult EnsureRowIsVisible(int32_t aRow);
|
|
nsresult EnsureCellIsVisible(int32_t aRow, nsTreeColumn *aCol);
|
|
void ScrollToRow(int32_t aRow);
|
|
void ScrollByLines(int32_t aNumLines);
|
|
void ScrollByPages(int32_t aNumPages);
|
|
nsresult Invalidate();
|
|
nsresult InvalidateColumn(nsTreeColumn *aCol);
|
|
nsresult InvalidateRow(int32_t aRow);
|
|
nsresult InvalidateCell(int32_t aRow, nsTreeColumn *aCol);
|
|
nsresult InvalidateRange(int32_t aStart, int32_t aEnd);
|
|
int32_t GetRowAt(int32_t aX, int32_t aY);
|
|
nsresult GetCellAt(int32_t aX, int32_t aY, int32_t *aRow,
|
|
nsTreeColumn **aCol, nsACString &aChildElt);
|
|
nsresult GetCoordsForCellItem(int32_t aRow, nsTreeColumn *aCol,
|
|
const nsACString &aElt,
|
|
int32_t *aX, int32_t *aY,
|
|
int32_t *aWidth, int32_t *aHeight);
|
|
nsresult IsCellCropped(int32_t aRow, nsTreeColumn *aCol, bool *aResult);
|
|
nsresult RowCountChanged(int32_t aIndex, int32_t aCount);
|
|
nsresult BeginUpdateBatch();
|
|
nsresult EndUpdateBatch();
|
|
nsresult ClearStyleAndImageCaches();
|
|
void RemoveImageCacheEntry(int32_t aRowIndex, nsTreeColumn* aCol);
|
|
|
|
void CancelImageRequests();
|
|
|
|
void ManageReflowCallback(const nsRect& aRect, nscoord aHorzWidth);
|
|
|
|
virtual nsSize GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) override;
|
|
virtual void SetXULBounds(nsBoxLayoutState& aBoxLayoutState, const nsRect& aRect,
|
|
bool aRemoveOverflowArea = false) override;
|
|
|
|
// nsIReflowCallback
|
|
virtual bool ReflowFinished() override;
|
|
virtual void ReflowCallbackCanceled() override;
|
|
|
|
// nsIScrollbarMediator
|
|
virtual void ScrollByPage(nsScrollbarFrame* aScrollbar, int32_t aDirection,
|
|
nsIScrollbarMediator::ScrollSnapMode aSnap
|
|
= nsIScrollbarMediator::DISABLE_SNAP) override;
|
|
virtual void ScrollByWhole(nsScrollbarFrame* aScrollbar, int32_t aDirection,
|
|
nsIScrollbarMediator::ScrollSnapMode aSnap
|
|
= nsIScrollbarMediator::DISABLE_SNAP) override;
|
|
virtual void ScrollByLine(nsScrollbarFrame* aScrollbar, int32_t aDirection,
|
|
nsIScrollbarMediator::ScrollSnapMode aSnap
|
|
= nsIScrollbarMediator::DISABLE_SNAP) override;
|
|
virtual void RepeatButtonScroll(nsScrollbarFrame* aScrollbar) override;
|
|
virtual void ThumbMoved(nsScrollbarFrame* aScrollbar,
|
|
nscoord aOldPos,
|
|
nscoord aNewPos) override;
|
|
virtual void ScrollbarReleased(nsScrollbarFrame* aScrollbar) override {}
|
|
virtual void VisibilityChanged(bool aVisible) override { Invalidate(); }
|
|
virtual nsIFrame* GetScrollbarBox(bool aVertical) override {
|
|
ScrollParts parts = GetScrollParts();
|
|
return aVertical ? parts.mVScrollbar : parts.mHScrollbar;
|
|
}
|
|
virtual void ScrollbarActivityStarted() const override;
|
|
virtual void ScrollbarActivityStopped() const override;
|
|
virtual bool IsScrollbarOnRight() const override {
|
|
return (StyleVisibility()->mDirection == NS_STYLE_DIRECTION_LTR);
|
|
}
|
|
virtual bool ShouldSuppressScrollbarRepaints() const override {
|
|
return false;
|
|
}
|
|
|
|
// Overridden from nsIFrame to cache our pres context.
|
|
virtual void Init(nsIContent* aContent,
|
|
nsContainerFrame* aParent,
|
|
nsIFrame* aPrevInFlow) override;
|
|
virtual void DestroyFrom(nsIFrame* aDestructRoot, PostDestroyData& aPostDestroyData) override;
|
|
|
|
virtual nsresult GetCursor(const nsPoint& aPoint,
|
|
nsIFrame::Cursor& aCursor) override;
|
|
|
|
virtual nsresult HandleEvent(nsPresContext* aPresContext,
|
|
mozilla::WidgetGUIEvent* aEvent,
|
|
nsEventStatus* aEventStatus) override;
|
|
|
|
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
|
|
const nsDisplayListSet& aLists) override;
|
|
|
|
virtual void DidSetComputedStyle(ComputedStyle* aOldComputedStyle) override;
|
|
|
|
friend nsIFrame* NS_NewTreeBodyFrame(nsIPresShell* aPresShell);
|
|
friend class nsTreeColumn;
|
|
|
|
struct ScrollParts {
|
|
nsScrollbarFrame* mVScrollbar;
|
|
RefPtr<Element> mVScrollbarContent;
|
|
nsScrollbarFrame* mHScrollbar;
|
|
RefPtr<Element> mHScrollbarContent;
|
|
nsIFrame* mColumnsFrame;
|
|
nsIScrollableFrame* mColumnsScrollFrame;
|
|
};
|
|
|
|
ImgDrawResult PaintTreeBody(gfxContext& aRenderingContext,
|
|
const nsRect& aDirtyRect, nsPoint aPt,
|
|
nsDisplayListBuilder* aBuilder);
|
|
|
|
nsITreeBoxObject* GetTreeBoxObject() const { return mTreeBoxObject; }
|
|
|
|
// Get the base element, <tree>
|
|
mozilla::dom::Element* GetBaseElement();
|
|
|
|
bool GetVerticalOverflow() const { return mVerticalOverflow; }
|
|
bool GetHorizontalOverflow() const {return mHorizontalOverflow; }
|
|
|
|
// This returns the property array where atoms are stored for style during
|
|
// draw, whether the row currently being drawn is selected, hovered, etc.
|
|
const mozilla::AtomArray& GetPropertyArrayForCurrentDrawingItem()
|
|
{
|
|
return mScratchArray;
|
|
}
|
|
|
|
protected:
|
|
friend class nsOverflowChecker;
|
|
|
|
// This method paints a specific column background of the tree.
|
|
ImgDrawResult PaintColumn(nsTreeColumn* aColumn,
|
|
const nsRect& aColumnRect,
|
|
nsPresContext* aPresContext,
|
|
gfxContext& aRenderingContext,
|
|
const nsRect& aDirtyRect);
|
|
|
|
// This method paints a single row in the tree.
|
|
ImgDrawResult PaintRow(int32_t aRowIndex,
|
|
const nsRect& aRowRect,
|
|
nsPresContext* aPresContext,
|
|
gfxContext& aRenderingContext,
|
|
const nsRect& aDirtyRect,
|
|
nsPoint aPt,
|
|
nsDisplayListBuilder* aBuilder);
|
|
|
|
// This method paints a single separator in the tree.
|
|
ImgDrawResult PaintSeparator(int32_t aRowIndex,
|
|
const nsRect& aSeparatorRect,
|
|
nsPresContext* aPresContext,
|
|
gfxContext& aRenderingContext,
|
|
const nsRect& aDirtyRect);
|
|
|
|
// This method paints a specific cell in a given row of the tree.
|
|
ImgDrawResult PaintCell(int32_t aRowIndex,
|
|
nsTreeColumn* aColumn,
|
|
const nsRect& aCellRect,
|
|
nsPresContext* aPresContext,
|
|
gfxContext& aRenderingContext,
|
|
const nsRect& aDirtyRect,
|
|
nscoord& aCurrX,
|
|
nsPoint aPt,
|
|
nsDisplayListBuilder* aBuilder);
|
|
|
|
// This method paints the twisty inside a cell in the primary column of an tree.
|
|
ImgDrawResult PaintTwisty(int32_t aRowIndex,
|
|
nsTreeColumn* aColumn,
|
|
const nsRect& aTwistyRect,
|
|
nsPresContext* aPresContext,
|
|
gfxContext& aRenderingContext,
|
|
const nsRect& aDirtyRect,
|
|
nscoord& aRemainingWidth,
|
|
nscoord& aCurrX);
|
|
|
|
// This method paints the image inside the cell of an tree.
|
|
ImgDrawResult PaintImage(int32_t aRowIndex,
|
|
nsTreeColumn* aColumn,
|
|
const nsRect& aImageRect,
|
|
nsPresContext* aPresContext,
|
|
gfxContext& aRenderingContext,
|
|
const nsRect& aDirtyRect,
|
|
nscoord& aRemainingWidth,
|
|
nscoord& aCurrX,
|
|
nsDisplayListBuilder* aBuilder);
|
|
|
|
// This method paints the text string inside a particular cell of the tree.
|
|
ImgDrawResult PaintText(int32_t aRowIndex,
|
|
nsTreeColumn* aColumn,
|
|
const nsRect& aTextRect,
|
|
nsPresContext* aPresContext,
|
|
gfxContext& aRenderingContext,
|
|
const nsRect& aDirtyRect,
|
|
nscoord& aCurrX);
|
|
|
|
// This method paints the checkbox inside a particular cell of the tree.
|
|
ImgDrawResult PaintCheckbox(int32_t aRowIndex,
|
|
nsTreeColumn* aColumn,
|
|
const nsRect& aCheckboxRect,
|
|
nsPresContext* aPresContext,
|
|
gfxContext& aRenderingContext,
|
|
const nsRect& aDirtyRect);
|
|
|
|
// This method paints a drop feedback of the tree.
|
|
ImgDrawResult PaintDropFeedback(const nsRect& aDropFeedbackRect,
|
|
nsPresContext* aPresContext,
|
|
gfxContext& aRenderingContext,
|
|
const nsRect& aDirtyRect,
|
|
nsPoint aPt);
|
|
|
|
// This method is called with a specific ComputedStyle and rect to
|
|
// paint the background rect as if it were a full-blown frame.
|
|
ImgDrawResult PaintBackgroundLayer(ComputedStyle* aComputedStyle,
|
|
nsPresContext* aPresContext,
|
|
gfxContext& aRenderingContext,
|
|
const nsRect& aRect,
|
|
const nsRect& aDirtyRect);
|
|
|
|
|
|
// An internal hit test. aX and aY are expected to be in twips in the
|
|
// coordinate system of this frame.
|
|
int32_t GetRowAtInternal(nscoord aX, nscoord aY);
|
|
|
|
// Check for bidi characters in the text, and if there are any, ensure
|
|
// that the prescontext is in bidi mode.
|
|
void CheckTextForBidi(nsAutoString& aText);
|
|
|
|
void AdjustForCellText(nsAutoString& aText,
|
|
int32_t aRowIndex,
|
|
nsTreeColumn* aColumn,
|
|
gfxContext& aRenderingContext,
|
|
nsFontMetrics& aFontMetrics,
|
|
nsRect& aTextRect);
|
|
|
|
// A helper used when hit testing.
|
|
nsICSSAnonBoxPseudo* GetItemWithinCellAt(nscoord aX,
|
|
const nsRect& aCellRect,
|
|
int32_t aRowIndex,
|
|
nsTreeColumn* aColumn);
|
|
|
|
// An internal hit test. aX and aY are expected to be in twips in the
|
|
// coordinate system of this frame.
|
|
void GetCellAt(nscoord aX, nscoord aY, int32_t* aRow, nsTreeColumn** aCol,
|
|
nsICSSAnonBoxPseudo** aChildElt);
|
|
|
|
// Retrieve the area for the twisty for a cell.
|
|
nsITheme* GetTwistyRect(int32_t aRowIndex,
|
|
nsTreeColumn* aColumn,
|
|
nsRect& aImageRect,
|
|
nsRect& aTwistyRect,
|
|
nsPresContext* aPresContext,
|
|
ComputedStyle* aTwistyContext);
|
|
|
|
// Fetch an image from the image cache.
|
|
nsresult GetImage(int32_t aRowIndex, nsTreeColumn* aCol, bool aUseContext,
|
|
ComputedStyle* aComputedStyle, bool& aAllowImageRegions, imgIContainer** aResult);
|
|
|
|
// Returns the size of a given image. This size *includes* border and
|
|
// padding. It does not include margins.
|
|
nsRect GetImageSize(int32_t aRowIndex, nsTreeColumn* aCol, bool aUseContext, ComputedStyle* aComputedStyle);
|
|
|
|
// Returns the destination size of the image, not including borders and padding.
|
|
nsSize GetImageDestSize(ComputedStyle* aComputedStyle, bool useImageRegion, imgIContainer* image);
|
|
|
|
// Returns the source rectangle of the image to be displayed.
|
|
nsRect GetImageSourceRect(ComputedStyle* aComputedStyle, bool useImageRegion, imgIContainer* image);
|
|
|
|
// Returns the height of rows in the tree.
|
|
int32_t GetRowHeight();
|
|
|
|
// Returns our indentation width.
|
|
int32_t GetIndentation();
|
|
|
|
// Calculates our width/height once border and padding have been removed.
|
|
void CalcInnerBox();
|
|
|
|
// Calculate the total width of our scrollable portion
|
|
nscoord CalcHorzWidth(const ScrollParts& aParts);
|
|
|
|
// Looks up a ComputedStyle in the style cache. On a cache miss we resolve
|
|
// the pseudo-styles passed in and place them into the cache.
|
|
ComputedStyle* GetPseudoComputedStyle(nsICSSAnonBoxPseudo* aPseudoElement);
|
|
|
|
// Retrieves the scrollbars and scrollview relevant to this treebody. We
|
|
// traverse the frame tree under our base element, in frame order, looking
|
|
// for the first relevant vertical scrollbar, horizontal scrollbar, and
|
|
// scrollable frame (with associated content and scrollable view). These
|
|
// are all volatile and should not be retained.
|
|
ScrollParts GetScrollParts();
|
|
|
|
// Update the curpos of the scrollbar.
|
|
void UpdateScrollbars(const ScrollParts& aParts);
|
|
|
|
// Update the maxpos of the scrollbar.
|
|
void InvalidateScrollbars(const ScrollParts& aParts, AutoWeakFrame& aWeakColumnsFrame);
|
|
|
|
// Check overflow and generate events.
|
|
void CheckOverflow(const ScrollParts& aParts);
|
|
|
|
// Calls UpdateScrollbars, Invalidate aNeedsFullInvalidation if true,
|
|
// InvalidateScrollbars and finally CheckOverflow.
|
|
// returns true if the frame is still alive after the method call.
|
|
bool FullScrollbarsUpdate(bool aNeedsFullInvalidation);
|
|
|
|
// Use to auto-fill some of the common properties without the view having to do it.
|
|
// Examples include container, open, selected, and focus.
|
|
void PrefillPropertyArray(int32_t aRowIndex, nsTreeColumn* aCol);
|
|
|
|
// Our internal scroll method, used by all the public scroll methods.
|
|
nsresult ScrollInternal(const ScrollParts& aParts, int32_t aRow);
|
|
nsresult ScrollToRowInternal(const ScrollParts& aParts, int32_t aRow);
|
|
nsresult ScrollHorzInternal(const ScrollParts& aParts, int32_t aPosition);
|
|
nsresult EnsureRowIsVisibleInternal(const ScrollParts& aParts, int32_t aRow);
|
|
|
|
// Convert client pixels into appunits in our coordinate space.
|
|
nsPoint AdjustClientCoordsToBoxCoordSpace(int32_t aX, int32_t aY);
|
|
|
|
// Cache the box object
|
|
void EnsureBoxObject();
|
|
|
|
void EnsureView();
|
|
|
|
nsresult GetCellWidth(int32_t aRow, nsTreeColumn* aCol,
|
|
gfxContext* aRenderingContext,
|
|
nscoord& aDesiredSize, nscoord& aCurrentSize);
|
|
nscoord CalcMaxRowWidth();
|
|
|
|
// Translate the given rect horizontally from tree coordinates into the
|
|
// coordinate system of our nsTreeBodyFrame. If clip is true, then clip the
|
|
// rect to its intersection with mInnerBox in the horizontal direction.
|
|
// Return whether the result has a nonempty intersection with mInnerBox
|
|
// after projecting both onto the horizontal coordinate axis.
|
|
bool OffsetForHorzScroll(nsRect& rect, bool clip);
|
|
|
|
bool CanAutoScroll(int32_t aRowIndex);
|
|
|
|
// Calc the row and above/below/on status given where the mouse currently is hovering.
|
|
// Also calc if we're in the region in which we want to auto-scroll the tree.
|
|
// A positive value of |aScrollLines| means scroll down, a negative value
|
|
// means scroll up, a zero value means that we aren't in drag scroll region.
|
|
void ComputeDropPosition(mozilla::WidgetGUIEvent* aEvent,
|
|
int32_t* aRow,
|
|
int16_t* aOrient,
|
|
int16_t* aScrollLines);
|
|
|
|
void InvalidateDropFeedback(int32_t aRow, int16_t aOrientation) {
|
|
InvalidateRow(aRow);
|
|
if (aOrientation != nsITreeView::DROP_ON)
|
|
InvalidateRow(aRow + aOrientation);
|
|
}
|
|
|
|
public:
|
|
/**
|
|
* Remove an nsITreeImageListener from being tracked by this frame. Only tree
|
|
* image listeners that are created by this frame are tracked.
|
|
*
|
|
* @param aListener A pointer to an nsTreeImageListener to no longer
|
|
* track.
|
|
*/
|
|
void RemoveTreeImageListener(nsTreeImageListener* aListener);
|
|
|
|
protected:
|
|
|
|
// Create a new timer. This method is used to delay various actions like
|
|
// opening/closing folders or tree scrolling.
|
|
// aID is type of the action, aFunc is the function to be called when
|
|
// the timer fires and aType is type of timer - one shot or repeating.
|
|
nsresult CreateTimer(const mozilla::LookAndFeel::IntID aID,
|
|
nsTimerCallbackFunc aFunc, int32_t aType,
|
|
nsITimer** aTimer, const char* aName);
|
|
|
|
static void OpenCallback(nsITimer *aTimer, void *aClosure);
|
|
|
|
static void CloseCallback(nsITimer *aTimer, void *aClosure);
|
|
|
|
static void LazyScrollCallback(nsITimer *aTimer, void *aClosure);
|
|
|
|
static void ScrollCallback(nsITimer *aTimer, void *aClosure);
|
|
|
|
class ScrollEvent : public mozilla::Runnable {
|
|
public:
|
|
NS_DECL_NSIRUNNABLE
|
|
explicit ScrollEvent(nsTreeBodyFrame* aInner)
|
|
: mozilla::Runnable("nsTreeBodyFrame::ScrollEvent")
|
|
, mInner(aInner)
|
|
{
|
|
}
|
|
void Revoke() { mInner = nullptr; }
|
|
private:
|
|
nsTreeBodyFrame* mInner;
|
|
};
|
|
|
|
void PostScrollEvent();
|
|
void FireScrollEvent();
|
|
|
|
/**
|
|
* Clear the pointer to this frame for all nsTreeImageListeners that were
|
|
* created by this frame.
|
|
*/
|
|
void DetachImageListeners();
|
|
|
|
#ifdef ACCESSIBILITY
|
|
/**
|
|
* Fires 'treeRowCountChanged' event asynchronously. The event is a
|
|
* CustomEvent that is used to expose the following information structures
|
|
* via a property bag.
|
|
*
|
|
* @param aIndex the row index rows are added/removed from
|
|
* @param aCount the number of added/removed rows (the sign points to
|
|
* an operation, plus - addition, minus - removing)
|
|
*/
|
|
void FireRowCountChangedEvent(int32_t aIndex, int32_t aCount);
|
|
|
|
/**
|
|
* Fires 'treeInvalidated' event asynchronously. The event is a CustomEvent
|
|
* that is used to expose the information structures described by method
|
|
* arguments via a property bag.
|
|
*
|
|
* @param aStartRow the start index of invalidated rows, -1 means that
|
|
* columns have been invalidated only
|
|
* @param aEndRow the end index of invalidated rows, -1 means that columns
|
|
* have been invalidated only
|
|
* @param aStartCol the start invalidated column, nullptr means that only rows
|
|
* have been invalidated
|
|
* @param aEndCol the end invalidated column, nullptr means that rows have
|
|
* been invalidated only
|
|
*/
|
|
void FireInvalidateEvent(int32_t aStartRow, int32_t aEndRow,
|
|
nsTreeColumn *aStartCol, nsTreeColumn *aEndCol);
|
|
#endif
|
|
|
|
protected: // Data Members
|
|
|
|
class Slots {
|
|
public:
|
|
Slots()
|
|
: mDropAllowed(false)
|
|
, mIsDragging(false)
|
|
, mDropRow(-1)
|
|
, mDropOrient(-1)
|
|
, mScrollLines(0)
|
|
, mDragAction(0) {
|
|
}
|
|
|
|
~Slots() {
|
|
if (mTimer)
|
|
mTimer->Cancel();
|
|
}
|
|
|
|
friend class nsTreeBodyFrame;
|
|
|
|
protected:
|
|
// If the drop is actually allowed here or not.
|
|
bool mDropAllowed;
|
|
|
|
// True while dragging over the tree.
|
|
bool mIsDragging;
|
|
|
|
// The row the mouse is hovering over during a drop.
|
|
int32_t mDropRow;
|
|
|
|
// Where we want to draw feedback (above/on this row/below) if allowed.
|
|
int16_t mDropOrient;
|
|
|
|
// Number of lines to be scrolled.
|
|
int16_t mScrollLines;
|
|
|
|
// The drag action that was received for this slot
|
|
uint32_t mDragAction;
|
|
|
|
// Timer for opening/closing spring loaded folders or scrolling the tree.
|
|
nsCOMPtr<nsITimer> mTimer;
|
|
|
|
// An array used to keep track of all spring loaded folders.
|
|
nsTArray<int32_t> mArray;
|
|
};
|
|
|
|
Slots* mSlots;
|
|
|
|
nsRevocableEventPtr<ScrollEvent> mScrollEvent;
|
|
|
|
RefPtr<ScrollbarActivity> mScrollbarActivity;
|
|
|
|
// The cached box object parent.
|
|
nsCOMPtr<nsITreeBoxObject> mTreeBoxObject;
|
|
|
|
// Cached column information.
|
|
RefPtr<nsTreeColumns> mColumns;
|
|
|
|
// The current view for this tree widget. We get all of our row and cell data
|
|
// from the view.
|
|
nsCOMPtr<nsITreeView> mView;
|
|
|
|
// A cache of all the ComputedStyles we have seen for rows and cells of the tree. This is a mapping from
|
|
// a list of atoms to a corresponding ComputedStyle. This cache stores every combination that
|
|
// occurs in the tree, so for n distinct properties, this cache could have 2 to the n entries
|
|
// (the power set of all row properties).
|
|
nsTreeStyleCache mStyleCache;
|
|
|
|
// A hashtable that maps from URLs to image request/listener pairs. The URL
|
|
// is provided by the view or by the ComputedStyle. The ComputedStyle
|
|
// represents a resolved :-moz-tree-cell-image (or twisty) pseudo-element.
|
|
// It maps directly to an imgIRequest.
|
|
nsDataHashtable<nsStringHashKey, nsTreeImageCacheEntry> mImageCache;
|
|
|
|
// A scratch array used when looking up cached ComputedStyles.
|
|
mozilla::AtomArray mScratchArray;
|
|
|
|
// The index of the first visible row and the # of rows visible onscreen.
|
|
// The tree only examines onscreen rows, starting from
|
|
// this index and going up to index+pageLength.
|
|
int32_t mTopRowIndex;
|
|
int32_t mPageLength;
|
|
|
|
// The horizontal scroll position
|
|
nscoord mHorzPosition;
|
|
|
|
// The original desired horizontal width before changing it and posting a
|
|
// reflow callback. In some cases, the desired horizontal width can first be
|
|
// different from the current desired horizontal width, only to return to
|
|
// the same value later during the same reflow. In this case, we can cancel
|
|
// the posted reflow callback and prevent an unnecessary reflow.
|
|
nscoord mOriginalHorzWidth;
|
|
// Our desired horizontal width (the width for which we actually have tree
|
|
// columns).
|
|
nscoord mHorzWidth;
|
|
// The amount by which to adjust the width of the last cell.
|
|
// This depends on whether or not the columnpicker and scrollbars are present.
|
|
nscoord mAdjustWidth;
|
|
|
|
// Cached heights and indent info.
|
|
nsRect mInnerBox; // 4-byte aligned
|
|
int32_t mRowHeight;
|
|
int32_t mIndentation;
|
|
nscoord mStringWidth;
|
|
|
|
int32_t mUpdateBatchNest;
|
|
|
|
// Cached row count.
|
|
int32_t mRowCount;
|
|
|
|
// The row the mouse is hovering over.
|
|
int32_t mMouseOverRow;
|
|
|
|
// Whether or not we're currently focused.
|
|
bool mFocused;
|
|
|
|
// Do we have a fixed number of onscreen rows?
|
|
bool mHasFixedRowCount;
|
|
|
|
bool mVerticalOverflow;
|
|
bool mHorizontalOverflow;
|
|
|
|
bool mReflowCallbackPosted;
|
|
|
|
// Set while we flush layout to take account of effects of
|
|
// overflow/underflow event handlers
|
|
bool mCheckingOverflow;
|
|
|
|
// Hash table to keep track of which listeners we created and thus
|
|
// have pointers to us.
|
|
nsTHashtable<nsPtrHashKey<nsTreeImageListener> > mCreatedListeners;
|
|
|
|
}; // class nsTreeBodyFrame
|
|
|
|
#endif
|