Ellide by fading

ui/gfx/canvas_skia_linux.cc

 // Copyright (c) 2011 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.
 
 #include "ui/gfx/canvas_skia.h"
 
 #include <cairo/cairo.h>
 #include <gtk/gtk.h>
 #include <pango/pango.h>
 #include <pango/pangocairo.h>
 
+#include "base/i18n/rtl.h"
 #include "base/logging.h"
+#include "base/stringprintf.h"

[oshima, 2011/05/31 23:56:10]

you dont need this anymore? (guessing you added for debugging :)

 #include "base/utf_string_conversions.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/gtk_util.h"
 #include "ui/gfx/platform_font_gtk.h"
 #include "ui/gfx/rect.h"
 
 namespace {
 
 const gunichar kAcceleratorChar = '&';
 
+// Multiply by the text height to determine how much text should be faded
+// when elliding.
+const double kFadeWidthFactor = 1.5;
+
+// End state of the elliding fade.
+const double kKFadeFinalAlpha = 0.15;
+
 // Font settings that we initialize once and then use when drawing text in
 // DrawStringInt().
 static cairo_font_options_t* cairo_font_options = NULL;
 
 // Update |cairo_font_options| based on GtkSettings, allocating it if needed.
 static void UpdateCairoFontOptions() {
   if (!cairo_font_options)
     cairo_font_options = cairo_font_options_create();
 
   GtkSettings* gtk_settings = gtk_settings_get_default();
@@ skipping 68 matching lines @@
   pango_cairo_context_set_font_options(
       pango_layout_get_context(layout), cairo_font_options);
 
   // Callers of DrawStringInt handle RTL layout themselves, so tell pango to not
   // scope out RTL characters.
   pango_layout_set_auto_dir(layout, FALSE);
 
   if (width > 0)
     pango_layout_set_width(layout, width * PANGO_SCALE);
 
-  if (flags & gfx::Canvas::NO_ELLIPSIS) {
-    pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);
-  } else {
-    pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END);
-  }
-
   if (flags & gfx::Canvas::TEXT_ALIGN_CENTER) {
     pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
   } else if (flags & gfx::Canvas::TEXT_ALIGN_RIGHT) {
     pango_layout_set_alignment(layout, PANGO_ALIGN_RIGHT);
   }
 
-  if (flags & gfx::Canvas::MULTI_LINE) {
-    pango_layout_set_wrap(layout,
-        (flags & gfx::Canvas::CHARACTER_BREAK) ?
-            PANGO_WRAP_WORD_CHAR : PANGO_WRAP_WORD);
+  if (flags & gfx::Canvas::NO_ELLIPSIS) {
+    pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);
+    if (flags & gfx::Canvas::MULTI_LINE) {
+      pango_layout_set_wrap(layout,
+          (flags & gfx::Canvas::CHARACTER_BREAK) ?
+              PANGO_WRAP_WORD_CHAR : PANGO_WRAP_WORD);
+    }
+  } else if (base::i18n::IsRTL()){
+    pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END);
+  } else {
+    // Fading the text will be handled in the draw operation.
+    // that the text is only on one line.
+    pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);
+    pango_layout_set_width(layout, -1);

[Dmitry Polukhin, 2011/06/08 12:50:35]

Setting width to -1 breaks TEXT_ALIGN_CENTER. See
http://code.google.com/p/chromium-os/issues/detail?id=16286. I can add
NO_ELLIPSIS but it looks broken to me that TEXT_ALIGN_CENTER doesn't work
without NO_ELLIPSIS. Moreover it looks like later in DrawStringContext::Draw you
have condition if text fits to bounds. What about removing this line?

[Dmitry Polukhin, 2011/06/08 13:09:48]

It looks like we can't disable wrap without setting width to -1. But still
requirement to use TEXT_ALIGN_CENTER only with NO_ELLIPSIS in LTR mode looks odd
to me.

   }
 
   // Set the resolution to match that used by Gtk. If we don't set the
   // resolution and the resolution differs from the default, Gtk and Chrome end
   // up drawing at different sizes.
   double resolution = gfx::GetPangoResolution();
   if (resolution > 0) {
     pango_cairo_context_set_resolution(pango_layout_get_context(layout),
                                        resolution);
   }
