Replace StyleRange with BreakList; update RenderText, etc.

ui/gfx/render_text.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef UI_GFX_RENDER_TEXT_H_
 #define UI_GFX_RENDER_TEXT_H_
 
 #include <algorithm>
 #include <cstring>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/i18n/rtl.h"
 #include "base/string16.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "ui/base/range/range.h"
+#include "ui/gfx/break_list.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/selection_model.h"
 #include "ui/gfx/shadow_value.h"
 #include "ui/gfx/text_constants.h"
 #include "ui/gfx/vector2d.h"
 
 class SkCanvas;
 class SkDrawLooper;
 struct SkPoint;
 class SkShader;
 class SkTypeface;
 
 namespace gfx {
 
 class Canvas;
 class Font;
 class RenderTextTest;
-struct StyleRange;
 
 namespace internal {
 
 // Internal helper class used by derived classes to draw text through Skia.
 class SkiaTextRenderer {
  public:
   explicit SkiaTextRenderer(Canvas* canvas);
   ~SkiaTextRenderer();
 
   void SetDrawLooper(SkDrawLooper* draw_looper);
   void SetFontSmoothingSettings(bool enable_smoothing, bool enable_lcd_text);
   void SetTypeface(SkTypeface* typeface);
   void SetTextSize(SkScalar size);
   void SetFontFamilyWithStyle(const std::string& family, int font_style);
   void SetForegroundColor(SkColor foreground);
   void SetShader(SkShader* shader, const Rect& bounds);
   // Sets underline metrics to use if the text will be drawn with an underline.
   // If not set, default values based on the size of the text will be used. The
   // two metrics must be set together.
   void SetUnderlineMetrics(SkScalar thickness, SkScalar position);
   void DrawSelection(const std::vector<Rect>& selection, SkColor color);
   void DrawPosText(const SkPoint* pos,
                    const uint16* glyphs,
                    size_t glyph_count);
-  void DrawDecorations(int x, int y, int width, const StyleRange& style);
+  // Draw underline and strike-through text decorations.
+  // Based on |SkCanvas::DrawTextDecorations()| and constants from:
+  //   third_party/skia/src/core/SkTextFormatParams.h
+  void DrawDecorations(int x, int y, int width, bool underline, bool strike,
+                       bool diagonal_strike);
+  void DrawUnderline(int x, int y, int width);
+  void DrawStrike(int x, int y, int width) const;
+  void DrawDiagonalStrike(int x, int y, int width) const;
 
  private:
   SkCanvas* canvas_skia_;
   bool started_drawing_;
   SkPaint paint_;
   SkRect bounds_;
   SkRefPtr<SkShader> deferred_fade_shader_;
   SkScalar underline_thickness_;
   SkScalar underline_position_;
 
   DISALLOW_COPY_AND_ASSIGN(SkiaTextRenderer);
 };
 
+// Internal helper class used by derived classes to iterate colors and styles.
+class StyleIterator {
+ public:
+  StyleIterator(const BreakList<SkColor>& colors,
+                const std::vector<BreakList<bool> >& styles);
+  ~StyleIterator();
+
+  // Get the colors and styles at the current iterator position.
+  SkColor color() const { return color_->second; }
+  bool style(TextStyle s) const { return style_[s]->second; }
+
+  // Get the intersecting range of the current iterator set.
+  ui::Range GetRange() const;
+
+  // Update the iterator to point to colors and styles applicable at |position|.
+  void UpdatePosition(size_t position);
+
+ private:
+  BreakList<SkColor> colors_;
+  std::vector<BreakList<bool> > styles_;
+
+  BreakList<SkColor>::const_iterator color_;
+  std::vector<BreakList<bool>::const_iterator> style_;
+
+  DISALLOW_COPY_AND_ASSIGN(StyleIterator);
+};
+
 }  // namespace internal
 
-// A visual style applicable to a range of text.
-struct UI_EXPORT StyleRange {
-  StyleRange();
-
-  SkColor foreground;
-  // A gfx::Font::FontStyle flag to specify bold and italic styles.
-  int font_style;
-  bool strike;
-  bool diagonal_strike;
-  bool underline;
-  ui::Range range;
-};
-
-typedef std::vector<StyleRange> StyleRanges;
-
 // RenderText represents an abstract model of styled text and its corresponding
 // visual layout. Support is built in for a cursor, a selection, simple styling,
 // complex scripts, and bi-directional text. Implementations provide mechanisms
 // for rendering and translation between logical and visual data.
 class UI_EXPORT RenderText {
  public:
   virtual ~RenderText();
 
   // Creates a platform-specific RenderText instance.
   static RenderText* CreateInstance();
@@ skipping 44 matching lines @@
   void set_selection_background_unfocused_color(SkColor color) {
     selection_background_unfocused_color_ = color;
   }
 
   bool focused() const { return focused_; }
   void set_focused(bool focused) { focused_ = focused; }
 
   bool clip_to_display_rect() const { return clip_to_display_rect_; }
   void set_clip_to_display_rect(bool clip) { clip_to_display_rect_ = clip; }
 
-  const StyleRange& default_style() const { return default_style_; }
-  void set_default_style(const StyleRange& style) { default_style_ = style; }
-
   // In an obscured (password) field, all text is drawn as asterisks or bullets.
   bool obscured() const { return obscured_; }
   void SetObscured(bool obscured);
 
   const Rect& display_rect() const { return display_rect_; }
   void SetDisplayRect(const Rect& r);
 
   void set_fade_head(bool fade_head) { fade_head_ = fade_head; }
   bool fade_head() const { return fade_head_; }
   void set_fade_tail(bool fade_tail) { fade_tail_ = fade_tail; }
@@ skipping 47 matching lines @@
   // the logical beginning of the text; this generally shows the leading portion
   // of text that overflows its display area.
   void SelectAll(bool reversed);
 
   // Selects the word at the current cursor position.
   void SelectWord();
 
   const ui::Range& GetCompositionRange() const;
   void SetCompositionRange(const ui::Range& composition_range);
 
-  // Apply |style_range| to the internal style model.
-  void ApplyStyleRange(const StyleRange& style_range);
+  // Set the text color over the entire text or a logical character range.
+  // The |range| should be valid, non-reversed, and within [0, text().length()].
+  void SetColor(SkColor value);
+  void ApplyColor(SkColor value, const ui::Range& range);
 
-  // Apply |default_style_| over the entire text range.
-  void ApplyDefaultStyle();
+  // Set various text styles over the entire text or a logical character range.
+  // The respective |style| is applied if |value| is true, or removed if false.
+  // The |range| should be valid, non-reversed, and within [0, text().length()].
+  void SetStyle(TextStyle style, bool value);
+  void ApplyStyle(TextStyle style, bool value, const ui::Range& range);
 
   // Set the text directionality mode and get the text direction yielded.
   void SetDirectionalityMode(DirectionalityMode mode);
   base::i18n::TextDirection GetTextDirection();
 
   // Returns the visual movement direction corresponding to the logical end
   // of the text, considering only the dominant direction returned by
   // |GetTextDirection()|, not the direction of a particular run.
   VisualCursorDirection GetVisualDirectionOfLogicalEnd();
 
@@ skipping 43 matching lines @@
   typedef std::pair<Font, ui::Range> FontSpan;
   // For testing purposes, returns which fonts were chosen for which parts of
   // the text by returning a vector of Font and Range pairs, where each range
   // specifies the character range for which the corresponding font has been
   // chosen.
   virtual std::vector<FontSpan> GetFontSpansForTesting() = 0;
 
  protected:
   RenderText();
 
+  const BreakList<SkColor>& colors() const { return colors_; }
+  const std::vector<BreakList<bool> >& styles() const { return styles_; }
+
   const Vector2d& GetUpdatedDisplayOffset();
 
   void set_cached_bounds_and_offset_valid(bool valid) {
     cached_bounds_and_offset_valid_ = valid;
   }
 
-  const StyleRanges& style_ranges() const { return style_ranges_; }
-
   // Get the selection model that visually neighbors |position| by |break_type|.
   // The returned value represents a cursor/caret position without a selection.
   SelectionModel GetAdjacentSelectionModel(const SelectionModel& current,
                                            BreakType break_type,
                                            VisualCursorDirection direction);
 
   // Get the selection model visually left/right of |selection| by one grapheme.
   // The returned value represents a cursor/caret position without a selection.
   virtual SelectionModel AdjacentCharSelectionModel(
       const SelectionModel& selection,
@@ skipping 41 matching lines @@
 
   // Ensure the text is laid out.
   virtual void EnsureLayout() = 0;
 
   // Draw the text.
   virtual void DrawVisualText(Canvas* canvas) = 0;
 
   // Returns the text used for layout, which may be |obscured_text_|.
   const string16& GetLayoutText() const;
 
-  // Apply composition style (underline) to composition range and selection
-  // style (foreground) to selection range.
-  void ApplyCompositionAndSelectionStyles(StyleRanges* style_ranges);
+  // Apply (and undo) temporary composition underlines and selection colors.
+  void ApplyCompositionAndSelectionStyles();
+  void UndoCompositionAndSelectionStyles();
 
   // Returns the text offset from the origin after applying text alignment and
   // display offset.
   Vector2d GetTextOffset();
 
   // Convert points from the text space to the view space and back.
   // Handles the display area, display offset, and the application LTR/RTL mode.
   Point ToTextPoint(const Point& point);
   Point ToViewPoint(const Point& point);
 
@@ skipping 15 matching lines @@
   void ApplyTextShadows(internal::SkiaTextRenderer* renderer);
 
   // A convenience function to check whether the glyph attached to the caret
   // is within the given range.
   static bool RangeContainsCaret(const ui::Range& range,
                                  size_t caret_pos,
                                  LogicalCursorDirection caret_affinity);
 
  private:
   friend class RenderTextTest;
-
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, DefaultStyle);
-  FRIEND_TEST_ALL_PREFIXES(RenderTextTest, CustomDefaultStyle);
-  FRIEND_TEST_ALL_PREFIXES(RenderTextTest, ApplyStyleRange);
-  FRIEND_TEST_ALL_PREFIXES(RenderTextTest, StyleRangesAdjust);
+  FRIEND_TEST_ALL_PREFIXES(RenderTextTest, SetColorAndStyle);
+  FRIEND_TEST_ALL_PREFIXES(RenderTextTest, ApplyColorAndStyle);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, ObscuredText);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, GraphemePositions);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, EdgeSelectionModels);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, OriginForDrawing);
 
   // Set the cursor to |position|, with the caret trailing the previous
   // grapheme, or if there is no previous grapheme, leading the cursor position.
   // If |select| is false, the selection start is moved to the same position.
   // If the |position| is not a cursorable position (not on grapheme boundary),
   // it is a NO-OP.
