Add support for transformed, stoked, shadowed, filled text. We do this by...

webkit/port/platform/graphics/chromium/FontChromiumWin.cpp

 /*
  * Copyright (C) 2006, 2007 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
 #include "config.h"
 #include <windows.h>
 
+#include "AffineTransform.h"
 #include "ChromiumBridge.h"
 #include "Font.h"
 #include "FontFallbackList.h"
 #include "GlyphBuffer.h"
 #include "PlatformContextSkia.h"
 #include "SimpleFontData.h"
+#include "SkiaFontWin.h"
 #include "SkiaUtils.h"
 #include "UniscribeHelperTextRun.h"
 
 #include "skia/ext/platform_canvas_win.h"
 #include "skia/ext/skia_utils_win.h"  // TODO(brettw) remove this dependency.
 
 namespace WebCore {
 
+static bool windowsCanHandleTextDrawing(GraphicsContext* context)
+{
+    // Check for non-translation transforms.
+    const AffineTransform& xform = context->getCTM();
+    if (xform.b() != 0 ||  // Y skew
+        xform.c() != 0 ||  // X skew
+        xform.a() != 1.0 ||  // X scale
+        xform.d() != 1.0)
+        return false;
+
+    // Check for stroke effects.
+    if (context->platformContext()->getTextDrawingMode() != cTextFill)
+        return false;
+
+    // Check for shadow effects.
+    if (context->platformContext()->getDrawLooper())

[M-A Ruel, 2008/12/15 19:54:51]

shadow should be ignored when printing on Windows. :/

+        return false;
+
+    return true;
+}
+
+static bool PaintSkiaText(PlatformContextSkia* platformContext,
+                          HFONT hfont,
+                          int numGlyphs,
+                          const WORD* glyphs,
+                          const int* advances,
+                          const SkPoint& origin)
+{
+    int textMode = platformContext->getTextDrawingMode();
+
+    // Filling (if necessary). This is the common case.
+    SkPaint paint;
+    platformContext->setupPaintForFilling(&paint);
+    paint.setFlags(SkPaint::kAntiAlias_Flag);
+    bool didFill = false;
+    if ((textMode & cTextFill) && SkColorGetA(paint.getColor())) {
+        if (!SkiaDrawText(hfont, platformContext->canvas(), origin, &paint,
+                          &glyphs[0], &advances[0], numGlyphs))
+            return false;
+        didFill = true;
+    }
+
+    // Stroking on top (if necessary).
+    if ((textMode & WebCore::cTextStroke) &&
+        platformContext->getStrokeStyle() != NoStroke &&
+        platformContext->getStrokeThickness() > 0) {
+
+        paint.reset();
+        platformContext->setupPaintForStroking(&paint, NULL, 0);
+        paint.setFlags(SkPaint::kAntiAlias_Flag);
+        if (didFill) {
+            // If there is a shadow and we filled above, there will already be
+            // a shadow. We don't want to draw it again or it will be too dark
+            // and it will go on top of the fill.
+            //
+            // Note that this isn't strictly correct, since the stroke could be
+            // very thick and the shadow wouldn't account for this. The "right"
+            // thing would be to draw to a new layer and then draw that layer
+            // with a shadow. But this is a lot of extra work for something
+            // that isn't normally an issue.
+            paint.setLooper(NULL)->safeUnref();
+        }
+
+        if (!SkiaDrawText(hfont, platformContext->canvas(), origin,
+                          &paint, &glyphs[0], &advances[0], numGlyphs))
+            return false;
+    }
+    return true;
+}
+
 void Font::drawGlyphs(GraphicsContext* graphicsContext,
                       const SimpleFontData* font,
                       const GlyphBuffer& glyphBuffer,
                       int from,
                       int numGlyphs,
                       const FloatPoint& point) const
 {
     PlatformGraphicsContext* context = graphicsContext->platformContext();
 
     // Max buffer length passed to the underlying windows API.
@@ skipping 22 matching lines @@
     // Windows needs the characters and the advances in nice contiguous
     // buffers, which we build here.
     Vector<WORD, kDefaultBufferLength> glyphs;
     Vector<int, kDefaultBufferLength> advances;
 
     // Compute the coordinate. The 'origin' represents the baseline, so we need
     // to move it up to the top of the bounding square.
     int x = static_cast<int>(point.x());
     int lineTop = static_cast<int>(point.y()) - font->ascent();
 
+    bool canUseGDI = windowsCanHandleTextDrawing(graphicsContext);

[M-A Ruel, 2008/12/15 19:54:51]

I wonder if canUseGDI should always be true when printing.

+
     // We draw the glyphs in chunks to avoid having to do a heap allocation for
     // the arrays of characters and advances. Since ExtTextOut is the
     // lowest-level text output function on Windows, there should be little
     // penalty for splitting up the text. On the other hand, the buffer cannot
     // be bigger than 4094 or the function will fail.
     int glyphIndex = 0;
     while (glyphIndex < numGlyphs) {
         // how many chars will be in this chunk?
         int curLen = std::min(kMaxBufferLength, numGlyphs - glyphIndex);
 
         glyphs.resize(curLen);
         advances.resize(curLen);
 
         int curWidth = 0;
         for (int i = 0; i < curLen; ++i, ++glyphIndex) {
             glyphs[i] = glyphBuffer.glyphAt(from + glyphIndex);
             advances[i] =
                 static_cast<int>(glyphBuffer.advanceAt(from + glyphIndex));
             curWidth += advances[i];
         }
 
         bool success = false;
         for (int executions = 0; executions < 2; ++executions) {
-            success = !!ExtTextOut(hdc, x, lineTop, ETO_GLYPH_INDEX, NULL,
-                                   reinterpret_cast<const wchar_t*>(&glyphs[0]),
-                                   curLen,
-                                   &advances[0]);
+            if (canUseGDI) {
+                success = !!ExtTextOut(hdc, x, lineTop, ETO_GLYPH_INDEX, NULL,
+                                       reinterpret_cast<const wchar_t*>(&glyphs[0]),
+                                       curLen, &advances[0]);
+            } else {
+                // Skia's text draing origin is the baseline, like WebKit, not

[M-A Ruel, 2008/12/15 19:54:51]

drawing

+                // the top, like Windows.
+                SkPoint origin = { x, point.y() };
+                success = PaintSkiaText(context,
+                                        font->platformData().hfont(), numGlyphs,
+                                        reinterpret_cast<const WORD*>(&glyphs[0]),

[M-A Ruel, 2008/12/15 19:54:51]

80 cols, if you care.

+                                        &advances[0], origin);
+            }
 
             if (!success && executions == 0) {
                 // Ask the browser to load the font for us and retry.
                 ChromiumBridge::ensureFontLoaded(font->platformData().hfont());
                 continue;
             }
             break;
         }
 
         ASSERT(success);
@@ skipping 74 matching lines @@
     int char_index = state.XToCharacter(x);
 
     // XToCharacter will return -1 if the position is before the first
     // character (we get called like this sometimes).
     if (char_index < 0)
       char_index = 0;
     return char_index;
 }
 
 } // namespace WebCore