RenderText API Outline.

ui/gfx/canvas_skia_win.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 <limits>
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/win/scoped_gdi_object.h"
 #include "skia/ext/bitmap_platform_device.h"
 #include "skia/ext/skia_utils_win.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/rect.h"
+#include "ui/gfx/render_text.h"
 
 namespace {
 
 static inline int Round(double x) {
   // Why oh why is this not in a standard header?
   return static_cast<int>(floor(x + 0.5));
 }
 
 // We make sure that LTR text we draw in an RTL context is modified
 // appropriately to make sure it maintains it LTR orientation.
@@ skipping 344 matching lines @@
 }
 
 void CanvasSkia::DrawStringInt(const string16& text,
                                const gfx::Font& font,
                                const SkColor& color,
                                int x, int y, int w, int h,
                                int flags) {
   DrawStringInt(text, font.GetNativeFont(), color, x, y, w, h, flags);
 }
 
+// TODO(msw): Copied from another DrawStringInt. Dig in, understand, and unify.
+void CanvasSkia::DrawStringInt(const gfx::RenderText& render_text) {
+  SkRect fclip;
+  if (!getClipBounds(&fclip))
+    return;
+  const gfx::Rect& r = render_text.get_display_rect();
+  RECT text_bounds = { r.x(), r.y(), r.x() + r.width(), r.y() + r.height() };
+  SkIRect clip;
+  fclip.round(&clip);
+  if (!clip.intersect(skia::RECTToSkIRect(text_bounds)))
+    return;
+
+  // TODO(msw): Necessary with Uniscribe?
+  // Clamp the max amount of text we'll draw to 32K.  There seem to be bugs in
+  // DrawText() if you e.g. ask it to character-break a no-whitespace string of
+  // length > 43680 (for which it draws nothing), and since we clamped to 2K in
+  // SizeStringInt() we're unlikely to be able to display this much anyway.
+  const int kMaxStringLength = 32768 - 1;  // So the trailing \0 fits in 32K.
+  string16 clamped_string(render_text.text().substr(0, kMaxStringLength));
+
+  HDC dc;
+  {
+    // TODO(msw): Fix.
+    skia::ScopedPlatformPaint scoped_platform_paint(this);
+    dc = scoped_platform_paint.GetPlatformSurface();
+    SetBkMode(dc, TRANSPARENT);
+    //int f = ComputeFormatFlags(flags, clamped_string);
+    //DoDrawText(dc, clamped_string, &text_bounds, f);
+    render_text.Draw(dc);
+  }
+
+  // TODO(msw): Necessary with Uniscribe?
+  // Windows will have cleared the alpha channel of the text we drew. Assume
+  // we're drawing to an opaque surface, or at least the text rect area is
+  // opaque.
+  skia::MakeOpaque(this, clip.fLeft, clip.fTop, clip.width(),
+                   clip.height());
+}
+
 // Checks each pixel immediately adjacent to the given pixel in the bitmap. If
 // any of them are not the halo color, returns true. This defines the halo of
 // pixels that will appear around the text. Note that we have to check each
 // pixel against both the halo color and transparent since DrawStringWithHalo
 // will modify the bitmap as it goes, and clears pixels shouldn't count as
 // changed.
 static bool pixelShouldGetHalo(const SkBitmap& bitmap,
                                int x, int y,
                                SkColor halo_color) {
   if (x > 0 &&
@@ skipping 185 matching lines @@
               solid_part.width(), solid_part.height());
   DrawStringInt(text, font, color,
                 text_rect.x(), text_rect.y(),
                 text_rect.width(), text_rect.height(),
                 flags);
   restore();
   restore();
 }
 
 }  // namespace gfx