Lines Matching full:line
54 // We don't let our line box tree for a single line get any deeper than this.
97 // Check to see if our last midpoint is a start point beyond the line break. If so,
108 // We hit the line break before the start point. Shave off the start point.
188 // We only treat a box as text for a <br> if we are on a line by ourself or in strict mode
213 // See if we have an unconstructed line box for this object that is also
214 // the last item on the line.
225 // If this box is constructed then it is from a previous line, and we need
226 // to make a new box for our line. If this box is unconstructed but it has
227 // something following it on the line, then we know we have to make a new box
229 // the same line (this can happen with very fancy language mixtures).
233 // made, we need to place it at the end of the current line.
245 // inline box for the line, and it doesn't have to be appended to any parent
255 // If we've exceeded our line depth, then jump straight to the root and skip all the remaining
289 // Append the inline box to this line.
304 // be the last continuation of our line list.
310 // the line.
313 // Now mark the line boxes as being constructed.
316 // Return the last line.
333 // Similarly, line break boxes have no effect on the width.
371 // Armed with the total width of the line (without justification),
373 // objects horizontally. The total width of the line can be increased if we end up
488 continue; // Skip runs with no line boxes.
490 // Align positioned boxes with the top of the line box. This is
503 // position(), which unnecessarily dirties the line.
507 // collects one line of the paragraph and transforms it to visual order
533 // Figure out if we should clear out our line boxes.
546 // Walk all the lines and delete our ellipsis line boxes if they exist.
557 // In case the line height is less than the font size, we skip
688 // We want to skip ahead to the first dirty line
712 // We also find the first clean line and extract these lines. We will add them back
738 // If the last line before the start line ends with a line break that clear floats,
740 // A line break can be either the first or the last object on a line, depending on its direction.
830 // Now that the runs have been ordered, we create the line boxes.
901 for (RootInlineBox* line = endLine; line; line = line->nextRootBox()) {
902 line->attachLine();
904 repaintTop = min(repaintTop, line->topVisibleOverflow() + min(delta, 0));
905 repaintBottom = max(repaintBottom, line->bottomVisibleOverflow() + max(delta, 0));
906 line->adjustPosition(0, delta);
908 if (Vector<RenderBox*>* cleanLineFloats = line->floatsPtr()) {
921 RootInlineBox* line = endLine;
923 while (line) {
924 repaintTop = min(repaintTop, line->topVisibleOverflow());
925 repaintBottom = max(repaintBottom, line->bottomVisibleOverflow());
926 RootInlineBox* next = line->nextRootBox();
927 line->deleteLine(arena);
928 line = next;
933 // In case we have a float on the last line, it might not be positioned up to now.
1000 // A new float has been inserted before this line or before its last known float.
1037 // We have a dirty line.
1039 // We have a previous line.
1041 // The previous line didn't break cleanly or broke at a newline
1047 // If the last line didn't break cleanly, treat it as dirty.
1060 RootInlineBox* line = firstRootBox();
1061 while (line != curr) {
1062 line->floatsPtr()) {
1072 line = line->nextRootBox();
1130 for (RootInlineBox* line = last; line; line = line->nextRootBox())
1131 line->extractLine(); // Disconnect all line boxes from their render objects while preserving
1164 // The first clean line doesn't match, but we can check a handful of following lines to try
1167 RootInlineBox* line = endLine;
1168 for (int i = 0; i < numLines && line; i++, line = line->nextRootBox()) {
1169 if (line->lineBreakObj() == resolver.position().obj && line->lineBreakPos() == resolver.position().pos) {
1171 if (line->lineBreakBidiStatus() != resolver.status())
1173 RootInlineBox* result = line->nextRootBox();
1177 endYPos = line->blockHeight();
1223 // on a line after a clean line break (or on the first line, since previousLineBrokeCleanly starts off
1248 // FIXME: Right now, we only allow line boxes for inlines that are truly empty.
1250 // ignorable whitespace should should also have line boxes.
1282 // line boxes even for containers that may ultimately collapse away. Otherwise we'll never get positioned
1283 // elements quite right. In other words, we need to build this function's work into the normal line
1358 // This is currently just used for list markers and inline flows that have line boxes. Neither should
1359 // have an effect on whitespace at the start of the line.
1477 // A <br> always breaks a line, so don't let the line be collapsed
1478 // away. Also, the space at the end of a line with a <br> does not
1479 // get collapsed away. It only does this if the previous line broke
1480 // cleanly. Otherwise the <br> has no effect on whether the line is
1498 // check if it fits in the current line.
1500 // it after moving to next line (in newLine() func)
1551 // Now that some inline flows have line boxes, if we are already ignoring spaces, we need
1553 // If this object is at the start of the line, we need to behave like list markers and
1633 // which is only possible if the word is the first thing on the line, that is, if |w| is zero.
1676 // on the line if it shows when we break.
1741 // as candidate width for this line.
1745 // Check if line is too big even without the extra space
1746 // at the end of the line. If it is not, do nothing.
1747 // If the line needs the extra whitespace to be too long,
1748 // then move the line break to the space and skip all
1773 // Subtract the width of the soft hyphen out since we fit on a line.
1884 // If the next item on the line is text, and if we did not end with
1919 // the end label if we still don't fit on the line. -dwh
1969 // There's no room at all. We just have to be on this line,
2014 // For soft hyphens on line breaks, we have to chop out the midpoints that made us
2015 // ignore the hyphen so that it will render at the end of the line.
2051 // if the right edge of a line box exceeds that. For RTL, we use the left edge of the padding box and
2052 // check the left edge of the line box to see if it is less
2060 // This line spills out of our box in the appropriate direction. Now we need to see if the line
2061 // can be truncated. In order for truncation to be possible, the line must have sufficient space to
