1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef UI_GFX_RENDER_TEXT_H_
6 #define UI_GFX_RENDER_TEXT_H_
14 #include "base/gtest_prod_util.h"
15 #include "base/i18n/rtl.h"
16 #include "base/memory/scoped_ptr.h"
17 #include "base/strings/string16.h"
18 #include "skia/ext/refptr.h"
19 #include "third_party/skia/include/core/SkColor.h"
20 #include "third_party/skia/include/core/SkPaint.h"
21 #include "third_party/skia/include/core/SkRect.h"
22 #include "ui/gfx/break_list.h"
23 #include "ui/gfx/font_list.h"
24 #include "ui/gfx/font_render_params.h"
25 #include "ui/gfx/point.h"
26 #include "ui/gfx/range/range.h"
27 #include "ui/gfx/rect.h"
28 #include "ui/gfx/selection_model.h"
29 #include "ui/gfx/shadow_value.h"
30 #include "ui/gfx/size_f.h"
31 #include "ui/gfx/text_constants.h"
32 #include "ui/gfx/vector2d.h"
48 // Internal helper class used by derived classes to draw text through Skia.
49 class SkiaTextRenderer
{
51 explicit SkiaTextRenderer(Canvas
* canvas
);
54 void SetDrawLooper(SkDrawLooper
* draw_looper
);
55 void SetFontRenderParams(const FontRenderParams
& params
,
56 bool background_is_transparent
);
57 void SetTypeface(SkTypeface
* typeface
);
58 void SetTextSize(SkScalar size
);
59 void SetFontFamilyWithStyle(const std::string
& family
, int font_style
);
60 void SetForegroundColor(SkColor foreground
);
61 void SetShader(SkShader
* shader
, const Rect
& bounds
);
62 // Sets underline metrics to use if the text will be drawn with an underline.
63 // If not set, default values based on the size of the text will be used. The
64 // two metrics must be set together.
65 void SetUnderlineMetrics(SkScalar thickness
, SkScalar position
);
66 void DrawSelection(const std::vector
<Rect
>& selection
, SkColor color
);
67 void DrawPosText(const SkPoint
* pos
,
70 // Draw underline and strike-through text decorations.
71 // Based on |SkCanvas::DrawTextDecorations()| and constants from:
72 // third_party/skia/src/core/SkTextFormatParams.h
73 void DrawDecorations(int x
, int y
, int width
, bool underline
, bool strike
,
74 bool diagonal_strike
);
75 // Finishes any ongoing diagonal strike run.
76 void EndDiagonalStrike();
77 void DrawUnderline(int x
, int y
, int width
);
78 void DrawStrike(int x
, int y
, int width
) const;
81 // Helper class to draw a diagonal line with multiple pieces of different
82 // lengths and colors; to support text selection appearances.
83 class DiagonalStrike
{
85 DiagonalStrike(Canvas
* canvas
, Point start
, const SkPaint
& paint
);
88 void AddPiece(int length
, SkColor color
);
92 typedef std::pair
<int, SkColor
> Piece
;
98 std::vector
<Piece
> pieces_
;
100 DISALLOW_COPY_AND_ASSIGN(DiagonalStrike
);
104 SkCanvas
* canvas_skia_
;
105 bool started_drawing_
;
108 skia::RefPtr
<SkShader
> deferred_fade_shader_
;
109 SkScalar underline_thickness_
;
110 SkScalar underline_position_
;
111 scoped_ptr
<DiagonalStrike
> diagonal_
;
113 DISALLOW_COPY_AND_ASSIGN(SkiaTextRenderer
);
116 // Internal helper class used by derived classes to iterate colors and styles.
117 class StyleIterator
{
119 StyleIterator(const BreakList
<SkColor
>& colors
,
120 const std::vector
<BreakList
<bool> >& styles
);
123 // Get the colors and styles at the current iterator position.
124 SkColor
color() const { return color_
->second
; }
125 bool style(TextStyle s
) const { return style_
[s
]->second
; }
127 // Get the intersecting range of the current iterator set.
128 Range
GetRange() const;
130 // Update the iterator to point to colors and styles applicable at |position|.
131 void UpdatePosition(size_t position
);
134 BreakList
<SkColor
> colors_
;
135 std::vector
<BreakList
<bool> > styles_
;
137 BreakList
<SkColor
>::const_iterator color_
;
138 std::vector
<BreakList
<bool>::const_iterator
> style_
;
140 DISALLOW_COPY_AND_ASSIGN(StyleIterator
);
143 // Line segments are slices of the layout text to be rendered on a single line.
148 // X coordinates of this line segment in text space.
151 // The character range this segment corresponds to.
154 // Index of the text run that generated this segment.
158 // A line of layout text, comprised of a line segment list and some metrics.
163 // Segments that make up this line in visual order.
164 std::vector
<LineSegment
> segments
;
166 // The sum of segment widths and the maximum of segment heights.
169 // Sum of preceding lines' heights.
170 int preceding_heights
;
172 // Maximum baseline of all segments on this line.
176 // Creates an SkTypeface from a font |family| name and a |gfx::Font::FontStyle|.
178 skia::RefPtr
<SkTypeface
> CreateSkiaTypeface(const std::string
& family
,
181 // Applies the given FontRenderParams to a Skia |paint|.
182 void ApplyRenderParams(const FontRenderParams
& params
,
183 bool background_is_transparent
,
186 } // namespace internal
188 // RenderText represents an abstract model of styled text and its corresponding
189 // visual layout. Support is built in for a cursor, a selection, simple styling,
190 // complex scripts, and bi-directional text. Implementations provide mechanisms
191 // for rendering and translation between logical and visual data.
192 class GFX_EXPORT RenderText
{
194 virtual ~RenderText();
196 // Creates a platform-specific or cross-platform RenderText instance.
197 static RenderText
* CreateInstance();
199 const base::string16
& text() const { return text_
; }
200 void SetText(const base::string16
& text
);
202 HorizontalAlignment
horizontal_alignment() const {
203 return horizontal_alignment_
;
205 void SetHorizontalAlignment(HorizontalAlignment alignment
);
207 const FontList
& font_list() const { return font_list_
; }
208 void SetFontList(const FontList
& font_list
);
210 bool cursor_enabled() const { return cursor_enabled_
; }
211 void SetCursorEnabled(bool cursor_enabled
);
213 bool cursor_visible() const { return cursor_visible_
; }
214 void set_cursor_visible(bool visible
) { cursor_visible_
= visible
; }
216 bool insert_mode() const { return insert_mode_
; }
217 void ToggleInsertMode();
219 SkColor
cursor_color() const { return cursor_color_
; }
220 void set_cursor_color(SkColor color
) { cursor_color_
= color
; }
222 SkColor
selection_color() const { return selection_color_
; }
223 void set_selection_color(SkColor color
) { selection_color_
= color
; }
225 SkColor
selection_background_focused_color() const {
226 return selection_background_focused_color_
;
228 void set_selection_background_focused_color(SkColor color
) {
229 selection_background_focused_color_
= color
;
232 bool focused() const { return focused_
; }
233 void set_focused(bool focused
) { focused_
= focused
; }
235 bool clip_to_display_rect() const { return clip_to_display_rect_
; }
236 void set_clip_to_display_rect(bool clip
) { clip_to_display_rect_
= clip
; }
238 // In an obscured (password) field, all text is drawn as asterisks or bullets.
239 bool obscured() const { return obscured_
; }
240 void SetObscured(bool obscured
);
242 // Makes a char in obscured text at |index| to be revealed. |index| should be
243 // a UTF16 text index. If there is a previous revealed index, the previous one
244 // is cleared and only the last set index will be revealed. If |index| is -1
245 // or out of range, no char will be revealed. The revealed index is also
246 // cleared when SetText or SetObscured is called.
247 void SetObscuredRevealIndex(int index
);
249 // Set whether newline characters should be replaced with newline symbols.
250 void SetReplaceNewlineCharsWithSymbols(bool replace
);
252 // TODO(ckocagil): Multiline text rendering is currently only supported on
253 // Windows. Support other platforms.
254 bool multiline() const { return multiline_
; }
255 void SetMultiline(bool multiline
);
257 // Set the maximum length of the displayed layout text, not the actual text.
258 // A |length| of 0 forgoes a hard limit, but does not guarantee proper
259 // functionality of very long strings. Applies to subsequent SetText calls.
260 // WARNING: Only use this for system limits, it lacks complex text support.
261 void set_truncate_length(size_t length
) { truncate_length_
= length
; }
263 // The layout text will be elided to fit |display_rect| using this behavior.
264 // The layout text may be shortened further by the truncate length.
265 void SetElideBehavior(ElideBehavior elide_behavior
);
266 ElideBehavior
elide_behavior() const { return elide_behavior_
; }
268 const base::string16
& layout_text() const { return layout_text_
; }
270 const Rect
& display_rect() const { return display_rect_
; }
271 void SetDisplayRect(const Rect
& r
);
273 bool background_is_transparent() const { return background_is_transparent_
; }
274 void set_background_is_transparent(bool transparent
) {
275 background_is_transparent_
= transparent
;
278 const SelectionModel
& selection_model() const { return selection_model_
; }
280 const Range
& selection() const { return selection_model_
.selection(); }
282 size_t cursor_position() const { return selection_model_
.caret_pos(); }
283 void SetCursorPosition(size_t position
);
285 // Moves the cursor left or right. Cursor movement is visual, meaning that
286 // left and right are relative to screen, not the directionality of the text.
287 // If |select| is false, the selection start is moved to the same position.
288 void MoveCursor(BreakType break_type
,
289 VisualCursorDirection direction
,
292 // Set the selection_model_ to the value of |selection|.
293 // The selection range is clamped to text().length() if out of range.
294 // Returns true if the cursor position or selection range changed.
295 // If any index in |selection_model| is not a cursorable position (not on a
296 // grapheme boundary), it is a no-op and returns false.
297 bool MoveCursorTo(const SelectionModel
& selection_model
);
299 // Set the selection_model_ based on |range|.
300 // If the |range| start or end is greater than text length, it is modified
301 // to be the text length.
302 // If the |range| start or end is not a cursorable position (not on grapheme
303 // boundary), it is a NO-OP and returns false. Otherwise, returns true.
304 bool SelectRange(const Range
& range
);
306 // Returns true if the local point is over selected text.
307 bool IsPointInSelection(const Point
& point
);
309 // Selects no text, keeping the current cursor position and caret affinity.
310 void ClearSelection();
312 // Select the entire text range. If |reversed| is true, the range will end at
313 // the logical beginning of the text; this generally shows the leading portion
314 // of text that overflows its display area.
315 void SelectAll(bool reversed
);
317 // Selects the word at the current cursor position. If there is a non-empty
318 // selection, the selection bounds are extended to their nearest word
322 const Range
& GetCompositionRange() const;
323 void SetCompositionRange(const Range
& composition_range
);
325 // Set the text color over the entire text or a logical character range.
326 // The |range| should be valid, non-reversed, and within [0, text().length()].
327 void SetColor(SkColor value
);
328 void ApplyColor(SkColor value
, const Range
& range
);
330 // Set various text styles over the entire text or a logical character range.
331 // The respective |style| is applied if |value| is true, or removed if false.
332 // The |range| should be valid, non-reversed, and within [0, text().length()].
333 void SetStyle(TextStyle style
, bool value
);
334 void ApplyStyle(TextStyle style
, bool value
, const Range
& range
);
336 // Returns whether this style is enabled consistently across the entire
338 bool GetStyle(TextStyle style
) const;
340 // Set or get the text directionality mode and get the text direction yielded.
341 void SetDirectionalityMode(DirectionalityMode mode
);
342 DirectionalityMode
directionality_mode() const {
343 return directionality_mode_
;
345 base::i18n::TextDirection
GetTextDirection();
347 // Returns the visual movement direction corresponding to the logical end
348 // of the text, considering only the dominant direction returned by
349 // |GetTextDirection()|, not the direction of a particular run.
350 VisualCursorDirection
GetVisualDirectionOfLogicalEnd();
352 // Returns the size required to display the current string (which is the
353 // wrapped size in multiline mode). The returned size does not include space
354 // reserved for the cursor or the offset text shadows.
355 virtual Size
GetStringSize() = 0;
357 // This is same as GetStringSize except that fractional size is returned.
358 // The default implementation is same as GetStringSize. Certain platforms that
359 // compute the text size as floating-point values, like Mac, will override
361 // See comment in Canvas::GetStringWidthF for its usage.
362 virtual SizeF
GetStringSizeF();
364 // Returns the width of the content (which is the wrapped width in multiline
365 // mode). Reserves room for the cursor if |cursor_enabled_| is true.
366 float GetContentWidth();
368 // Returns the common baseline of the text. The return value is the vertical
369 // offset from the top of |display_rect_| to the text baseline, in pixels.
370 // The baseline is determined from the font list and display rect, and does
371 // not depend on the text.
374 void Draw(Canvas
* canvas
);
376 // Draws a cursor at |position|.
377 void DrawCursor(Canvas
* canvas
, const SelectionModel
& position
);
379 // Gets the SelectionModel from a visual point in local coordinates.
380 virtual SelectionModel
FindCursorPosition(const Point
& point
) = 0;
382 // Returns true if the position is a valid logical index into text(), and is
383 // also a valid grapheme boundary, which may be used as a cursor position.
384 virtual bool IsValidCursorIndex(size_t index
) = 0;
386 // Returns true if the position is a valid logical index into text(). Indices
387 // amid multi-character graphemes are allowed here, unlike IsValidCursorIndex.
388 virtual bool IsValidLogicalIndex(size_t index
);
390 // Get the visual bounds of a cursor at |caret|. These bounds typically
391 // represent a vertical line if |insert_mode| is true. Pass false for
392 // |insert_mode| to retrieve the bounds of the associated glyph. These bounds
393 // are in local coordinates, but may be outside the visible region if the text
394 // is longer than the textfield. Subsequent text, cursor, or bounds changes
395 // may invalidate returned values. Note that |caret| must be placed at
396 // grapheme boundary, i.e. caret.caret_pos() must be a cursorable position.
397 Rect
GetCursorBounds(const SelectionModel
& caret
, bool insert_mode
);
399 // Compute the current cursor bounds, panning the text to show the cursor in
400 // the display rect if necessary. These bounds are in local coordinates.
401 // Subsequent text, cursor, or bounds changes may invalidate returned values.
402 const Rect
& GetUpdatedCursorBounds();
404 // Given an |index| in text(), return the next or previous grapheme boundary
405 // in logical order (i.e. the nearest cursorable index). The return value is
406 // in the range 0 to text().length() inclusive (the input is clamped if it is
407 // out of that range). Always moves by at least one character index unless the
408 // supplied index is already at the boundary of the string.
409 size_t IndexOfAdjacentGrapheme(size_t index
,
410 LogicalCursorDirection direction
);
412 // Return a SelectionModel with the cursor at the current selection's start.
413 // The returned value represents a cursor/caret position without a selection.
414 SelectionModel
GetSelectionModelForSelectionStart();
416 // Sets shadows to drawn with text.
417 void set_shadows(const ShadowValues
& shadows
) { shadows_
= shadows
; }
418 const ShadowValues
& shadows() { return shadows_
; }
420 typedef std::pair
<Font
, Range
> FontSpan
;
421 // For testing purposes, returns which fonts were chosen for which parts of
422 // the text by returning a vector of Font and Range pairs, where each range
423 // specifies the character range for which the corresponding font has been
425 virtual std::vector
<FontSpan
> GetFontSpansForTesting() = 0;
427 // Gets the horizontal bounds (relative to the left of the text, not the view)
428 // of the glyph starting at |index|. If the glyph is RTL then the returned
429 // Range will have is_reversed() true. (This does not return a Rect because a
430 // Rect can't have a negative width.)
431 virtual Range
GetGlyphBounds(size_t index
) = 0;
433 const Vector2d
& GetUpdatedDisplayOffset();
434 void SetDisplayOffset(int horizontal_offset
);
439 const BreakList
<SkColor
>& colors() const { return colors_
; }
440 const std::vector
<BreakList
<bool> >& styles() const { return styles_
; }
442 const std::vector
<internal::Line
>& lines() const { return lines_
; }
443 void set_lines(std::vector
<internal::Line
>* lines
) { lines_
.swap(*lines
); }
445 // Returns the baseline of the current text. The return value depends on
446 // the text and its layout while the return value of GetBaseline() doesn't.
447 // GetAlignmentOffset() takes into account the difference between them.
449 // We'd like a RenderText to show the text always on the same baseline
450 // regardless of the text, so the text does not jump up or down depending
451 // on the text. However, underlying layout engines return different baselines
452 // depending on the text. In general, layout engines determine the minimum
453 // bounding box for the text and return the baseline from the top of the
454 // bounding box. So the baseline changes depending on font metrics used to
457 // For example, suppose there are FontA and FontB and the baseline of FontA
458 // is smaller than the one of FontB. If the text is laid out only with FontA,
459 // then the baseline of FontA may be returned. If the text includes some
460 // characters which are laid out with FontB, then the baseline of FontB may
463 // GetBaseline() returns the fixed baseline regardless of the text.
464 // GetLayoutTextBaseline() returns the baseline determined by the underlying
465 // layout engine, and it changes depending on the text. GetAlignmentOffset()
466 // returns the difference between them.
467 virtual int GetLayoutTextBaseline() = 0;
469 void set_cached_bounds_and_offset_valid(bool valid
) {
470 cached_bounds_and_offset_valid_
= valid
;
473 // Get the selection model that visually neighbors |position| by |break_type|.
474 // The returned value represents a cursor/caret position without a selection.
475 SelectionModel
GetAdjacentSelectionModel(const SelectionModel
& current
,
476 BreakType break_type
,
477 VisualCursorDirection direction
);
479 // Get the selection model visually left/right of |selection| by one grapheme.
480 // The returned value represents a cursor/caret position without a selection.
481 virtual SelectionModel
AdjacentCharSelectionModel(
482 const SelectionModel
& selection
,
483 VisualCursorDirection direction
) = 0;
485 // Get the selection model visually left/right of |selection| by one word.
486 // The returned value represents a cursor/caret position without a selection.
487 virtual SelectionModel
AdjacentWordSelectionModel(
488 const SelectionModel
& selection
,
489 VisualCursorDirection direction
) = 0;
491 // Get the SelectionModels corresponding to visual text ends.
492 // The returned value represents a cursor/caret position without a selection.
493 SelectionModel
EdgeSelectionModel(VisualCursorDirection direction
);
495 // Sets the selection model, the argument is assumed to be valid.
496 virtual void SetSelectionModel(const SelectionModel
& model
);
498 // Get the visual bounds containing the logical substring within the |range|.
499 // If |range| is empty, the result is empty. These bounds could be visually
500 // discontinuous if the substring is split by a LTR/RTL level change.
501 // These bounds are in local coordinates, but may be outside the visible
502 // region if the text is longer than the textfield. Subsequent text, cursor,
503 // or bounds changes may invalidate returned values.
504 virtual std::vector
<Rect
> GetSubstringBounds(const Range
& range
) = 0;
506 // Convert between indices into |text_| and indices into |obscured_text_|,
507 // which differ when the text is obscured. Regardless of whether or not the
508 // text is obscured, the character (code point) offsets always match.
509 virtual size_t TextIndexToLayoutIndex(size_t index
) const = 0;
510 virtual size_t LayoutIndexToTextIndex(size_t index
) const = 0;
512 // Reset the layout to be invalid.
513 virtual void ResetLayout() = 0;
515 // Ensure the text is laid out, lines are computed, and |lines_| is valid.
516 virtual void EnsureLayout() = 0;
519 virtual void DrawVisualText(Canvas
* canvas
) = 0;
521 // Returns the text used for layout, which may be obscured or truncated.
522 const base::string16
& GetLayoutText() const;
524 // Returns layout text positions that are suitable for breaking lines.
525 const BreakList
<size_t>& GetLineBreaks();
527 // Apply (and undo) temporary composition underlines and selection colors.
528 void ApplyCompositionAndSelectionStyles();
529 void UndoCompositionAndSelectionStyles();
531 // Returns the line offset from the origin after applying the text alignment
532 // and the display offset.
533 Vector2d
GetLineOffset(size_t line_number
);
535 // Convert points from the text space to the view space and back. Handles the
536 // display area, display offset, application LTR/RTL mode and multiline.
537 Point
ToTextPoint(const Point
& point
);
538 Point
ToViewPoint(const Point
& point
);
540 // Convert a text space x-coordinate range to rects in view space.
541 std::vector
<Rect
> TextBoundsToViewBounds(const Range
& x
);
543 // Get the alignment, resolving ALIGN_TO_HEAD with the current text direction.
544 HorizontalAlignment
GetCurrentHorizontalAlignment();
546 // Returns the line offset from the origin, accounts for text alignment only.
547 Vector2d
GetAlignmentOffset(size_t line_number
);
549 // Applies fade effects to |renderer|.
550 void ApplyFadeEffects(internal::SkiaTextRenderer
* renderer
);
552 // Applies text shadows to |renderer|.
553 void ApplyTextShadows(internal::SkiaTextRenderer
* renderer
);
555 // A convenience function to check whether the glyph attached to the caret
556 // is within the given range.
557 static bool RangeContainsCaret(const Range
& range
,
559 LogicalCursorDirection caret_affinity
);
562 friend class RenderTextTest
;
563 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, DefaultStyle
);
564 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, SetColorAndStyle
);
565 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, ApplyColorAndStyle
);
566 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, ObscuredText
);
567 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, RevealObscuredText
);
568 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, ElidedText
);
569 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, ElidedObscuredText
);
570 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, TruncatedText
);
571 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, TruncatedObscuredText
);
572 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, GraphemePositions
);
573 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, EdgeSelectionModels
);
574 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, GetTextOffset
);
575 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, GetTextOffsetHorizontalDefaultInRTL
);
576 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, Multiline_MinWidth
);
577 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, Multiline_NormalWidth
);
578 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, Multiline_SufficientWidth
);
579 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, Multiline_Newline
);
580 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, GlyphBounds
);
581 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, HarfBuzz_GlyphBounds
);
582 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
,
583 MoveCursorLeftRight_MeiryoUILigatures
);
584 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, Win_LogicalClusters
);
585 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, SameFontForParentheses
);
586 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, BreakRunsByUnicodeBlocks
);
587 FRIEND_TEST_ALL_PREFIXES(RenderTextTest
, PangoAttributes
);
589 // Creates a platform-specific RenderText instance.
590 static RenderText
* CreateNativeInstance();
592 // Set the cursor to |position|, with the caret trailing the previous
593 // grapheme, or if there is no previous grapheme, leading the cursor position.
594 // If |select| is false, the selection start is moved to the same position.
595 // If the |position| is not a cursorable position (not on grapheme boundary),
597 void MoveCursorTo(size_t position
, bool select
);
599 // Updates |layout_text_| if the text is obscured or truncated.
600 void UpdateLayoutText();
602 // Elides |text| as needed to fit in the |available_width| using |behavior|.
603 base::string16
Elide(const base::string16
& text
,
604 float available_width
,
605 ElideBehavior behavior
);
607 // Elides |email| as needed to fit the |available_width|.
608 base::string16
ElideEmail(const base::string16
& email
, float available_width
);
610 // Update the cached bounds and display offset to ensure that the current
611 // cursor is within the visible display area.
612 void UpdateCachedBoundsAndOffset();
614 // Draw the selection.
615 void DrawSelection(Canvas
* canvas
);
617 // Logical UTF-16 string data to be drawn.
618 base::string16 text_
;
620 // Horizontal alignment of the text with respect to |display_rect_|. The
621 // default is to align left if the application UI is LTR and right if RTL.
622 HorizontalAlignment horizontal_alignment_
;
624 // The text directionality mode, defaults to DIRECTIONALITY_FROM_TEXT.
625 DirectionalityMode directionality_mode_
;
627 // The cached text direction, potentially computed from the text or UI locale.
628 // Use GetTextDirection(), do not use this potentially invalid value directly!
629 base::i18n::TextDirection text_direction_
;
631 // A list of fonts used to render |text_|.
634 // Logical selection range and visual cursor position.
635 SelectionModel selection_model_
;
637 // The cached cursor bounds; get these bounds with GetUpdatedCursorBounds.
640 // Specifies whether the cursor is enabled. If disabled, no space is reserved
641 // for the cursor when positioning text.
642 bool cursor_enabled_
;
644 // The cursor visibility and insert mode.
645 bool cursor_visible_
;
648 // The color used for the cursor.
649 SkColor cursor_color_
;
651 // The color used for drawing selected text.
652 SkColor selection_color_
;
654 // The background color used for drawing the selection when focused.
655 SkColor selection_background_focused_color_
;
657 // The focus state of the text.
660 // Composition text range.
661 Range composition_range_
;
663 // Color and style breaks, used to color and stylize ranges of text.
664 // BreakList positions are stored with text indices, not layout indices.
665 // TODO(msw): Expand to support cursor, selection, background, etc. colors.
666 BreakList
<SkColor
> colors_
;
667 std::vector
<BreakList
<bool> > styles_
;
669 // Breaks saved without temporary composition and selection styling.
670 BreakList
<SkColor
> saved_colors_
;
671 BreakList
<bool> saved_underlines_
;
672 bool composition_and_selection_styles_applied_
;
674 // A flag to obscure actual text with asterisks for password fields.
676 // The index at which the char should be revealed in the obscured text.
677 int obscured_reveal_index_
;
679 // The maximum length of text to display, 0 forgoes a hard limit.
680 size_t truncate_length_
;
682 // The behavior for eliding, fading, or truncating.
683 ElideBehavior elide_behavior_
;
685 // The obscured and/or truncated text that will be displayed.
686 base::string16 layout_text_
;
688 // Whether newline characters should be replaced with newline symbols.
689 bool replace_newline_chars_with_symbols_
;
691 // Whether the text should be broken into multiple lines. Uses the width of
692 // |display_rect_| as the width cap.
695 // Is the background transparent (either partially or fully)?
696 bool background_is_transparent_
;
698 // The local display area for rendering the text.
701 // Flag to work around a Skia bug with the PDF path (http://crbug.com/133548)
702 // that results in incorrect clipping when drawing to the document margins.
703 // This field allows disabling clipping to work around the issue.
704 // TODO(asvitkine): Remove this when the underlying Skia bug is fixed.
705 bool clip_to_display_rect_
;
707 // The offset for the text to be drawn, relative to the display area.
708 // Get this point with GetUpdatedDisplayOffset (or risk using a stale value).
709 Vector2d display_offset_
;
711 // The baseline of the text. This is determined from the height of the
712 // display area and the cap height of the font list so the text is vertically
716 // The cached bounds and offset are invalidated by changes to the cursor,
717 // selection, font, and other operations that adjust the visible text bounds.
718 bool cached_bounds_and_offset_valid_
;
720 // Text shadows to be drawn.
721 ShadowValues shadows_
;
723 // A list of valid layout text line break positions.
724 BreakList
<size_t> line_breaks_
;
726 // Lines computed by EnsureLayout. These should be invalidated with
727 // ResetLayout and on |display_rect_| changes.
728 std::vector
<internal::Line
> lines_
;
730 DISALLOW_COPY_AND_ASSIGN(RenderText
);
735 #endif // UI_GFX_RENDER_TEXT_H_