layout/forms/nsDateTimeControlFrame.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /**
   8  * This frame type is used for input type=date, time, month, week, and
   9  * datetime-local.
  10  */
  11
  12 #include "nsDateTimeControlFrame.h"
  13
  14 #include "mozilla/PresShell.h"
  15 #include "nsLayoutUtils.h"
  16 #include "nsTextControlFrame.h"
  17
  18 using namespace mozilla;
  19 using namespace mozilla::dom;
  20
  21 nsIFrame* NS_NewDateTimeControlFrame(PresShell* aPresShell,
  22                                      ComputedStyle* aStyle) {
  23   return new (aPresShell)
  24       nsDateTimeControlFrame(aStyle, aPresShell->GetPresContext());
  25 }
  26
  27 NS_IMPL_FRAMEARENA_HELPERS(nsDateTimeControlFrame)
  28
  29 NS_QUERYFRAME_HEAD(nsDateTimeControlFrame)
  30   NS_QUERYFRAME_ENTRY(nsDateTimeControlFrame)
  31 NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
  32
  33 nsDateTimeControlFrame::nsDateTimeControlFrame(ComputedStyle* aStyle,
  34                                                nsPresContext* aPresContext)
  35     : nsContainerFrame(aStyle, aPresContext, kClassID) {}
  36
  37 nscoord nsDateTimeControlFrame::GetMinISize(gfxContext* aRenderingContext) {
  38   nscoord result;
  39   DISPLAY_MIN_INLINE_SIZE(this, result);
  40
  41   nsIFrame* kid = mFrames.FirstChild();
  42   if (kid) {  // display:none?
  43     result = nsLayoutUtils::IntrinsicForContainer(aRenderingContext, kid,
  44                                                   IntrinsicISizeType::MinISize);
  45   } else {
  46     result = 0;
  47   }
  48
  49   return result;
  50 }
  51
  52 nscoord nsDateTimeControlFrame::GetPrefISize(gfxContext* aRenderingContext) {
  53   nscoord result;
  54   DISPLAY_PREF_INLINE_SIZE(this, result);
  55
  56   nsIFrame* kid = mFrames.FirstChild();
  57   if (kid) {  // display:none?
  58     result = nsLayoutUtils::IntrinsicForContainer(
  59         aRenderingContext, kid, IntrinsicISizeType::PrefISize);
  60   } else {
  61     result = 0;
  62   }
  63
  64   return result;
  65 }
  66
  67 Maybe<nscoord> nsDateTimeControlFrame::GetNaturalBaselineBOffset(
  68     WritingMode aWM, BaselineSharingGroup aBaselineGroup,
  69     BaselineExportContext) const {
  70   return nsTextControlFrame::GetSingleLineTextControlBaseline(
  71       this, mFirstBaseline, aWM, aBaselineGroup);
  72 }
  73
  74 void nsDateTimeControlFrame::Reflow(nsPresContext* aPresContext,
  75                                     ReflowOutput& aDesiredSize,
  76                                     const ReflowInput& aReflowInput,
  77                                     nsReflowStatus& aStatus) {
  78   MarkInReflow();
  79
  80   DO_GLOBAL_REFLOW_COUNT("nsDateTimeControlFrame");
  81   DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
  82   MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
  83   NS_FRAME_TRACE(
  84       NS_FRAME_TRACE_CALLS,
  85       ("enter nsDateTimeControlFrame::Reflow: availSize=%d,%d",
  86        aReflowInput.AvailableWidth(), aReflowInput.AvailableHeight()));
  87
  88   NS_ASSERTION(mFrames.GetLength() <= 1,
  89                "There should be no more than 1 frames");
  90
  91   const WritingMode myWM = aReflowInput.GetWritingMode();
  92
  93   {
  94     auto baseline = nsTextControlFrame::ComputeBaseline(
  95         this, aReflowInput, /* aForSingleLineControl = */ true);
  96     mFirstBaseline = baseline.valueOr(NS_INTRINSIC_ISIZE_UNKNOWN);
  97     if (baseline) {
  98       aDesiredSize.SetBlockStartAscent(*baseline);
  99     }
 100   }
 101
 102   // The ISize of our content box, which is the available ISize
 103   // for our anonymous content:
 104   const nscoord contentBoxISize = aReflowInput.ComputedISize();
 105   nscoord contentBoxBSize = aReflowInput.ComputedBSize();
 106
 107   // Figure out our border-box sizes as well (by adding borderPadding to
 108   // content-box sizes):
 109   const auto borderPadding = aReflowInput.ComputedLogicalBorderPadding(myWM);
 110   const nscoord borderBoxISize =
 111       contentBoxISize + borderPadding.IStartEnd(myWM);
 112
 113   nscoord borderBoxBSize;
 114   if (contentBoxBSize != NS_UNCONSTRAINEDSIZE) {
 115     borderBoxBSize = contentBoxBSize + borderPadding.BStartEnd(myWM);
 116   }  // else, we'll figure out borderBoxBSize after we resolve contentBoxBSize.
 117
 118   nsIFrame* inputAreaFrame = mFrames.FirstChild();
 119   if (!inputAreaFrame) {  // display:none?
 120     if (contentBoxBSize == NS_UNCONSTRAINEDSIZE) {
 121       contentBoxBSize = 0;
 122       borderBoxBSize = borderPadding.BStartEnd(myWM);
 123     }
 124   } else {
 125     ReflowOutput childDesiredSize(aReflowInput);
 126
 127     WritingMode wm = inputAreaFrame->GetWritingMode();
 128     LogicalSize availSize = aReflowInput.ComputedSize(wm);
 129     availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
 130
 131     ReflowInput childReflowInput(aPresContext, aReflowInput, inputAreaFrame,
 132                                  availSize);
 133
 134     // Convert input area margin into my own writing-mode (in case it differs):
 135     LogicalMargin childMargin = childReflowInput.ComputedLogicalMargin(myWM);
 136
 137     // offsets of input area frame within this frame:
 138     LogicalPoint childOffset(
 139         myWM, borderPadding.IStart(myWM) + childMargin.IStart(myWM),
 140         borderPadding.BStart(myWM) + childMargin.BStart(myWM));
 141
 142     nsReflowStatus childStatus;
 143     // We initially reflow the child with a dummy containerSize; positioning
 144     // will be fixed later.
 145     const nsSize dummyContainerSize;
 146     ReflowChild(inputAreaFrame, aPresContext, childDesiredSize,
 147                 childReflowInput, myWM, childOffset, dummyContainerSize,
 148                 ReflowChildFlags::Default, childStatus);
 149     MOZ_ASSERT(childStatus.IsFullyComplete(),
 150                "We gave our child unconstrained available block-size, "
 151                "so it should be complete");
 152
 153     nscoord childMarginBoxBSize =
 154         childDesiredSize.BSize(myWM) + childMargin.BStartEnd(myWM);
 155
 156     if (contentBoxBSize == NS_UNCONSTRAINEDSIZE) {
 157       // We are intrinsically sized -- we should shrinkwrap the input area's
 158       // block-size, or our line-height:
 159       contentBoxBSize =
 160           std::max(aReflowInput.GetLineHeight(), childMarginBoxBSize);
 161
 162       // Make sure we obey min/max-bsize in the case when we're doing intrinsic
 163       // sizing (we get it for free when we have a non-intrinsic
 164       // aReflowInput.ComputedBSize()).  Note that we do this before
 165       // adjusting for borderpadding, since ComputedMaxBSize and
 166       // ComputedMinBSize are content heights.
 167       contentBoxBSize =
 168           NS_CSS_MINMAX(contentBoxBSize, aReflowInput.ComputedMinBSize(),
 169                         aReflowInput.ComputedMaxBSize());
 170
 171       borderBoxBSize = contentBoxBSize + borderPadding.BStartEnd(myWM);
 172     }
 173
 174     // Center child in block axis
 175     nscoord extraSpace = contentBoxBSize - childMarginBoxBSize;
 176     childOffset.B(myWM) += std::max(0, extraSpace / 2);
 177
 178     // Needed in FinishReflowChild, for logical-to-physical conversion:
 179     nsSize borderBoxSize =
 180         LogicalSize(myWM, borderBoxISize, borderBoxBSize).GetPhysicalSize(myWM);
 181
 182     // Place the child
 183     FinishReflowChild(inputAreaFrame, aPresContext, childDesiredSize,
 184                       &childReflowInput, myWM, childOffset, borderBoxSize,
 185                       ReflowChildFlags::Default);
 186   }
 187
 188   LogicalSize logicalDesiredSize(myWM, borderBoxISize, borderBoxBSize);
 189   aDesiredSize.SetSize(myWM, logicalDesiredSize);
 190   aDesiredSize.SetOverflowAreasToDesiredBounds();
 191
 192   if (inputAreaFrame) {
 193     ConsiderChildOverflow(aDesiredSize.mOverflowAreas, inputAreaFrame);
 194   }
 195
 196   FinishAndStoreOverflow(&aDesiredSize);
 197
 198   NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
 199                  ("exit nsDateTimeControlFrame::Reflow: size=%d,%d",
 200                   aDesiredSize.Width(), aDesiredSize.Height()));
 201 }