@@ skipping 51 matching lines @@
 
   // The background color used for drawing the selection when not focused.
   SkColor selection_background_unfocused_color_;
 
   // The focus state of the text.
   bool focused_;
 
   // Composition text range.
   ui::Range composition_range_;
 
-  // List of style ranges. Elements in the list never overlap each other.
-  StyleRanges style_ranges_;
-  // The default text style.
-  StyleRange default_style_;
+  // Color and style breaks, used to color and stylize ranges of text.

[Alexei Svitkine (slow), 2013/01/31 16:33:34]

Mention that these BreakLists use text indexes (and not layout indexes).

[msw, 2013/01/31 20:27:39]

Done.

+  // TODO(msw): Expand to support cursor, selection, background, etc. colors.
+  BreakList<SkColor> colors_;
+  std::vector<BreakList<bool> > styles_;
+
+  // Breaks saved without temporary composition and selection styling.
+  BreakList<SkColor> saved_colors_;
+  BreakList<bool> saved_underlines_;
+  bool composition_and_selection_styles_applied_;
 
   // A flag and the text to display for obscured (password) fields.
   // Asterisks are used instead of the actual text glyphs when true.
   bool obscured_;
   string16 obscured_text_;
 
   // Fade text head and/or tail, if text doesn't fit into |display_rect_|.
   bool fade_head_;
   bool fade_tail_;
 
@@ skipping 19 matching lines @@
 
   // Text shadows to be drawn.
   ShadowValues text_shadows_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderText);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_RENDER_TEXT_H_