Home | History | Annotate | Download | only in ext
      1 // Copyright (c) 2011 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.
      4 
      5 #ifndef SKIA_EXT_VECTOR_PLATFORM_DEVICE_EMF_WIN_H_
      6 #define SKIA_EXT_VECTOR_PLATFORM_DEVICE_EMF_WIN_H_
      7 
      8 #include "base/basictypes.h"
      9 #include "base/compiler_specific.h"
     10 #include "skia/ext/platform_device.h"
     11 #include "third_party/skia/include/core/SkMatrix.h"
     12 #include "third_party/skia/include/core/SkRegion.h"
     13 
     14 namespace skia {
     15 
     16 // A device is basically a wrapper around SkBitmap that provides a surface for
     17 // SkCanvas to draw into. This specific device is not not backed by a surface
     18 // and is thus unreadable. This is because the backend is completely vectorial.
     19 // This device is a simple wrapper over a Windows device context (HDC) handle.
     20 // TODO(robertphillips): Once Skia's SkBaseDevice is refactored to remove
     21 // the bitmap-specific entry points, this class should derive from it.
     22 class VectorPlatformDeviceEmf : public SkBitmapDevice, public PlatformDevice {
     23  public:
     24   SK_API static SkBaseDevice* CreateDevice(int width, int height, bool isOpaque,
     25                                            HANDLE shared_section);
     26 
     27   // Factory function. The DC is kept as the output context.
     28   static SkBaseDevice* create(HDC dc, int width, int height);
     29 
     30   VectorPlatformDeviceEmf(HDC dc, const SkBitmap& bitmap);
     31   virtual ~VectorPlatformDeviceEmf();
     32 
     33   // PlatformDevice methods
     34   virtual PlatformSurface BeginPlatformPaint() OVERRIDE;
     35   virtual void DrawToNativeContext(HDC dc, int x, int y,
     36                                    const RECT* src_rect) OVERRIDE;
     37   // SkBaseDevice methods.
     38   virtual void drawPaint(const SkDraw& draw, const SkPaint& paint) OVERRIDE;
     39   virtual void drawPoints(const SkDraw& draw, SkCanvas::PointMode mode,
     40                           size_t count, const SkPoint[],
     41                           const SkPaint& paint) OVERRIDE;
     42   virtual void drawRect(const SkDraw& draw, const SkRect& r,
     43                         const SkPaint& paint) OVERRIDE;
     44   virtual void drawRRect(const SkDraw&, const SkRRect& rr,
     45                          const SkPaint& paint) OVERRIDE;
     46   virtual void drawPath(const SkDraw& draw, const SkPath& path,
     47                         const SkPaint& paint,
     48                         const SkMatrix* prePathMatrix = NULL,
     49                         bool pathIsMutable = false) OVERRIDE;
     50   virtual void drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
     51                               const SkRect* src, const SkRect& dst,
     52                               const SkPaint& paint,
     53                               SkCanvas::DrawBitmapRectFlags flags) SK_OVERRIDE;
     54   virtual void drawBitmap(const SkDraw& draw, const SkBitmap& bitmap,
     55                           const SkMatrix& matrix,
     56                           const SkPaint& paint) OVERRIDE;
     57   virtual void drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
     58                           int x, int y, const SkPaint& paint) OVERRIDE;
     59   virtual void drawText(const SkDraw& draw, const void* text, size_t len,
     60                         SkScalar x, SkScalar y, const SkPaint& paint) OVERRIDE;
     61   virtual void drawPosText(const SkDraw& draw, const void* text, size_t len,
     62                            const SkScalar pos[], SkScalar constY,
     63                            int scalarsPerPos, const SkPaint& paint) OVERRIDE;
     64   virtual void drawTextOnPath(const SkDraw& draw, const void* text, size_t len,
     65                               const SkPath& path, const SkMatrix* matrix,
     66                               const SkPaint& paint) OVERRIDE;
     67   virtual void drawVertices(const SkDraw& draw, SkCanvas::VertexMode,
     68                             int vertexCount,
     69                             const SkPoint verts[], const SkPoint texs[],
     70                             const SkColor colors[], SkXfermode* xmode,
     71                             const uint16_t indices[], int indexCount,
     72                             const SkPaint& paint) OVERRIDE;
     73   virtual void drawDevice(const SkDraw& draw, SkBaseDevice*, int x, int y,
     74                           const SkPaint&) OVERRIDE;
     75 
     76   virtual void setMatrixClip(const SkMatrix& transform, const SkRegion& region,
     77                              const SkClipStack&) OVERRIDE;
     78 
     79   void LoadClipRegion();
     80 
     81  protected:
     82 #ifdef SK_SUPPORT_LEGACY_COMPATIBLEDEVICE_CONFIG
     83   virtual SkBaseDevice* onCreateCompatibleDevice(SkBitmap::Config, int width,
     84                                                  int height, bool isOpaque,
     85                                                  Usage usage) OVERRIDE;
     86 #endif
     87   virtual SkBaseDevice* onCreateDevice(const SkImageInfo& info,
     88                                        Usage usage) OVERRIDE;
     89 
     90  private:
     91   // Applies the SkPaint's painting properties in the current GDI context, if
     92   // possible. If GDI can't support all paint's properties, returns false. It
     93   // doesn't execute the "commands" in SkPaint.
     94   bool ApplyPaint(const SkPaint& paint);
     95 
     96   // Selects a new object in the device context. It can be a pen, a brush, a
     97   // clipping region, a bitmap or a font. Returns the old selected object.
     98   HGDIOBJ SelectObject(HGDIOBJ object);
     99 
    100   // Creates a brush according to SkPaint's properties.
    101   bool CreateBrush(bool use_brush, const SkPaint& paint);
    102 
    103   // Creates a pen according to SkPaint's properties.
    104   bool CreatePen(bool use_pen, const SkPaint& paint);
    105 
    106   // Restores back the previous objects (pen, brush, etc) after a paint command.
    107   void Cleanup();
    108 
    109   // Creates a brush according to SkPaint's properties.
    110   bool CreateBrush(bool use_brush, COLORREF color);
    111 
    112   // Creates a pen according to SkPaint's properties.
    113   bool CreatePen(bool use_pen, COLORREF color, int stroke_width,
    114                  float stroke_miter, DWORD pen_style);
    115 
    116   // Draws a bitmap in the the device, using the currently loaded matrix.
    117   void InternalDrawBitmap(const SkBitmap& bitmap, int x, int y,
    118                           const SkPaint& paint);
    119 
    120   // The Windows Device Context handle. It is the backend used with GDI drawing.
    121   // This backend is write-only and vectorial.
    122   HDC hdc_;
    123 
    124   // Translation assigned to the DC: we need to keep track of this separately
    125   // so it can be updated even if the DC isn't created yet.
    126   SkMatrix transform_;
    127 
    128   // The current clipping
    129   SkRegion clip_region_;
    130 
    131   // Previously selected brush before the current drawing.
    132   HGDIOBJ previous_brush_;
    133 
    134   // Previously selected pen before the current drawing.
    135   HGDIOBJ previous_pen_;
    136 
    137   DISALLOW_COPY_AND_ASSIGN(VectorPlatformDeviceEmf);
    138 };
    139 
    140 typedef void (*SkiaEnsureTypefaceCharactersAccessible)
    141     (const LOGFONT& font, const wchar_t* text, unsigned int text_length);
    142 
    143 SK_API void SetSkiaEnsureTypefaceCharactersAccessible(
    144     SkiaEnsureTypefaceCharactersAccessible func);
    145 
    146 }  // namespace skia
    147 
    148 #endif  // SKIA_EXT_VECTOR_PLATFORM_DEVICE_EMF_WIN_H_
    149