@@ skipping 109 matching lines @@
   }
   cairo_restore(cr_);
 
   skia::EndPlatformPaint(canvas_);
 
   g_object_unref(layout_);
   // NOTE: BeginPlatformPaint returned its surface, we shouldn't destroy it.
 }
 
 void DrawStringContext::Draw(const SkColor& text_color) {
-  cairo_set_source_rgba(cr_,
-                        SkColorGetR(text_color) / 255.0,
-                        SkColorGetG(text_color) / 255.0,
-                        SkColorGetB(text_color) / 255.0,
-                        SkColorGetA(text_color) / 255.0);
-  cairo_move_to(cr_, text_x_, text_y_);
-  pango_cairo_show_layout(cr_, layout_);
+  double r = SkColorGetR(text_color) / 255.0,
+         g = SkColorGetG(text_color) / 255.0,
+         b = SkColorGetB(text_color) / 255.0,
+         a = SkColorGetA(text_color) / 255.0;
+
+  if (base::i18n::IsRTL() ||
+      (flags_ & gfx::Canvas::NO_ELLIPSIS) ||
+      text_width_ <= bounds_.width()) {
+    cairo_set_source_rgba(cr_, r, g, b, a);
+    cairo_move_to(cr_, text_x_, text_y_);
+    pango_cairo_show_layout(cr_, layout_);
+  } else {
+    // Fade to gray to ellide.
+    int fade_width = static_cast<double>(text_height_) * kFadeWidthFactor;
+    if (fade_width > (bounds_.width() / 2)) {
+      // Don't fade more than half the text.
+      fade_width = bounds_.width() / 2;
+    }
+    int fade_x = bounds_.x() + bounds_.width() - fade_width;
+
+    // Draw left part of text, clipped at fade_width.
+    cairo_save(cr_);
+    cairo_rectangle(

[oshima, 2011/05/31 23:56:10]

indent at "(" ?

+        cr_,
+        bounds_.x(),
+        bounds_.y(),
+        bounds_.width() - fade_width,
+        bounds_.height());
+    cairo_clip(cr_);
+    cairo_set_source_rgba(cr_, r, g, b, a);
+    cairo_move_to(cr_, text_x_, text_y_);
+    pango_cairo_show_layout(cr_, layout_);
+    cairo_restore(cr_);
+
+    // Clip to the left of fade_width.
+    cairo_save(cr_);
+    cairo_rectangle(cr_, fade_x, bounds_.y(), fade_width, bounds_.height());
+    cairo_clip(cr_);
+
+    // Create clip for text.
+    cairo_move_to(cr_, text_x_, text_y_);
+    pango_cairo_layout_path(cr_, layout_);
+    cairo_clip(cr_);
+
+    // Create alpha fade pattern.
+    cairo_pattern_t* pattern = cairo_pattern_create_linear(
+        fade_x, bounds_.y(), bounds_.x() + bounds_.width(), bounds_.y());
+    cairo_pattern_add_color_stop_rgba(pattern, 0, r, g, b, a);
+    cairo_pattern_add_color_stop_rgba(pattern, 1, r, g, b, kKFadeFinalAlpha);
+
+    // Draw pattern, clipped by text.
+    cairo_set_source(cr_, pattern);
+    cairo_fill(cr_);
+    cairo_paint(cr_);
+    cairo_pattern_destroy(pattern);
+
+    cairo_restore(cr_);
+  }
 }
 
 void DrawStringContext::DrawWithHalo(const SkColor& text_color,
                                      const SkColor& halo_color) {
   gfx::CanvasSkia text_canvas(bounds_.width() + 2, bounds_.height() + 2, false);
   text_canvas.FillRectInt(static_cast<SkColor>(0),
       0, 0, bounds_.width() + 2, bounds_.height() + 2);
 
   {
     skia::ScopedPlatformPaint scoped_platform_paint(&text_canvas);
@@ skipping 114 matching lines @@
   gdk_cairo_set_source_pixbuf(cr, pixbuf, x, y);
   cairo_paint(cr);
 }
 
 ui::TextureID CanvasSkia::GetTextureID() {
   // TODO(wjmaclean)
   return 0;
 }
 
 }  // namespace gfx