/* -*- 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/. */ #ifndef WritingModes_h_ #define WritingModes_h_ #include "nsRect.h" #include "nsStyleContext.h" #include "nsBidiUtils.h" // It is the caller's responsibility to operate on logical-coordinate objects // with matched writing modes. Failure to do so will be a runtime bug; the // compiler can't catch it, but in debug mode, we'll throw an assertion. // NOTE that in non-debug builds, a writing mode mismatch error will NOT be // detected, yet the results will be nonsense (and may lead to further layout // failures). Therefore, it is important to test (and fuzz-test) writing-mode // support using debug builds. // Methods in logical-coordinate classes that take another logical-coordinate // object as a parameter should call CHECK_WRITING_MODE on it to verify that // the writing modes match. // (In some cases, there are internal (private) methods that don't do this; // such methods should only be used by other methods that have already checked // the writing modes.) // The check ignores the eSidewaysMask bit of writing mode, because this does // not affect the interpretation of logical coordinates. #define CHECK_WRITING_MODE(param) \ NS_ASSERTION(param.IgnoreSideways() == GetWritingMode().IgnoreSideways(), \ "writing-mode mismatch") namespace mozilla { namespace widget { struct IMENotification; } // namespace widget // Physical axis constants. enum PhysicalAxis { eAxisVertical = 0x0, eAxisHorizontal = 0x1 }; inline LogicalAxis GetOrthogonalAxis(LogicalAxis aAxis) { return aAxis == eLogicalAxisBlock ? eLogicalAxisInline : eLogicalAxisBlock; } inline bool IsInline(LogicalSide aSide) { return aSide & 0x2; } inline bool IsBlock(LogicalSide aSide) { return !IsInline(aSide); } inline bool IsEnd(LogicalSide aSide) { return aSide & 0x1; } inline bool IsStart(LogicalSide aSide) { return !IsEnd(aSide); } inline LogicalAxis GetAxis(LogicalSide aSide) { return IsInline(aSide) ? eLogicalAxisInline : eLogicalAxisBlock; } inline LogicalEdge GetEdge(LogicalSide aSide) { return IsEnd(aSide) ? eLogicalEdgeEnd : eLogicalEdgeStart; } inline LogicalEdge GetOppositeEdge(LogicalEdge aEdge) { // This relies on the only two LogicalEdge enum values being 0 and 1. return LogicalEdge(1 - aEdge); } inline LogicalSide MakeLogicalSide(LogicalAxis aAxis, LogicalEdge aEdge) { return LogicalSide((aAxis << 1) | aEdge); } inline LogicalSide GetOppositeSide(LogicalSide aSide) { return MakeLogicalSide(GetAxis(aSide), GetOppositeEdge(GetEdge(aSide))); } enum LogicalSideBits { eLogicalSideBitsNone = 0, eLogicalSideBitsBStart = 1 << eLogicalSideBStart, eLogicalSideBitsBEnd = 1 << eLogicalSideBEnd, eLogicalSideBitsIEnd = 1 << eLogicalSideIEnd, eLogicalSideBitsIStart = 1 << eLogicalSideIStart, eLogicalSideBitsBBoth = eLogicalSideBitsBStart | eLogicalSideBitsBEnd, eLogicalSideBitsIBoth = eLogicalSideBitsIStart | eLogicalSideBitsIEnd, eLogicalSideBitsAll = eLogicalSideBitsBBoth | eLogicalSideBitsIBoth }; enum LineRelativeDir { eLineRelativeDirOver = eLogicalSideBStart, eLineRelativeDirUnder = eLogicalSideBEnd, eLineRelativeDirLeft = eLogicalSideIStart, eLineRelativeDirRight = eLogicalSideIEnd }; /** * LogicalSides represents a set of logical sides. */ struct LogicalSides final { LogicalSides() : mBits(0) {} explicit LogicalSides(LogicalSideBits aSideBits) { MOZ_ASSERT((aSideBits & ~eLogicalSideBitsAll) == 0, "illegal side bits"); mBits = aSideBits; } bool IsEmpty() const { return mBits == 0; } bool BStart() const { return mBits & eLogicalSideBitsBStart; } bool BEnd() const { return mBits & eLogicalSideBitsBEnd; } bool IStart() const { return mBits & eLogicalSideBitsIStart; } bool IEnd() const { return mBits & eLogicalSideBitsIEnd; } bool Contains(LogicalSideBits aSideBits) const { MOZ_ASSERT((aSideBits & ~eLogicalSideBitsAll) == 0, "illegal side bits"); return (mBits & aSideBits) == aSideBits; } LogicalSides operator|(LogicalSides aOther) const { return LogicalSides(LogicalSideBits(mBits | aOther.mBits)); } LogicalSides operator|(LogicalSideBits aSideBits) const { return *this | LogicalSides(aSideBits); } LogicalSides& operator|=(LogicalSides aOther) { mBits |= aOther.mBits; return *this; } LogicalSides& operator|=(LogicalSideBits aSideBits) { return *this |= LogicalSides(aSideBits); } bool operator==(LogicalSides aOther) const { return mBits == aOther.mBits; } bool operator!=(LogicalSides aOther) const { return !(*this == aOther); } private: uint8_t mBits; }; /** * mozilla::WritingMode is an immutable class representing a * writing mode. * * It efficiently stores the writing mode and can rapidly compute * interesting things about it for use in layout. * * Writing modes are computed from the CSS 'direction', * 'writing-mode', and 'text-orientation' properties. * See CSS3 Writing Modes for more information * http://www.w3.org/TR/css3-writing-modes/ */ class WritingMode { public: /** * Absolute inline flow direction */ enum InlineDir { eInlineLTR = 0x00, // text flows horizontally left to right eInlineRTL = 0x02, // text flows horizontally right to left eInlineTTB = 0x01, // text flows vertically top to bottom eInlineBTT = 0x03, // text flows vertically bottom to top }; /** * Absolute block flow direction */ enum BlockDir { eBlockTB = 0x00, // horizontal lines stack top to bottom eBlockRL = 0x01, // vertical lines stack right to left eBlockLR = 0x05, // vertical lines stack left to right }; /** * Line-relative (bidi-relative) inline flow direction */ enum BidiDir { eBidiLTR = 0x00, // inline flow matches bidi LTR text eBidiRTL = 0x10, // inline flow matches bidi RTL text }; /** * Unknown writing mode (should never actually be stored or used anywhere). */ enum { eUnknownWritingMode = 0xff }; /** * Return the absolute inline flow direction as an InlineDir */ InlineDir GetInlineDir() const { return InlineDir(mWritingMode & eInlineMask); } /** * Return the absolute block flow direction as a BlockDir */ BlockDir GetBlockDir() const { return BlockDir(mWritingMode & eBlockMask); } /** * Return the line-relative inline flow direction as a BidiDir */ BidiDir GetBidiDir() const { return BidiDir(mWritingMode & eBidiMask); } /** * Return true if the inline flow direction is against physical direction * (i.e. right-to-left or bottom-to-top). * This occurs when writing-mode is sideways-lr OR direction is rtl (but not * if both of those are true). */ bool IsInlineReversed() const { return !!(mWritingMode & eInlineFlowMask); } /** * Return true if bidi direction is LTR. (Convenience method) */ bool IsBidiLTR() const { return eBidiLTR == GetBidiDir(); } /** * True if vertical-mode block direction is LR (convenience method). */ bool IsVerticalLR() const { return eBlockLR == GetBlockDir(); } /** * True if vertical-mode block direction is RL (convenience method). */ bool IsVerticalRL() const { return eBlockRL == GetBlockDir(); } /** * True if vertical writing mode, i.e. when * writing-mode: vertical-lr | vertical-rl. */ bool IsVertical() const { return !!(mWritingMode & eOrientationMask); } /** * True if line-over/line-under are inverted from block-start/block-end. * This is true only when writing-mode is vertical-lr. */ bool IsLineInverted() const { return !!(mWritingMode & eLineOrientMask); } /** * Block-axis flow-relative to line-relative factor. * May be used as a multiplication factor for block-axis coordinates * to convert between flow- and line-relative coordinate systems (e.g. * positioning an over- or under-line decoration). */ int FlowRelativeToLineRelativeFactor() const { return IsLineInverted() ? -1 : 1; } /** * True if the text-orientation will force all text to be rendered sideways * in vertical lines, in which case we should prefer an alphabetic baseline; * otherwise, the default is centered. * Note that some glyph runs may be rendered sideways even if this is false, * due to text-orientation:mixed resolution, but in that case the dominant * baseline remains centered. */ bool IsSideways() const { return !!(mWritingMode & eSidewaysMask); } #ifdef DEBUG // Used by CHECK_WRITING_MODE to compare modes without regard // for the eSidewaysMask flag. WritingMode IgnoreSideways() const { return WritingMode(mWritingMode & ~eSidewaysMask); } #endif /** * Return true if boxes with this writing mode should use central baselines. */ bool IsCentralBaseline() const { return IsVertical() && !IsSideways(); } /** * Return true if boxes with this writing mode should use alphabetical * baselines. */ bool IsAlphabeticalBaseline() const { return !IsCentralBaseline(); } static mozilla::PhysicalAxis PhysicalAxisForLogicalAxis( uint8_t aWritingModeValue, LogicalAxis aAxis) { // This relies on bit 0 of a writing-value mode indicating vertical // orientation and bit 0 of a LogicalAxis value indicating the inline axis, // so that it can correctly form mozilla::PhysicalAxis values using bit // manipulation. static_assert(NS_STYLE_WRITING_MODE_HORIZONTAL_TB == 0 && NS_STYLE_WRITING_MODE_VERTICAL_RL == 1 && NS_STYLE_WRITING_MODE_VERTICAL_LR == 3 && eLogicalAxisBlock == 0 && eLogicalAxisInline == 1 && eAxisVertical == 0 && eAxisHorizontal == 1, "unexpected writing-mode, logical axis or physical axis " "constant values"); return mozilla::PhysicalAxis((aWritingModeValue ^ aAxis) & 0x1); } mozilla::PhysicalAxis PhysicalAxis(LogicalAxis aAxis) const { // This will set wm to either NS_STYLE_WRITING_MODE_HORIZONTAL_TB or // NS_STYLE_WRITING_MODE_VERTICAL_RL, and not the other two (real // and hypothetical) values. But this is fine; we only need to // distinguish between vertical and horizontal in // PhysicalAxisForLogicalAxis. int wm = mWritingMode & eOrientationMask; return PhysicalAxisForLogicalAxis(wm, aAxis); } static mozilla::Side PhysicalSideForBlockAxis(uint8_t aWritingModeValue, LogicalEdge aEdge) { // indexes are NS_STYLE_WRITING_MODE_* values, which are the same as these // two-bit values: // bit 0 = the eOrientationMask value // bit 1 = the eBlockFlowMask value static const mozilla::css::Side kLogicalBlockSides[][2] = { { NS_SIDE_TOP, NS_SIDE_BOTTOM }, // horizontal-tb { NS_SIDE_RIGHT, NS_SIDE_LEFT }, // vertical-rl { NS_SIDE_BOTTOM, NS_SIDE_TOP }, // (horizontal-bt) { NS_SIDE_LEFT, NS_SIDE_RIGHT }, // vertical-lr }; // Ignore the SIDEWAYS_MASK bit of the writing-mode value, as this has no // effect on the side mappings. aWritingModeValue &= ~NS_STYLE_WRITING_MODE_SIDEWAYS_MASK; // What's left of the writing-mode should be in the range 0-3: NS_ASSERTION(aWritingModeValue < 4, "invalid aWritingModeValue value"); return kLogicalBlockSides[aWritingModeValue][aEdge]; } mozilla::Side PhysicalSideForInlineAxis(LogicalEdge aEdge) const { // indexes are four-bit values: // bit 0 = the eOrientationMask value // bit 1 = the eInlineFlowMask value // bit 2 = the eBlockFlowMask value // bit 3 = the eLineOrientMask value // Not all of these combinations can actually be specified via CSS: there // is no horizontal-bt writing-mode, and no text-orientation value that // produces "inverted" text. (The former 'sideways-left' value, no longer // in the spec, would have produced this in vertical-rl mode.) static const mozilla::css::Side kLogicalInlineSides[][2] = { { NS_SIDE_LEFT, NS_SIDE_RIGHT }, // horizontal-tb ltr { NS_SIDE_TOP, NS_SIDE_BOTTOM }, // vertical-rl ltr { NS_SIDE_RIGHT, NS_SIDE_LEFT }, // horizontal-tb rtl { NS_SIDE_BOTTOM, NS_SIDE_TOP }, // vertical-rl rtl { NS_SIDE_RIGHT, NS_SIDE_LEFT }, // (horizontal-bt) (inverted) ltr { NS_SIDE_TOP, NS_SIDE_BOTTOM }, // sideways-lr rtl { NS_SIDE_LEFT, NS_SIDE_RIGHT }, // (horizontal-bt) (inverted) rtl { NS_SIDE_BOTTOM, NS_SIDE_TOP }, // sideways-lr ltr { NS_SIDE_LEFT, NS_SIDE_RIGHT }, // horizontal-tb (inverted) rtl { NS_SIDE_TOP, NS_SIDE_BOTTOM }, // vertical-rl (inverted) rtl { NS_SIDE_RIGHT, NS_SIDE_LEFT }, // horizontal-tb (inverted) ltr { NS_SIDE_BOTTOM, NS_SIDE_TOP }, // vertical-rl (inverted) ltr { NS_SIDE_LEFT, NS_SIDE_RIGHT }, // (horizontal-bt) ltr { NS_SIDE_TOP, NS_SIDE_BOTTOM }, // vertical-lr ltr { NS_SIDE_RIGHT, NS_SIDE_LEFT }, // (horizontal-bt) rtl { NS_SIDE_BOTTOM, NS_SIDE_TOP }, // vertical-lr rtl }; // Inline axis sides depend on all three of writing-mode, text-orientation // and direction, which are encoded in the eOrientationMask, // eInlineFlowMask, eBlockFlowMask and eLineOrientMask bits. Use these four // bits to index into kLogicalInlineSides. static_assert(eOrientationMask == 0x01 && eInlineFlowMask == 0x02 && eBlockFlowMask == 0x04 && eLineOrientMask == 0x08, "unexpected mask values"); int index = mWritingMode & 0x0F; return kLogicalInlineSides[index][aEdge]; } /** * Returns the physical side corresponding to the specified logical side, * given the current writing mode. */ mozilla::Side PhysicalSide(LogicalSide aSide) const { if (IsBlock(aSide)) { static_assert(eOrientationMask == 0x01 && eBlockFlowMask == 0x04, "unexpected mask values"); int wm = ((mWritingMode & eBlockFlowMask) >> 1) | (mWritingMode & eOrientationMask); return PhysicalSideForBlockAxis(wm, GetEdge(aSide)); } return PhysicalSideForInlineAxis(GetEdge(aSide)); } /** * Returns the logical side corresponding to the specified physical side, * given the current writing mode. * (This is the inverse of the PhysicalSide() method above.) */ LogicalSide LogicalSideForPhysicalSide(mozilla::css::Side aSide) const { // indexes are four-bit values: // bit 0 = the eOrientationMask value // bit 1 = the eInlineFlowMask value // bit 2 = the eBlockFlowMask value // bit 3 = the eLineOrientMask value static const LogicalSide kPhysicalToLogicalSides[][4] = { // top right // bottom left { eLogicalSideBStart, eLogicalSideIEnd, eLogicalSideBEnd, eLogicalSideIStart }, // horizontal-tb ltr { eLogicalSideIStart, eLogicalSideBStart, eLogicalSideIEnd, eLogicalSideBEnd }, // vertical-rl ltr { eLogicalSideBStart, eLogicalSideIStart, eLogicalSideBEnd, eLogicalSideIEnd }, // horizontal-tb rtl { eLogicalSideIEnd, eLogicalSideBStart, eLogicalSideIStart, eLogicalSideBEnd }, // vertical-rl rtl { eLogicalSideBEnd, eLogicalSideIStart, eLogicalSideBStart, eLogicalSideIEnd }, // (horizontal-bt) (inv) ltr { eLogicalSideIStart, eLogicalSideBEnd, eLogicalSideIEnd, eLogicalSideBStart }, // vertical-lr sw-left rtl { eLogicalSideBEnd, eLogicalSideIEnd, eLogicalSideBStart, eLogicalSideIStart }, // (horizontal-bt) (inv) rtl { eLogicalSideIEnd, eLogicalSideBEnd, eLogicalSideIStart, eLogicalSideBStart }, // vertical-lr sw-left ltr { eLogicalSideBStart, eLogicalSideIEnd, eLogicalSideBEnd, eLogicalSideIStart }, // horizontal-tb (inv) rtl { eLogicalSideIStart, eLogicalSideBStart, eLogicalSideIEnd, eLogicalSideBEnd }, // vertical-rl sw-left rtl { eLogicalSideBStart, eLogicalSideIStart, eLogicalSideBEnd, eLogicalSideIEnd }, // horizontal-tb (inv) ltr { eLogicalSideIEnd, eLogicalSideBStart, eLogicalSideIStart, eLogicalSideBEnd }, // vertical-rl sw-left ltr { eLogicalSideBEnd, eLogicalSideIEnd, eLogicalSideBStart, eLogicalSideIStart }, // (horizontal-bt) ltr { eLogicalSideIStart, eLogicalSideBEnd, eLogicalSideIEnd, eLogicalSideBStart }, // vertical-lr ltr { eLogicalSideBEnd, eLogicalSideIStart, eLogicalSideBStart, eLogicalSideIEnd }, // (horizontal-bt) rtl { eLogicalSideIEnd, eLogicalSideBEnd, eLogicalSideIStart, eLogicalSideBStart }, // vertical-lr rtl }; static_assert(eOrientationMask == 0x01 && eInlineFlowMask == 0x02 && eBlockFlowMask == 0x04 && eLineOrientMask == 0x08, "unexpected mask values"); int index = mWritingMode & 0x0F; return kPhysicalToLogicalSides[index][aSide]; } /** * Returns the logical side corresponding to the specified * line-relative direction, given the current writing mode. */ LogicalSide LogicalSideForLineRelativeDir(LineRelativeDir aDir) const { auto side = static_cast(aDir); if (IsInline(side)) { return !IsInlineReversed() ? side : GetOppositeSide(side); } return !IsLineInverted() ? side : GetOppositeSide(side); } /** * Default constructor gives us a horizontal, LTR writing mode. * XXX We will probably eliminate this and require explicit initialization * in all cases once transition is complete. */ WritingMode() : mWritingMode(0) { } /** * Construct writing mode based on a style context */ explicit WritingMode(nsStyleContext* aStyleContext) { NS_ASSERTION(aStyleContext, "we need an nsStyleContext here"); InitFromStyleVisibility(aStyleContext->StyleVisibility()); } explicit WritingMode(const nsStyleVisibility* aStyleVisibility) { NS_ASSERTION(aStyleVisibility, "we need an nsStyleVisibility here"); InitFromStyleVisibility(aStyleVisibility); } private: void InitFromStyleVisibility(const nsStyleVisibility* aStyleVisibility) { switch (aStyleVisibility->mWritingMode) { case NS_STYLE_WRITING_MODE_HORIZONTAL_TB: mWritingMode = 0; break; case NS_STYLE_WRITING_MODE_VERTICAL_LR: { mWritingMode = eBlockFlowMask | eLineOrientMask | eOrientationMask; uint8_t textOrientation = aStyleVisibility->mTextOrientation; if (textOrientation == NS_STYLE_TEXT_ORIENTATION_SIDEWAYS) { mWritingMode |= eSidewaysMask; } break; } case NS_STYLE_WRITING_MODE_VERTICAL_RL: { mWritingMode = eOrientationMask; uint8_t textOrientation = aStyleVisibility->mTextOrientation; if (textOrientation == NS_STYLE_TEXT_ORIENTATION_SIDEWAYS) { mWritingMode |= eSidewaysMask; } break; } case NS_STYLE_WRITING_MODE_SIDEWAYS_LR: mWritingMode = eBlockFlowMask | eInlineFlowMask | eOrientationMask | eSidewaysMask; break; case NS_STYLE_WRITING_MODE_SIDEWAYS_RL: mWritingMode = eOrientationMask | eSidewaysMask; break; default: NS_NOTREACHED("unknown writing mode!"); mWritingMode = 0; break; } if (NS_STYLE_DIRECTION_RTL == aStyleVisibility->mDirection) { mWritingMode ^= eInlineFlowMask | eBidiMask; } } public: /** * This function performs fixup for elements with 'unicode-bidi: plaintext', * where inline directionality is derived from the Unicode bidi categories * of the element's content, and not the CSS 'direction' property. * * The WritingMode constructor will have already incorporated the 'direction' * property into our flag bits, so such elements need to use this method * (after resolving the bidi level of their content) to update the direction * bits as needed. * * If it turns out that our bidi direction already matches what plaintext * resolution determined, there's nothing to do here. If it didn't (i.e. if * the rtl-ness doesn't match), then we correct the direction by flipping the * same bits that get flipped in the constructor's CSS 'direction'-based * chunk. * * XXX change uint8_t to UBiDiLevel after bug 924851 */ void SetDirectionFromBidiLevel(uint8_t level) { if (IS_LEVEL_RTL(level) == IsBidiLTR()) { mWritingMode ^= eBidiMask | eInlineFlowMask; } } /** * Compare two WritingModes for equality. */ bool operator==(const WritingMode& aOther) const { return mWritingMode == aOther.mWritingMode; } bool operator!=(const WritingMode& aOther) const { return mWritingMode != aOther.mWritingMode; } /** * Check whether two modes are orthogonal to each other. */ bool IsOrthogonalTo(const WritingMode& aOther) const { return IsVertical() != aOther.IsVertical(); } /** * Returns true if this WritingMode's aLogicalAxis has the same physical * start side as the parallel axis of WritingMode |aOther|. * * @param aLogicalAxis The axis to compare from this WritingMode. * @param aOther The other WritingMode (from which we'll choose the axis * that's parallel to this WritingMode's aLogicalAxis, for * comparison). */ bool ParallelAxisStartsOnSameSide(LogicalAxis aLogicalAxis, const WritingMode& aOther) const { Side myStartSide = this->PhysicalSide(MakeLogicalSide(aLogicalAxis, eLogicalEdgeStart)); // Figure out which of aOther's axes is parallel to |this| WritingMode's // aLogicalAxis, and get its physical start side as well. LogicalAxis otherWMAxis = aOther.IsOrthogonalTo(*this) ? GetOrthogonalAxis(aLogicalAxis) : aLogicalAxis; Side otherWMStartSide = aOther.PhysicalSide(MakeLogicalSide(otherWMAxis, eLogicalEdgeStart)); NS_ASSERTION(myStartSide % 2 == otherWMStartSide % 2, "Should end up with sides in the same physical axis"); return myStartSide == otherWMStartSide; } uint8_t GetBits() const { return mWritingMode; } const char* DebugString() const { return IsVertical() ? IsVerticalLR() ? IsBidiLTR() ? IsSideways() ? "sw-lr-ltr" : "v-lr-ltr" : IsSideways() ? "sw-lr-rtl" : "v-lr-rtl" : IsBidiLTR() ? IsSideways() ? "sw-rl-ltr" : "v-rl-ltr" : IsSideways() ? "sw-rl-rtl" : "v-rl-rtl" : IsBidiLTR() ? "h-ltr" : "h-rtl" ; } private: friend class LogicalPoint; friend class LogicalSize; friend class LogicalMargin; friend class LogicalRect; friend struct IPC::ParamTraits; // IMENotification cannot store this class directly since this has some // constructors. Therefore, it stores mWritingMode and recreate the // instance from it. friend struct widget::IMENotification; /** * Return a WritingMode representing an unknown value. */ static inline WritingMode Unknown() { return WritingMode(eUnknownWritingMode); } /** * Constructing a WritingMode with an arbitrary value is a private operation * currently only used by the Unknown() static method. */ explicit WritingMode(uint8_t aValue) : mWritingMode(aValue) { } uint8_t mWritingMode; enum Masks { // Masks for our bits; true chosen as opposite of commonest case eOrientationMask = 0x01, // true means vertical text eInlineFlowMask = 0x02, // true means absolute RTL/BTT (against physical coords) eBlockFlowMask = 0x04, // true means vertical-LR (or horizontal-BT if added) eLineOrientMask = 0x08, // true means over != block-start eBidiMask = 0x10, // true means line-relative RTL (bidi RTL) // Note: We have one excess bit of info; WritingMode can pack into 4 bits. // But since we have space, we're caching interesting things for fast access. eSidewaysMask = 0x20, // true means text is being rendered vertically // using rotated glyphs (i.e. writing-mode is // sideways-*, or writing-mode is vertical-* AND // text-orientation is sideways), // which means we'll use alphabetic instead of // centered default baseline for vertical text // Masks for output enums eInlineMask = 0x03, eBlockMask = 0x05 }; }; /** * Logical-coordinate classes: * * There are three sets of coordinate space: * - physical (top, left, bottom, right) * relative to graphics coord system * - flow-relative (block-start, inline-start, block-end, inline-end) * relative to block/inline flow directions * - line-relative (line-over, line-left, line-under, line-right) * relative to glyph orientation / inline bidi directions * See CSS3 Writing Modes for more information * http://www.w3.org/TR/css3-writing-modes/#abstract-box * * For shorthand, B represents the block-axis * I represents the inline-axis * * The flow-relative geometric classes store coords in flow-relative space. * They use a private ns{Point,Size,Rect,Margin} member to store the actual * coordinate values, but reinterpret them as logical instead of physical. * This allows us to easily perform calculations in logical space (provided * writing modes of the operands match), by simply mapping to nsPoint (etc) * methods. * * Physical-coordinate accessors/setters are responsible to translate these * internal logical values as necessary. * * In DEBUG builds, the logical types store their WritingMode and check * that the same WritingMode is passed whenever callers ask them to do a * writing-mode-dependent operation. Non-DEBUG builds do NOT check this, * to avoid the overhead of storing WritingMode fields. * * Open question: do we need a different set optimized for line-relative * math, for use in nsLineLayout and the like? Or is multiplying values * by FlowRelativeToLineRelativeFactor() enough? */ /** * Flow-relative point */ class LogicalPoint { public: explicit LogicalPoint(WritingMode aWritingMode) : #ifdef DEBUG mWritingMode(aWritingMode), #endif mPoint(0, 0) { } // Construct from a writing mode and individual coordinates (which MUST be // values in that writing mode, NOT physical coordinates!) LogicalPoint(WritingMode aWritingMode, nscoord aI, nscoord aB) : #ifdef DEBUG mWritingMode(aWritingMode), #endif mPoint(aI, aB) { } // Construct from a writing mode and a physical point, within a given // containing rectangle's size (defining the conversion between LTR // and RTL coordinates, and between TTB and BTT coordinates). LogicalPoint(WritingMode aWritingMode, const nsPoint& aPoint, const nsSize& aContainerSize) #ifdef DEBUG : mWritingMode(aWritingMode) #endif { if (aWritingMode.IsVertical()) { I() = aWritingMode.IsInlineReversed() ? aContainerSize.height - aPoint.y : aPoint.y; B() = aWritingMode.IsVerticalLR() ? aPoint.x : aContainerSize.width - aPoint.x; } else { I() = aWritingMode.IsInlineReversed() ? aContainerSize.width - aPoint.x : aPoint.x; B() = aPoint.y; } } /** * Read-only (const) access to the logical coordinates. */ nscoord I(WritingMode aWritingMode) const // inline-axis { CHECK_WRITING_MODE(aWritingMode); return mPoint.x; } nscoord B(WritingMode aWritingMode) const // block-axis { CHECK_WRITING_MODE(aWritingMode); return mPoint.y; } /** * These non-const accessors return a reference (lvalue) that can be * assigned to by callers. */ nscoord& I(WritingMode aWritingMode) // inline-axis { CHECK_WRITING_MODE(aWritingMode); return mPoint.x; } nscoord& B(WritingMode aWritingMode) // block-axis { CHECK_WRITING_MODE(aWritingMode); return mPoint.y; } /** * Return a physical point corresponding to our logical coordinates, * converted according to our writing mode. */ nsPoint GetPhysicalPoint(WritingMode aWritingMode, const nsSize& aContainerSize) const { CHECK_WRITING_MODE(aWritingMode); if (aWritingMode.IsVertical()) { return nsPoint(aWritingMode.IsVerticalLR() ? B() : aContainerSize.width - B(), aWritingMode.IsInlineReversed() ? aContainerSize.height - I() : I()); } else { return nsPoint(aWritingMode.IsInlineReversed() ? aContainerSize.width - I() : I(), B()); } } /** * Return the equivalent point in a different writing mode. */ LogicalPoint ConvertTo(WritingMode aToMode, WritingMode aFromMode, const nsSize& aContainerSize) const { CHECK_WRITING_MODE(aFromMode); return aToMode == aFromMode ? *this : LogicalPoint(aToMode, GetPhysicalPoint(aFromMode, aContainerSize), aContainerSize); } bool operator==(const LogicalPoint& aOther) const { CHECK_WRITING_MODE(aOther.GetWritingMode()); return mPoint == aOther.mPoint; } bool operator!=(const LogicalPoint& aOther) const { CHECK_WRITING_MODE(aOther.GetWritingMode()); return mPoint != aOther.mPoint; } LogicalPoint operator+(const LogicalPoint& aOther) const { CHECK_WRITING_MODE(aOther.GetWritingMode()); // In non-debug builds, LogicalPoint does not store the WritingMode, // so the first parameter here (which will always be eUnknownWritingMode) // is ignored. return LogicalPoint(GetWritingMode(), mPoint.x + aOther.mPoint.x, mPoint.y + aOther.mPoint.y); } LogicalPoint& operator+=(const LogicalPoint& aOther) { CHECK_WRITING_MODE(aOther.GetWritingMode()); I() += aOther.I(); B() += aOther.B(); return *this; } LogicalPoint operator-(const LogicalPoint& aOther) const { CHECK_WRITING_MODE(aOther.GetWritingMode()); // In non-debug builds, LogicalPoint does not store the WritingMode, // so the first parameter here (which will always be eUnknownWritingMode) // is ignored. return LogicalPoint(GetWritingMode(), mPoint.x - aOther.mPoint.x, mPoint.y - aOther.mPoint.y); } LogicalPoint& operator-=(const LogicalPoint& aOther) { CHECK_WRITING_MODE(aOther.GetWritingMode()); I() -= aOther.I(); B() -= aOther.B(); return *this; } private: friend class LogicalRect; /** * NOTE that in non-DEBUG builds, GetWritingMode() always returns * eUnknownWritingMode, as the current mode is not stored in the logical- * geometry classes. Therefore, this method is private; it is used ONLY * by the DEBUG-mode checking macros in this class and its friends; * other code is not allowed to ask a logical point for its writing mode, * as this info will simply not be available in non-DEBUG builds. * * Also, in non-DEBUG builds, CHECK_WRITING_MODE does nothing, and the * WritingMode parameter to logical methods will generally be optimized * away altogether. */ #ifdef DEBUG WritingMode GetWritingMode() const { return mWritingMode; } #else WritingMode GetWritingMode() const { return WritingMode::Unknown(); } #endif // We don't allow construction of a LogicalPoint with no writing mode. LogicalPoint() = delete; // Accessors that don't take or check a WritingMode value. // These are for internal use only; they are called by methods that have // themselves already checked the WritingMode passed by the caller. nscoord I() const // inline-axis { return mPoint.x; } nscoord B() const // block-axis { return mPoint.y; } nscoord& I() // inline-axis { return mPoint.x; } nscoord& B() // block-axis { return mPoint.y; } #ifdef DEBUG WritingMode mWritingMode; #endif // We use an nsPoint to hold the coordinates, but reinterpret its .x and .y // fields as the inline and block directions. Hence, this is not exposed // directly, but only through accessors that will map them according to the // writing mode. nsPoint mPoint; }; /** * Flow-relative size */ class LogicalSize { public: explicit LogicalSize(WritingMode aWritingMode) : #ifdef DEBUG mWritingMode(aWritingMode), #endif mSize(0, 0) { } LogicalSize(WritingMode aWritingMode, nscoord aISize, nscoord aBSize) : #ifdef DEBUG mWritingMode(aWritingMode), #endif mSize(aISize, aBSize) { } LogicalSize(WritingMode aWritingMode, const nsSize& aPhysicalSize) #ifdef DEBUG : mWritingMode(aWritingMode) #endif { if (aWritingMode.IsVertical()) { ISize() = aPhysicalSize.height; BSize() = aPhysicalSize.width; } else { ISize() = aPhysicalSize.width; BSize() = aPhysicalSize.height; } } void SizeTo(WritingMode aWritingMode, nscoord aISize, nscoord aBSize) { CHECK_WRITING_MODE(aWritingMode); mSize.SizeTo(aISize, aBSize); } /** * Dimensions in logical and physical terms */ nscoord ISize(WritingMode aWritingMode) const // inline-size { CHECK_WRITING_MODE(aWritingMode); return mSize.width; } nscoord BSize(WritingMode aWritingMode) const // block-size { CHECK_WRITING_MODE(aWritingMode); return mSize.height; } nscoord Width(WritingMode aWritingMode) const { CHECK_WRITING_MODE(aWritingMode); return aWritingMode.IsVertical() ? BSize() : ISize(); } nscoord Height(WritingMode aWritingMode) const { CHECK_WRITING_MODE(aWritingMode); return aWritingMode.IsVertical() ? ISize() : BSize(); } /** * Writable references to the logical dimensions */ nscoord& ISize(WritingMode aWritingMode) // inline-size { CHECK_WRITING_MODE(aWritingMode); return mSize.width; } nscoord& BSize(WritingMode aWritingMode) // block-size { CHECK_WRITING_MODE(aWritingMode); return mSize.height; } /** * Return an nsSize containing our physical dimensions */ nsSize GetPhysicalSize(WritingMode aWritingMode) const { CHECK_WRITING_MODE(aWritingMode); return aWritingMode.IsVertical() ? nsSize(BSize(), ISize()) : nsSize(ISize(), BSize()); } /** * Return a LogicalSize representing this size in a different writing mode */ LogicalSize ConvertTo(WritingMode aToMode, WritingMode aFromMode) const { #ifdef DEBUG // In DEBUG builds make sure to return a LogicalSize with the // expected writing mode CHECK_WRITING_MODE(aFromMode); return aToMode == aFromMode ? *this : LogicalSize(aToMode, GetPhysicalSize(aFromMode)); #else // optimization for non-DEBUG builds where LogicalSize doesn't store // the writing mode return (aToMode == aFromMode || !aToMode.IsOrthogonalTo(aFromMode)) ? *this : LogicalSize(aToMode, BSize(), ISize()); #endif } /** * Test if a size is (0, 0). */ bool IsAllZero() const { return ISize() == 0 && BSize() == 0; } /** * Various binary operators on LogicalSize. These are valid ONLY for operands * that share the same writing mode. */ bool operator==(const LogicalSize& aOther) const { CHECK_WRITING_MODE(aOther.GetWritingMode()); return mSize == aOther.mSize; } bool operator!=(const LogicalSize& aOther) const { CHECK_WRITING_MODE(aOther.GetWritingMode()); return mSize != aOther.mSize; } LogicalSize operator+(const LogicalSize& aOther) const { CHECK_WRITING_MODE(aOther.GetWritingMode()); return LogicalSize(GetWritingMode(), ISize() + aOther.ISize(), BSize() + aOther.BSize()); } LogicalSize& operator+=(const LogicalSize& aOther) { CHECK_WRITING_MODE(aOther.GetWritingMode()); ISize() += aOther.ISize(); BSize() += aOther.BSize(); return *this; } LogicalSize operator-(const LogicalSize& aOther) const { CHECK_WRITING_MODE(aOther.GetWritingMode()); return LogicalSize(GetWritingMode(), ISize() - aOther.ISize(), BSize() - aOther.BSize()); } LogicalSize& operator-=(const LogicalSize& aOther) { CHECK_WRITING_MODE(aOther.GetWritingMode()); ISize() -= aOther.ISize(); BSize() -= aOther.BSize(); return *this; } private: friend class LogicalRect; LogicalSize() = delete; #ifdef DEBUG WritingMode GetWritingMode() const { return mWritingMode; } #else WritingMode GetWritingMode() const { return WritingMode::Unknown(); } #endif nscoord ISize() const // inline-size { return mSize.width; } nscoord BSize() const // block-size { return mSize.height; } nscoord& ISize() // inline-size { return mSize.width; } nscoord& BSize() // block-size { return mSize.height; } #ifdef DEBUG WritingMode mWritingMode; #endif nsSize mSize; }; /** * Flow-relative margin */ class LogicalMargin { public: explicit LogicalMargin(WritingMode aWritingMode) : #ifdef DEBUG mWritingMode(aWritingMode), #endif mMargin(0, 0, 0, 0) { } LogicalMargin(WritingMode aWritingMode, nscoord aBStart, nscoord aIEnd, nscoord aBEnd, nscoord aIStart) : #ifdef DEBUG mWritingMode(aWritingMode), #endif mMargin(aBStart, aIEnd, aBEnd, aIStart) { } LogicalMargin(WritingMode aWritingMode, const nsMargin& aPhysicalMargin) #ifdef DEBUG : mWritingMode(aWritingMode) #endif { if (aWritingMode.IsVertical()) { if (aWritingMode.IsVerticalLR()) { mMargin.top = aPhysicalMargin.left; mMargin.bottom = aPhysicalMargin.right; } else { mMargin.top = aPhysicalMargin.right; mMargin.bottom = aPhysicalMargin.left; } if (aWritingMode.IsInlineReversed()) { mMargin.left = aPhysicalMargin.bottom; mMargin.right = aPhysicalMargin.top; } else { mMargin.left = aPhysicalMargin.top; mMargin.right = aPhysicalMargin.bottom; } } else { mMargin.top = aPhysicalMargin.top; mMargin.bottom = aPhysicalMargin.bottom; if (aWritingMode.IsInlineReversed()) { mMargin.left = aPhysicalMargin.right; mMargin.right = aPhysicalMargin.left; } else { mMargin.left = aPhysicalMargin.left; mMargin.right = aPhysicalMargin.right; } } } nscoord IStart(WritingMode aWritingMode) const // inline-start margin { CHECK_WRITING_MODE(aWritingMode); return mMargin.left; } nscoord IEnd(WritingMode aWritingMode) const // inline-end margin { CHECK_WRITING_MODE(aWritingMode); return mMargin.right; } nscoord BStart(WritingMode aWritingMode) const // block-start margin { CHECK_WRITING_MODE(aWritingMode); return mMargin.top; } nscoord BEnd(WritingMode aWritingMode) const // block-end margin { CHECK_WRITING_MODE(aWritingMode); return mMargin.bottom; } nscoord& IStart(WritingMode aWritingMode) // inline-start margin { CHECK_WRITING_MODE(aWritingMode); return mMargin.left; } nscoord& IEnd(WritingMode aWritingMode) // inline-end margin { CHECK_WRITING_MODE(aWritingMode); return mMargin.right; } nscoord& BStart(WritingMode aWritingMode) // block-start margin { CHECK_WRITING_MODE(aWritingMode); return mMargin.top; } nscoord& BEnd(WritingMode aWritingMode) // block-end margin { CHECK_WRITING_MODE(aWritingMode); return mMargin.bottom; } nscoord IStartEnd(WritingMode aWritingMode) const // inline margins { CHECK_WRITING_MODE(aWritingMode); return mMargin.LeftRight(); } nscoord BStartEnd(WritingMode aWritingMode) const // block margins { CHECK_WRITING_MODE(aWritingMode); return mMargin.TopBottom(); } /* * Return margin values for line-relative sides, as defined in * http://www.w3.org/TR/css-writing-modes-3/#line-directions: * * line-left * Nominally the side from which LTR text would start. * line-right * Nominally the side from which RTL text would start. (Opposite of * line-left.) */ nscoord LineLeft(WritingMode aWritingMode) const { // We don't need to CHECK_WRITING_MODE here because the IStart or IEnd // accessor that we call will do it. return aWritingMode.IsBidiLTR() ? IStart(aWritingMode) : IEnd(aWritingMode); } nscoord LineRight(WritingMode aWritingMode) const { return aWritingMode.IsBidiLTR() ? IEnd(aWritingMode) : IStart(aWritingMode); } /** * Return a LogicalSize representing the total size of the inline- * and block-dimension margins. */ LogicalSize Size(WritingMode aWritingMode) const { CHECK_WRITING_MODE(aWritingMode); return LogicalSize(aWritingMode, IStartEnd(), BStartEnd()); } /** * Accessors for physical margins, using our writing mode to convert from * logical values. */ nscoord Top(WritingMode aWritingMode) const { CHECK_WRITING_MODE(aWritingMode); return aWritingMode.IsVertical() ? (aWritingMode.IsInlineReversed() ? IEnd() : IStart()) : BStart(); } nscoord Bottom(WritingMode aWritingMode) const { CHECK_WRITING_MODE(aWritingMode); return aWritingMode.IsVertical() ? (aWritingMode.IsInlineReversed() ? IStart() : IEnd()) : BEnd(); } nscoord Left(WritingMode aWritingMode) const { CHECK_WRITING_MODE(aWritingMode); return aWritingMode.IsVertical() ? (aWritingMode.IsVerticalLR() ? BStart() : BEnd()) : (aWritingMode.IsInlineReversed() ? IEnd() : IStart()); } nscoord Right(WritingMode aWritingMode) const { CHECK_WRITING_MODE(aWritingMode); return aWritingMode.IsVertical() ? (aWritingMode.IsVerticalLR() ? BEnd() : BStart()) : (aWritingMode.IsInlineReversed() ? IStart() : IEnd()); } nscoord LeftRight(WritingMode aWritingMode) const { CHECK_WRITING_MODE(aWritingMode); return aWritingMode.IsVertical() ? BStartEnd() : IStartEnd(); } nscoord TopBottom(WritingMode aWritingMode) const { CHECK_WRITING_MODE(aWritingMode); return aWritingMode.IsVertical() ? IStartEnd() : BStartEnd(); } void SizeTo(WritingMode aWritingMode, nscoord aBStart, nscoord aIEnd, nscoord aBEnd, nscoord aIStart) { CHECK_WRITING_MODE(aWritingMode); mMargin.SizeTo(aBStart, aIEnd, aBEnd, aIStart); } /** * Return an nsMargin containing our physical coordinates */ nsMargin GetPhysicalMargin(WritingMode aWritingMode) const { CHECK_WRITING_MODE(aWritingMode); return aWritingMode.IsVertical() ? (aWritingMode.IsVerticalLR() ? (aWritingMode.IsInlineReversed() ? nsMargin(IEnd(), BEnd(), IStart(), BStart()) : nsMargin(IStart(), BEnd(), IEnd(), BStart())) : (aWritingMode.IsInlineReversed() ? nsMargin(IEnd(), BStart(), IStart(), BEnd()) : nsMargin(IStart(), BStart(), IEnd(), BEnd()))) : (aWritingMode.IsInlineReversed() ? nsMargin(BStart(), IStart(), BEnd(), IEnd()) : nsMargin(BStart(), IEnd(), BEnd(), IStart())); } /** * Return a LogicalMargin representing this margin in a different * writing mode */ LogicalMargin ConvertTo(WritingMode aToMode, WritingMode aFromMode) const { CHECK_WRITING_MODE(aFromMode); return aToMode == aFromMode ? *this : LogicalMargin(aToMode, GetPhysicalMargin(aFromMode)); } void ApplySkipSides(LogicalSides aSkipSides) { if (aSkipSides.BStart()) { BStart() = 0; } if (aSkipSides.BEnd()) { BEnd() = 0; } if (aSkipSides.IStart()) { IStart() = 0; } if (aSkipSides.IEnd()) { IEnd() = 0; } } bool IsAllZero() const { return (mMargin.left == 0 && mMargin.top == 0 && mMargin.right == 0 && mMargin.bottom == 0); } LogicalMargin operator+(const LogicalMargin& aMargin) const { CHECK_WRITING_MODE(aMargin.GetWritingMode()); return LogicalMargin(GetWritingMode(), BStart() + aMargin.BStart(), IEnd() + aMargin.IEnd(), BEnd() + aMargin.BEnd(), IStart() + aMargin.IStart()); } LogicalMargin operator+=(const LogicalMargin& aMargin) { CHECK_WRITING_MODE(aMargin.GetWritingMode()); mMargin += aMargin.mMargin; return *this; } LogicalMargin operator-(const LogicalMargin& aMargin) const { CHECK_WRITING_MODE(aMargin.GetWritingMode()); return LogicalMargin(GetWritingMode(), BStart() - aMargin.BStart(), IEnd() - aMargin.IEnd(), BEnd() - aMargin.BEnd(), IStart() - aMargin.IStart()); } private: friend class LogicalRect; LogicalMargin() = delete; #ifdef DEBUG WritingMode GetWritingMode() const { return mWritingMode; } #else WritingMode GetWritingMode() const { return WritingMode::Unknown(); } #endif nscoord IStart() const // inline-start margin { return mMargin.left; } nscoord IEnd() const // inline-end margin { return mMargin.right; } nscoord BStart() const // block-start margin { return mMargin.top; } nscoord BEnd() const // block-end margin { return mMargin.bottom; } nscoord& IStart() // inline-start margin { return mMargin.left; } nscoord& IEnd() // inline-end margin { return mMargin.right; } nscoord& BStart() // block-start margin { return mMargin.top; } nscoord& BEnd() // block-end margin { return mMargin.bottom; } nscoord IStartEnd() const // inline margins { return mMargin.LeftRight(); } nscoord BStartEnd() const // block margins { return mMargin.TopBottom(); } #ifdef DEBUG WritingMode mWritingMode; #endif nsMargin mMargin; }; /** * Flow-relative rectangle */ class LogicalRect { public: explicit LogicalRect(WritingMode aWritingMode) : #ifdef DEBUG mWritingMode(aWritingMode), #endif mRect(0, 0, 0, 0) { } LogicalRect(WritingMode aWritingMode, nscoord aIStart, nscoord aBStart, nscoord aISize, nscoord aBSize) : #ifdef DEBUG mWritingMode(aWritingMode), #endif mRect(aIStart, aBStart, aISize, aBSize) { } LogicalRect(WritingMode aWritingMode, const LogicalPoint& aOrigin, const LogicalSize& aSize) : #ifdef DEBUG mWritingMode(aWritingMode), #endif mRect(aOrigin.mPoint, aSize.mSize) { CHECK_WRITING_MODE(aOrigin.GetWritingMode()); CHECK_WRITING_MODE(aSize.GetWritingMode()); } LogicalRect(WritingMode aWritingMode, const nsRect& aRect, const nsSize& aContainerSize) #ifdef DEBUG : mWritingMode(aWritingMode) #endif { if (aWritingMode.IsVertical()) { mRect.y = aWritingMode.IsVerticalLR() ? aRect.x : aContainerSize.width - aRect.XMost(); mRect.x = aWritingMode.IsInlineReversed() ? aContainerSize.height - aRect.YMost() : aRect.y; mRect.height = aRect.width; mRect.width = aRect.height; } else { mRect.x = aWritingMode.IsInlineReversed() ? aContainerSize.width - aRect.XMost() : aRect.x; mRect.y = aRect.y; mRect.width = aRect.width; mRect.height = aRect.height; } } /** * Inline- and block-dimension geometry. */ nscoord IStart(WritingMode aWritingMode) const // inline-start edge { CHECK_WRITING_MODE(aWritingMode); return mRect.X(); } nscoord IEnd(WritingMode aWritingMode) const // inline-end edge { CHECK_WRITING_MODE(aWritingMode); return mRect.XMost(); } nscoord ISize(WritingMode aWritingMode) const // inline-size { CHECK_WRITING_MODE(aWritingMode); return mRect.Width(); } nscoord BStart(WritingMode aWritingMode) const // block-start edge { CHECK_WRITING_MODE(aWritingMode); return mRect.Y(); } nscoord BEnd(WritingMode aWritingMode) const // block-end edge { CHECK_WRITING_MODE(aWritingMode); return mRect.YMost(); } nscoord BSize(WritingMode aWritingMode) const // block-size { CHECK_WRITING_MODE(aWritingMode); return mRect.Height(); } /** * Writable (reference) accessors are only available for the basic logical * fields (Start and Size), not derivatives like End. */ nscoord& IStart(WritingMode aWritingMode) // inline-start edge { CHECK_WRITING_MODE(aWritingMode); return mRect.x; } nscoord& ISize(WritingMode aWritingMode) // inline-size { CHECK_WRITING_MODE(aWritingMode); return mRect.width; } nscoord& BStart(WritingMode aWritingMode) // block-start edge { CHECK_WRITING_MODE(aWritingMode); return mRect.y; } nscoord& BSize(WritingMode aWritingMode) // block-size { CHECK_WRITING_MODE(aWritingMode); return mRect.height; } /** * Accessors for line-relative coordinates */ nscoord LineLeft(WritingMode aWritingMode, const nsSize& aContainerSize) const { CHECK_WRITING_MODE(aWritingMode); if (aWritingMode.IsBidiLTR()) { return IStart(); } nscoord containerISize = aWritingMode.IsVertical() ? aContainerSize.height : aContainerSize.width; return containerISize - IEnd(); } nscoord LineRight(WritingMode aWritingMode, const nsSize& aContainerSize) const { CHECK_WRITING_MODE(aWritingMode); if (aWritingMode.IsBidiLTR()) { return IEnd(); } nscoord containerISize = aWritingMode.IsVertical() ? aContainerSize.height : aContainerSize.width; return containerISize - IStart(); } /** * Physical coordinates of the rect. */ nscoord X(WritingMode aWritingMode, nscoord aContainerWidth) const { CHECK_WRITING_MODE(aWritingMode); if (aWritingMode.IsVertical()) { return aWritingMode.IsVerticalLR() ? mRect.Y() : aContainerWidth - mRect.YMost(); } else { return aWritingMode.IsInlineReversed() ? aContainerWidth - mRect.XMost() : mRect.X(); } } nscoord Y(WritingMode aWritingMode, nscoord aContainerHeight) const { CHECK_WRITING_MODE(aWritingMode); if (aWritingMode.IsVertical()) { return aWritingMode.IsInlineReversed() ? aContainerHeight - mRect.XMost() : mRect.X(); } else { return mRect.Y(); } } nscoord Width(WritingMode aWritingMode) const { CHECK_WRITING_MODE(aWritingMode); return aWritingMode.IsVertical() ? mRect.Height() : mRect.Width(); } nscoord Height(WritingMode aWritingMode) const { CHECK_WRITING_MODE(aWritingMode); return aWritingMode.IsVertical() ? mRect.Width() : mRect.Height(); } nscoord XMost(WritingMode aWritingMode, nscoord aContainerWidth) const { CHECK_WRITING_MODE(aWritingMode); if (aWritingMode.IsVertical()) { return aWritingMode.IsVerticalLR() ? mRect.YMost() : aContainerWidth - mRect.Y(); } else { return aWritingMode.IsInlineReversed() ? aContainerWidth - mRect.X() : mRect.XMost(); } } nscoord YMost(WritingMode aWritingMode, nscoord aContainerHeight) const { CHECK_WRITING_MODE(aWritingMode); if (aWritingMode.IsVertical()) { return aWritingMode.IsInlineReversed() ? aContainerHeight - mRect.x : mRect.XMost(); } else { return mRect.YMost(); } } bool IsEmpty() const { return mRect.IsEmpty(); } bool IsAllZero() const { return (mRect.x == 0 && mRect.y == 0 && mRect.width == 0 && mRect.height == 0); } bool IsZeroSize() const { return (mRect.width == 0 && mRect.height == 0); } void SetEmpty() { mRect.SetEmpty(); } bool IsEqualEdges(const LogicalRect aOther) const { CHECK_WRITING_MODE(aOther.GetWritingMode()); return mRect.IsEqualEdges(aOther.mRect); } LogicalPoint Origin(WritingMode aWritingMode) const { CHECK_WRITING_MODE(aWritingMode); return LogicalPoint(aWritingMode, IStart(), BStart()); } void SetOrigin(WritingMode aWritingMode, const LogicalPoint& aPoint) { IStart(aWritingMode) = aPoint.I(aWritingMode); BStart(aWritingMode) = aPoint.B(aWritingMode); } LogicalSize Size(WritingMode aWritingMode) const { CHECK_WRITING_MODE(aWritingMode); return LogicalSize(aWritingMode, ISize(), BSize()); } LogicalRect operator+(const LogicalPoint& aPoint) const { CHECK_WRITING_MODE(aPoint.GetWritingMode()); return LogicalRect(GetWritingMode(), IStart() + aPoint.I(), BStart() + aPoint.B(), ISize(), BSize()); } LogicalRect& operator+=(const LogicalPoint& aPoint) { CHECK_WRITING_MODE(aPoint.GetWritingMode()); mRect += aPoint.mPoint; return *this; } LogicalRect operator-(const LogicalPoint& aPoint) const { CHECK_WRITING_MODE(aPoint.GetWritingMode()); return LogicalRect(GetWritingMode(), IStart() - aPoint.I(), BStart() - aPoint.B(), ISize(), BSize()); } LogicalRect& operator-=(const LogicalPoint& aPoint) { CHECK_WRITING_MODE(aPoint.GetWritingMode()); mRect -= aPoint.mPoint; return *this; } void MoveBy(WritingMode aWritingMode, const LogicalPoint& aDelta) { CHECK_WRITING_MODE(aWritingMode); CHECK_WRITING_MODE(aDelta.GetWritingMode()); IStart() += aDelta.I(); BStart() += aDelta.B(); } void Inflate(nscoord aD) { mRect.Inflate(aD); } void Inflate(nscoord aDI, nscoord aDB) { mRect.Inflate(aDI, aDB); } void Inflate(WritingMode aWritingMode, const LogicalMargin& aMargin) { CHECK_WRITING_MODE(aWritingMode); CHECK_WRITING_MODE(aMargin.GetWritingMode()); mRect.Inflate(aMargin.mMargin); } void Deflate(nscoord aD) { mRect.Deflate(aD); } void Deflate(nscoord aDI, nscoord aDB) { mRect.Deflate(aDI, aDB); } void Deflate(WritingMode aWritingMode, const LogicalMargin& aMargin) { CHECK_WRITING_MODE(aWritingMode); CHECK_WRITING_MODE(aMargin.GetWritingMode()); mRect.Deflate(aMargin.mMargin); } /** * Return an nsRect containing our physical coordinates within the given * container size. */ nsRect GetPhysicalRect(WritingMode aWritingMode, const nsSize& aContainerSize) const { CHECK_WRITING_MODE(aWritingMode); if (aWritingMode.IsVertical()) { return nsRect(aWritingMode.IsVerticalLR() ? BStart() : aContainerSize.width - BEnd(), aWritingMode.IsInlineReversed() ? aContainerSize.height - IEnd() : IStart(), BSize(), ISize()); } else { return nsRect(aWritingMode.IsInlineReversed() ? aContainerSize.width - IEnd() : IStart(), BStart(), ISize(), BSize()); } } /** * Return a LogicalRect representing this rect in a different writing mode */ LogicalRect ConvertTo(WritingMode aToMode, WritingMode aFromMode, const nsSize& aContainerSize) const { CHECK_WRITING_MODE(aFromMode); return aToMode == aFromMode ? *this : LogicalRect(aToMode, GetPhysicalRect(aFromMode, aContainerSize), aContainerSize); } /** * Set *this to be the rectangle containing the intersection of aRect1 * and aRect2, return whether the intersection is non-empty. */ bool IntersectRect(const LogicalRect& aRect1, const LogicalRect& aRect2) { CHECK_WRITING_MODE(aRect1.mWritingMode); CHECK_WRITING_MODE(aRect2.mWritingMode); return mRect.IntersectRect(aRect1.mRect, aRect2.mRect); } private: LogicalRect() = delete; #ifdef DEBUG WritingMode GetWritingMode() const { return mWritingMode; } #else WritingMode GetWritingMode() const { return WritingMode::Unknown(); } #endif nscoord IStart() const // inline-start edge { return mRect.X(); } nscoord IEnd() const // inline-end edge { return mRect.XMost(); } nscoord ISize() const // inline-size { return mRect.Width(); } nscoord BStart() const // block-start edge { return mRect.Y(); } nscoord BEnd() const // block-end edge { return mRect.YMost(); } nscoord BSize() const // block-size { return mRect.Height(); } nscoord& IStart() // inline-start edge { return mRect.x; } nscoord& ISize() // inline-size { return mRect.width; } nscoord& BStart() // block-start edge { return mRect.y; } nscoord& BSize() // block-size { return mRect.height; } #ifdef DEBUG WritingMode mWritingMode; #endif nsRect mRect; }; } // namespace mozilla // Definitions of inline methods for nsStyleSides, declared in nsStyleCoord.h // but not defined there because they need WritingMode. inline nsStyleUnit nsStyleSides::GetUnit(mozilla::WritingMode aWM, mozilla::LogicalSide aSide) const { return GetUnit(aWM.PhysicalSide(aSide)); } inline nsStyleUnit nsStyleSides::GetIStartUnit(mozilla::WritingMode aWM) const { return GetUnit(aWM, mozilla::eLogicalSideIStart); } inline nsStyleUnit nsStyleSides::GetBStartUnit(mozilla::WritingMode aWM) const { return GetUnit(aWM, mozilla::eLogicalSideBStart); } inline nsStyleUnit nsStyleSides::GetIEndUnit(mozilla::WritingMode aWM) const { return GetUnit(aWM, mozilla::eLogicalSideIEnd); } inline nsStyleUnit nsStyleSides::GetBEndUnit(mozilla::WritingMode aWM) const { return GetUnit(aWM, mozilla::eLogicalSideBEnd); } inline bool nsStyleSides::HasBlockAxisAuto(mozilla::WritingMode aWM) const { return GetBStartUnit(aWM) == eStyleUnit_Auto || GetBEndUnit(aWM) == eStyleUnit_Auto; } inline bool nsStyleSides::HasInlineAxisAuto(mozilla::WritingMode aWM) const { return GetIStartUnit(aWM) == eStyleUnit_Auto || GetIEndUnit(aWM) == eStyleUnit_Auto; } inline nsStyleCoord nsStyleSides::Get(mozilla::WritingMode aWM, mozilla::LogicalSide aSide) const { return Get(aWM.PhysicalSide(aSide)); } inline nsStyleCoord nsStyleSides::GetIStart(mozilla::WritingMode aWM) const { return Get(aWM, mozilla::eLogicalSideIStart); } inline nsStyleCoord nsStyleSides::GetBStart(mozilla::WritingMode aWM) const { return Get(aWM, mozilla::eLogicalSideBStart); } inline nsStyleCoord nsStyleSides::GetIEnd(mozilla::WritingMode aWM) const { return Get(aWM, mozilla::eLogicalSideIEnd); } inline nsStyleCoord nsStyleSides::GetBEnd(mozilla::WritingMode aWM) const { return Get(aWM, mozilla::eLogicalSideBEnd); } // Definitions of inline methods for nsStylePosition, declared in // nsStyleStruct.h but not defined there because they need WritingMode. inline nsStyleCoord& nsStylePosition::ISize(mozilla::WritingMode aWM) { return aWM.IsVertical() ? mHeight : mWidth; } inline nsStyleCoord& nsStylePosition::MinISize(mozilla::WritingMode aWM) { return aWM.IsVertical() ? mMinHeight : mMinWidth; } inline nsStyleCoord& nsStylePosition::MaxISize(mozilla::WritingMode aWM) { return aWM.IsVertical() ? mMaxHeight : mMaxWidth; } inline nsStyleCoord& nsStylePosition::BSize(mozilla::WritingMode aWM) { return aWM.IsVertical() ? mWidth : mHeight; } inline nsStyleCoord& nsStylePosition::MinBSize(mozilla::WritingMode aWM) { return aWM.IsVertical() ? mMinWidth : mMinHeight; } inline nsStyleCoord& nsStylePosition::MaxBSize(mozilla::WritingMode aWM) { return aWM.IsVertical() ? mMaxWidth : mMaxHeight; } inline const nsStyleCoord& nsStylePosition::ISize(mozilla::WritingMode aWM) const { return aWM.IsVertical() ? mHeight : mWidth; } inline const nsStyleCoord& nsStylePosition::MinISize(mozilla::WritingMode aWM) const { return aWM.IsVertical() ? mMinHeight : mMinWidth; } inline const nsStyleCoord& nsStylePosition::MaxISize(mozilla::WritingMode aWM) const { return aWM.IsVertical() ? mMaxHeight : mMaxWidth; } inline const nsStyleCoord& nsStylePosition::BSize(mozilla::WritingMode aWM) const { return aWM.IsVertical() ? mWidth : mHeight; } inline const nsStyleCoord& nsStylePosition::MinBSize(mozilla::WritingMode aWM) const { return aWM.IsVertical() ? mMinWidth : mMinHeight; } inline const nsStyleCoord& nsStylePosition::MaxBSize(mozilla::WritingMode aWM) const { return aWM.IsVertical() ? mMaxWidth : mMaxHeight; } inline bool nsStylePosition::ISizeDependsOnContainer(mozilla::WritingMode aWM) const { return aWM.IsVertical() ? HeightDependsOnContainer() : WidthDependsOnContainer(); } inline bool nsStylePosition::MinISizeDependsOnContainer(mozilla::WritingMode aWM) const { return aWM.IsVertical() ? MinHeightDependsOnContainer() : MinWidthDependsOnContainer(); } inline bool nsStylePosition::MaxISizeDependsOnContainer(mozilla::WritingMode aWM) const { return aWM.IsVertical() ? MaxHeightDependsOnContainer() : MaxWidthDependsOnContainer(); } inline bool nsStylePosition::BSizeDependsOnContainer(mozilla::WritingMode aWM) const { return aWM.IsVertical() ? WidthDependsOnContainer() : HeightDependsOnContainer(); } inline bool nsStylePosition::MinBSizeDependsOnContainer(mozilla::WritingMode aWM) const { return aWM.IsVertical() ? MinWidthDependsOnContainer() : MinHeightDependsOnContainer(); } inline bool nsStylePosition::MaxBSizeDependsOnContainer(mozilla::WritingMode aWM) const { return aWM.IsVertical() ? MaxWidthDependsOnContainer() : MaxHeightDependsOnContainer(); } inline mozilla::StyleFloat nsStyleDisplay::PhysicalFloats(mozilla::WritingMode aWM) const { using StyleFloat = mozilla::StyleFloat; if (mFloat == StyleFloat::InlineStart) { return aWM.IsBidiLTR() ? StyleFloat::Left : StyleFloat::Right; } if (mFloat == StyleFloat::InlineEnd) { return aWM.IsBidiLTR() ? StyleFloat::Right : StyleFloat::Left; } return mFloat; } inline mozilla::StyleClear nsStyleDisplay::PhysicalBreakType(mozilla::WritingMode aWM) const { using StyleClear = mozilla::StyleClear; if (mBreakType == StyleClear::InlineStart) { return aWM.IsBidiLTR() ? StyleClear::Left : StyleClear::Right; } if (mBreakType == StyleClear::InlineEnd) { return aWM.IsBidiLTR() ? StyleClear::Right : StyleClear::Left; } return mBreakType; } inline bool nsStyleMargin::HasBlockAxisAuto(mozilla::WritingMode aWM) const { return mMargin.HasBlockAxisAuto(aWM); } inline bool nsStyleMargin::HasInlineAxisAuto(mozilla::WritingMode aWM) const { return mMargin.HasInlineAxisAuto(aWM); } #endif // WritingModes_h_