/usr/include/thunderbird/nsSplittableFrame.h is in thunderbird-dev 1:52.8.0-1~deb8u1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 | /* -*- 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/. */
/*
* base class for rendering objects that can be split across lines,
* columns, or pages
*/
#ifndef nsSplittableFrame_h___
#define nsSplittableFrame_h___
#include "mozilla/Attributes.h"
#include "nsFrame.h"
// Derived class that allows splitting
class nsSplittableFrame : public nsFrame
{
public:
NS_DECL_ABSTRACT_FRAME(nsSplittableFrame)
virtual void Init(nsIContent* aContent,
nsContainerFrame* aParent,
nsIFrame* aPrevInFlow) override;
virtual nsSplittableType GetSplittableType() const override;
virtual void DestroyFrom(nsIFrame* aDestructRoot) override;
/*
* Frame continuations can be either fluid or not:
* Fluid continuations ("in-flows") are the result of line breaking,
* column breaking, or page breaking.
* Other (non-fluid) continuations can be the result of BiDi frame splitting.
* A "flow" is a chain of fluid continuations.
*/
// Get the previous/next continuation, regardless of its type (fluid or non-fluid).
virtual nsIFrame* GetPrevContinuation() const override;
virtual nsIFrame* GetNextContinuation() const override;
// Set a previous/next non-fluid continuation.
virtual void SetPrevContinuation(nsIFrame*) override;
virtual void SetNextContinuation(nsIFrame*) override;
// Get the first/last continuation for this frame.
virtual nsIFrame* FirstContinuation() const override;
virtual nsIFrame* LastContinuation() const override;
#ifdef DEBUG
// Can aFrame2 be reached from aFrame1 by following prev/next continuations?
static bool IsInPrevContinuationChain(nsIFrame* aFrame1, nsIFrame* aFrame2);
static bool IsInNextContinuationChain(nsIFrame* aFrame1, nsIFrame* aFrame2);
#endif
// Get the previous/next continuation, only if it is fluid (an "in-flow").
nsIFrame* GetPrevInFlow() const;
nsIFrame* GetNextInFlow() const;
virtual nsIFrame* GetPrevInFlowVirtual() const override { return GetPrevInFlow(); }
virtual nsIFrame* GetNextInFlowVirtual() const override { return GetNextInFlow(); }
// Set a previous/next fluid continuation.
virtual void SetPrevInFlow(nsIFrame*) override;
virtual void SetNextInFlow(nsIFrame*) override;
// Get the first/last frame in the current flow.
virtual nsIFrame* FirstInFlow() const override;
virtual nsIFrame* LastInFlow() const override;
// Remove the frame from the flow. Connects the frame's prev-in-flow
// and its next-in-flow. This should only be called in frame Destroy() methods.
static void RemoveFromFlow(nsIFrame* aFrame);
protected:
explicit nsSplittableFrame(nsStyleContext* aContext) : nsFrame(aContext) {}
/**
* Determine the height consumed by our previous-in-flows.
*
* @note (bz) This makes laying out a splittable frame with N in-flows
* O(N^2)! So, use this function with caution and minimize the number
* of calls to this method.
*/
nscoord GetConsumedBSize() const;
/**
* Retrieve the effective computed block size of this frame, which is the
* computed block size, minus the block size consumed by any previous in-flows.
*/
nscoord GetEffectiveComputedBSize(const ReflowInput& aReflowInput,
nscoord aConsumed = NS_INTRINSICSIZE) const;
/**
* @see nsIFrame::GetLogicalSkipSides()
*/
virtual LogicalSides GetLogicalSkipSides(const ReflowInput* aReflowInput = nullptr) const override;
/**
* A faster version of GetLogicalSkipSides() that is intended to be used
* inside Reflow before it's known if |this| frame will be COMPLETE or not.
* It returns a result that assumes this fragment is the last and thus
* should apply the block-end border/padding etc (except for "true" overflow
* containers which always skip block sides). You're then expected to
* recalculate the block-end side (as needed) when you know |this| frame's
* reflow status is INCOMPLETE.
* This method is intended for frames that breaks in the block axis.
*/
LogicalSides PreReflowBlockLevelLogicalSkipSides() const;
#ifdef DEBUG
virtual void DumpBaseRegressionData(nsPresContext* aPresContext, FILE* out, int32_t aIndent) override;
#endif
nsIFrame* mPrevContinuation;
nsIFrame* mNextContinuation;
};
#endif /* nsSplittableFrame_h___ */
|