layout/generic/nsBRFrame.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 /* rendering object for HTML <br> elements */
   7
   8 #include "nsCOMPtr.h"
   9 #include "nsFrame.h"
  10 #include "nsPresContext.h"
  11 #include "nsLineLayout.h"
  12 #include "nsStyleConsts.h"
  13 #include "nsGkAtoms.h"
  14 #include "nsRenderingContext.h"
  15 #include "nsLayoutUtils.h"
  16
  17 //FOR SELECTION
  18 #include "nsIContent.h"
  19 //END INCLUDES FOR SELECTION
  20
  21 using namespace mozilla;
  22
  23 class BRFrame : public nsFrame {
  24 public:
  25   NS_DECL_FRAMEARENA_HELPERS
  26
  27   friend nsIFrame* NS_NewBRFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
  28
  29   virtual ContentOffsets CalcContentOffsetsFromFramePoint(nsPoint aPoint) MOZ_OVERRIDE;
  30
  31   virtual FrameSearchResult PeekOffsetNoAmount(bool aForward, int32_t* aOffset) MOZ_OVERRIDE;
  32   virtual FrameSearchResult PeekOffsetCharacter(bool aForward, int32_t* aOffset,
  33                                      bool aRespectClusters = true) MOZ_OVERRIDE;
  34   virtual FrameSearchResult PeekOffsetWord(bool aForward, bool aWordSelectEatSpace,
  35                               bool aIsKeyboardSelect, int32_t* aOffset,
  36                               PeekWordState* aState) MOZ_OVERRIDE;
  37
  38   virtual void Reflow(nsPresContext* aPresContext,
  39                           nsHTMLReflowMetrics& aDesiredSize,
  40                           const nsHTMLReflowState& aReflowState,
  41                           nsReflowStatus& aStatus) MOZ_OVERRIDE;
  42   virtual void AddInlineMinISize(nsRenderingContext *aRenderingContext,
  43                                  InlineMinISizeData *aData) MOZ_OVERRIDE;
  44   virtual void AddInlinePrefISize(nsRenderingContext *aRenderingContext,
  45                                   InlinePrefISizeData *aData) MOZ_OVERRIDE;
  46   virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
  47   virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
  48   virtual nsIAtom* GetType() const MOZ_OVERRIDE;
  49   virtual nscoord GetLogicalBaseline(mozilla::WritingMode aWritingMode) const MOZ_OVERRIDE;
  50
  51   virtual bool IsFrameOfType(uint32_t aFlags) const MOZ_OVERRIDE
  52   {
  53     return nsFrame::IsFrameOfType(aFlags & ~(nsIFrame::eReplaced |
  54                                              nsIFrame::eLineParticipant));
  55   }
  56
  57 #ifdef ACCESSIBILITY
  58   virtual mozilla::a11y::AccType AccessibleType() MOZ_OVERRIDE;
  59 #endif
  60
  61 protected:
  62   explicit BRFrame(nsStyleContext* aContext) : nsFrame(aContext) {}
  63   virtual ~BRFrame();
  64
  65   nscoord mAscent;
  66 };
  67
  68 nsIFrame*
  69 NS_NewBRFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
  70 {
  71   return new (aPresShell) BRFrame(aContext);
  72 }
  73
  74 NS_IMPL_FRAMEARENA_HELPERS(BRFrame)
  75
  76 BRFrame::~BRFrame()
  77 {
  78 }
  79
  80 void
  81 BRFrame::Reflow(nsPresContext* aPresContext,
  82                 nsHTMLReflowMetrics& aMetrics,
  83                 const nsHTMLReflowState& aReflowState,
  84                 nsReflowStatus& aStatus)
  85 {
  86   DO_GLOBAL_REFLOW_COUNT("BRFrame");
  87   DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus);
  88   WritingMode wm = aReflowState.GetWritingMode();
  89   LogicalSize finalSize(wm);
  90   finalSize.BSize(wm) = 0; // BR frames with block size 0 are ignored in quirks
  91                            // mode by nsLineLayout::VerticalAlignFrames .
  92                            // However, it's not always 0.  See below.
  93   finalSize.ISize(wm) = 0;
  94   aMetrics.SetBlockStartAscent(0);
  95
  96   // Only when the BR is operating in a line-layout situation will it
  97   // behave like a BR.
  98   nsLineLayout* ll = aReflowState.mLineLayout;
  99   if (ll) {
 100     // Note that the compatibility mode check excludes AlmostStandards
 101     // mode, since this is the inline box model.  See bug 161691.
 102     if ( ll->LineIsEmpty() ||
 103          aPresContext->CompatibilityMode() == eCompatibility_FullStandards ) {
 104       // The line is logically empty; any whitespace is trimmed away.
 105       //
 106       // If this frame is going to terminate the line we know
 107       // that nothing else will go on the line. Therefore, in this
 108       // case, we provide some height for the BR frame so that it
 109       // creates some vertical whitespace.  It's necessary to use the
 110       // line-height rather than the font size because the
 111       // quirks-mode fix that doesn't apply the block's min
 112       // line-height makes this necessary to make BR cause a line
 113       // of the full line-height
 114
 115       // We also do this in strict mode because BR should act like a
 116       // normal inline frame.  That line-height is used is important
 117       // here for cases where the line-height is less than 1.
 118       nsRefPtr<nsFontMetrics> fm;
 119       nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm),
 120         nsLayoutUtils::FontSizeInflationFor(this));
 121       aReflowState.rendContext->SetFont(fm); // FIXME: maybe not needed?
 122       if (fm) {
 123         nscoord logicalHeight = aReflowState.CalcLineHeight();
 124         finalSize.BSize(wm) = logicalHeight;
 125         aMetrics.SetBlockStartAscent(nsLayoutUtils::GetCenteredFontBaseline(fm, logicalHeight));
 126       }
 127       else {
 128         aMetrics.SetBlockStartAscent(aMetrics.BSize(wm) = 0);
 129       }
 130
 131       // XXX temporary until I figure out a better solution; see the
 132       // code in nsLineLayout::VerticalAlignFrames that zaps minY/maxY
 133       // if the width is zero.
 134       // XXX This also fixes bug 10036!
 135       // Warning: nsTextControlFrame::CalculateSizeStandard depends on
 136       // the following line, see bug 228752.
 137       finalSize.ISize(wm) = 1;
 138     }
 139
 140     // Return our reflow status
 141     uint32_t breakType = aReflowState.mStyleDisplay->mBreakType;
 142     if (NS_STYLE_CLEAR_NONE == breakType) {
 143       breakType = NS_STYLE_CLEAR_LINE;
 144     }
 145
 146     aStatus = NS_INLINE_BREAK | NS_INLINE_BREAK_AFTER |
 147       NS_INLINE_MAKE_BREAK_TYPE(breakType);
 148     ll->SetLineEndsInBR(true);
 149   }
 150   else {
 151     aStatus = NS_FRAME_COMPLETE;
 152   }
 153
 154   aMetrics.SetSize(wm, finalSize);
 155   aMetrics.SetOverflowAreasToDesiredBounds();
 156
 157   mAscent = aMetrics.BlockStartAscent();
 158
 159   NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aMetrics);
 160 }
 161
 162 /* virtual */ void
 163 BRFrame::AddInlineMinISize(nsRenderingContext *aRenderingContext,
 164                            nsIFrame::InlineMinISizeData *aData)
 165 {
 166   aData->ForceBreak(aRenderingContext);
 167 }
 168
 169 /* virtual */ void
 170 BRFrame::AddInlinePrefISize(nsRenderingContext *aRenderingContext,
 171                             nsIFrame::InlinePrefISizeData *aData)
 172 {
 173   aData->ForceBreak(aRenderingContext);
 174 }
 175
 176 /* virtual */ nscoord
 177 BRFrame::GetMinISize(nsRenderingContext *aRenderingContext)
 178 {
 179   nscoord result = 0;
 180   DISPLAY_MIN_WIDTH(this, result);
 181   return result;
 182 }
 183
 184 /* virtual */ nscoord
 185 BRFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
 186 {
 187   nscoord result = 0;
 188   DISPLAY_PREF_WIDTH(this, result);
 189   return result;
 190 }
 191
 192 nsIAtom*
 193 BRFrame::GetType() const
 194 {
 195   return nsGkAtoms::brFrame;
 196 }
 197
 198 nscoord
 199 BRFrame::GetLogicalBaseline(mozilla::WritingMode aWritingMode) const
 200 {
 201   return mAscent;
 202 }
 203
 204 nsIFrame::ContentOffsets BRFrame::CalcContentOffsetsFromFramePoint(nsPoint aPoint)
 205 {
 206   ContentOffsets offsets;
 207   offsets.content = mContent->GetParent();
 208   if (offsets.content) {
 209     offsets.offset = offsets.content->IndexOf(mContent);
 210     offsets.secondaryOffset = offsets.offset;
 211     offsets.associate = CARET_ASSOCIATE_AFTER;
 212   }
 213   return offsets;
 214 }
 215
 216 nsIFrame::FrameSearchResult
 217 BRFrame::PeekOffsetNoAmount(bool aForward, int32_t* aOffset)
 218 {
 219   NS_ASSERTION (aOffset && *aOffset <= 1, "aOffset out of range");
 220   int32_t startOffset = *aOffset;
 221   // If we hit the end of a BR going backwards, go to its beginning and stay there.
 222   if (!aForward && startOffset != 0) {
 223     *aOffset = 0;
 224     return FOUND;
 225   }
 226   // Otherwise, stop if we hit the beginning, continue (forward) if we hit the end.
 227   return (startOffset == 0) ? FOUND : CONTINUE;
 228 }
 229
 230 nsIFrame::FrameSearchResult
 231 BRFrame::PeekOffsetCharacter(bool aForward, int32_t* aOffset,
 232                              bool aRespectClusters)
 233 {
 234   NS_ASSERTION (aOffset && *aOffset <= 1, "aOffset out of range");
 235   // Keep going. The actual line jumping will stop us.
 236   return CONTINUE;
 237 }
 238
 239 nsIFrame::FrameSearchResult
 240 BRFrame::PeekOffsetWord(bool aForward, bool aWordSelectEatSpace, bool aIsKeyboardSelect,
 241                         int32_t* aOffset, PeekWordState* aState)
 242 {
 243   NS_ASSERTION (aOffset && *aOffset <= 1, "aOffset out of range");
 244   // Keep going. The actual line jumping will stop us.
 245   return CONTINUE;
 246 }
 247
 248 #ifdef ACCESSIBILITY
 249 a11y::AccType
 250 BRFrame::AccessibleType()
 251 {
 252   nsIContent *parent = mContent->GetParent();
 253   if (parent && parent->IsRootOfNativeAnonymousSubtree() &&
 254       parent->GetChildCount() == 1) {
 255     // This <br> is the only node in a text control, therefore it is the hacky
 256     // "bogus node" used when there is no text in the control
 257     return a11y::eNoType;
 258   }
 259
 260   return a11y::eHTMLBRType;
 261 }
 262 #endif
 263