DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (943311038575)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef _GFXWINDOWSNATIVEDRAWING_H_
#define _GFXWINDOWSNATIVEDRAWING_H_

#include <windows.h>

#include "gfxContext.h"
#include "gfxWindowsSurface.h"

class gfxWindowsNativeDrawing {
 public:
  /* Flags for notifying this class what kind of operations the native
   * drawing supports
   */

  enum {
    /* Whether the native drawing can draw to a surface of content COLOR_ALPHA
     */
    CAN_DRAW_TO_COLOR_ALPHA = 1 << 0,
    CANNOT_DRAW_TO_COLOR_ALPHA = 0 << 0,

    /* Whether the native drawing can be scaled using SetWorldTransform */
    CAN_AXIS_ALIGNED_SCALE = 1 << 1,
    CANNOT_AXIS_ALIGNED_SCALE = 0 << 1,

    /* Whether the native drawing can be both scaled and rotated arbitrarily
       using SetWorldTransform */
    CAN_COMPLEX_TRANSFORM = 1 << 2,
    CANNOT_COMPLEX_TRANSFORM = 0 << 2,

    /* If we have to do transforms with cairo, should we use nearest-neighbour
       filtering? */
    DO_NEAREST_NEIGHBOR_FILTERING = 1 << 3,
    DO_BILINEAR_FILTERING = 0 << 3
  };

  /* Create native win32 drawing for a rectangle bounded by
   * nativeRect.
   *
   * Typical usage looks like:
   *
   *   gfxWindowsNativeDrawing nativeDraw(ctx, destGfxRect, capabilities);
   *   do {
   *     HDC dc = nativeDraw.BeginNativeDrawing();
   *     if (!dc)
   *       return NS_ERROR_FAILURE;
   *
   *     RECT winRect;
   *     nativeDraw.TransformToNativeRect(rect, winRect);
   *
   *       ... call win32 operations on HDC to draw to winRect ...
   *
   *     nativeDraw.EndNativeDrawing();
   *   } while (nativeDraw.ShouldRenderAgain());
   *   nativeDraw.PaintToContext();
   */
  gfxWindowsNativeDrawing(gfxContext* ctx, const gfxRect& nativeRect,
                          uint32_t nativeDrawFlags =
                              CANNOT_DRAW_TO_COLOR_ALPHA |
                              CANNOT_AXIS_ALIGNED_SCALE |
                              CANNOT_COMPLEX_TRANSFORM | DO_BILINEAR_FILTERING);

  /* Returns a HDC which may be used for native drawing.  This HDC is valid
   * until EndNativeDrawing is called; if it is used for drawing after that
   * time, the result is undefined. */
  HDC BeginNativeDrawing();

  /* Transform the native rect into something valid for rendering
   * to the HDC.  This may or may not change RECT, depending on
   * whether SetWorldTransform is used or not. */
  void TransformToNativeRect(const gfxRect& r, RECT& rout);

  /* Marks the end of native drawing */
  void EndNativeDrawing();

  /* Returns true if the native drawing should be executed again */
  bool ShouldRenderAgain();

  /* Places the result to the context, if necessary */
  void PaintToContext();

 private:
  RefPtr<gfxContext> mContext;
  gfxRect mNativeRect;
  uint32_t mNativeDrawFlags;

  // what state the rendering is in
  uint8_t mRenderState;

  mozilla::gfx::Point mDeviceOffset;
  RefPtr<gfxPattern> mBlackPattern, mWhitePattern;

  enum TransformType { TRANSLATION_ONLY, AXIS_ALIGNED_SCALE, COMPLEX };

  TransformType mTransformType;
  gfxPoint mTranslation;
  gfxSize mScale;
  XFORM mWorldTransform;

  // saved state
  RefPtr<gfxWindowsSurface> mWinSurface, mBlackSurface, mWhiteSurface;
  HDC mDC;
  XFORM mOldWorldTransform;
  POINT mOrigViewportOrigin;
  mozilla::gfx::IntSize mTempSurfaceSize;
};

#endif