gecko-dev/gfx/2d/HelpersCairo.h

/* -*- 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 MOZILLA_GFX_HELPERSCAIRO_H_
#define MOZILLA_GFX_HELPERSCAIRO_H_

#include "2D.h"
#include "cairo.h"
#include "Logging.h"

namespace mozilla {
namespace gfx {

static inline cairo_operator_t
GfxOpToCairoOp(CompositionOp op)
{
  switch (op)
  {
    case CompositionOp::OP_OVER:
      return CAIRO_OPERATOR_OVER;
    case CompositionOp::OP_ADD:
      return CAIRO_OPERATOR_ADD;
    case CompositionOp::OP_ATOP:
      return CAIRO_OPERATOR_ATOP;
    case CompositionOp::OP_OUT:
      return CAIRO_OPERATOR_OUT;
    case CompositionOp::OP_IN:
      return CAIRO_OPERATOR_IN;
    case CompositionOp::OP_SOURCE:
      return CAIRO_OPERATOR_SOURCE;
    case CompositionOp::OP_DEST_IN:
      return CAIRO_OPERATOR_DEST_IN;
    case CompositionOp::OP_DEST_OUT:
      return CAIRO_OPERATOR_DEST_OUT;
    case CompositionOp::OP_DEST_OVER:
      return CAIRO_OPERATOR_DEST_OVER;
    case CompositionOp::OP_DEST_ATOP:
      return CAIRO_OPERATOR_DEST_ATOP;
    case CompositionOp::OP_XOR:
      return CAIRO_OPERATOR_XOR;
    case CompositionOp::OP_MULTIPLY:
      return CAIRO_OPERATOR_MULTIPLY;
    case CompositionOp::OP_SCREEN:
      return CAIRO_OPERATOR_SCREEN;
    case CompositionOp::OP_OVERLAY:
      return CAIRO_OPERATOR_OVERLAY;
    case CompositionOp::OP_DARKEN:
      return CAIRO_OPERATOR_DARKEN;
    case CompositionOp::OP_LIGHTEN:
      return CAIRO_OPERATOR_LIGHTEN;
    case CompositionOp::OP_COLOR_DODGE:
      return CAIRO_OPERATOR_COLOR_DODGE;
    case CompositionOp::OP_COLOR_BURN:
      return CAIRO_OPERATOR_COLOR_BURN;
    case CompositionOp::OP_HARD_LIGHT:
      return CAIRO_OPERATOR_HARD_LIGHT;
    case CompositionOp::OP_SOFT_LIGHT:
      return CAIRO_OPERATOR_SOFT_LIGHT;
    case CompositionOp::OP_DIFFERENCE:
      return CAIRO_OPERATOR_DIFFERENCE;
    case CompositionOp::OP_EXCLUSION:
      return CAIRO_OPERATOR_EXCLUSION;
    case CompositionOp::OP_HUE:
      return CAIRO_OPERATOR_HSL_HUE;
    case CompositionOp::OP_SATURATION:
      return CAIRO_OPERATOR_HSL_SATURATION;
    case CompositionOp::OP_COLOR:
      return CAIRO_OPERATOR_HSL_COLOR;
    case CompositionOp::OP_LUMINOSITY:
      return CAIRO_OPERATOR_HSL_LUMINOSITY;
    case CompositionOp::OP_COUNT:
      break;
  }

  return CAIRO_OPERATOR_OVER;
}

static inline cairo_antialias_t
GfxAntialiasToCairoAntialias(AntialiasMode antialias)
{
  switch (antialias)
  {
    case AntialiasMode::NONE:
      return CAIRO_ANTIALIAS_NONE;
    case AntialiasMode::GRAY:
      return CAIRO_ANTIALIAS_GRAY;
    case AntialiasMode::SUBPIXEL:
      return CAIRO_ANTIALIAS_SUBPIXEL;
    case AntialiasMode::DEFAULT:
      return CAIRO_ANTIALIAS_DEFAULT;
  }
  return CAIRO_ANTIALIAS_DEFAULT;
}

static inline cairo_filter_t
GfxFilterToCairoFilter(Filter filter)
{
  switch (filter)
  {
    case Filter::GOOD:
      return CAIRO_FILTER_GOOD;
    case Filter::LINEAR:
      return CAIRO_FILTER_BILINEAR;
    case Filter::POINT:
      return CAIRO_FILTER_NEAREST;
  }

  return CAIRO_FILTER_BILINEAR;
}

static inline cairo_extend_t
GfxExtendToCairoExtend(ExtendMode extend)
{
  switch (extend)
  {
    case ExtendMode::CLAMP:
      return CAIRO_EXTEND_PAD;
    case ExtendMode::REPEAT:
      return CAIRO_EXTEND_REPEAT;
    case ExtendMode::REFLECT:
      return CAIRO_EXTEND_REFLECT;
  }

  return CAIRO_EXTEND_PAD;
}

static inline cairo_format_t
GfxFormatToCairoFormat(SurfaceFormat format)
{
  switch (format)
  {
    case SurfaceFormat::B8G8R8A8:
      return CAIRO_FORMAT_ARGB32;
    case SurfaceFormat::B8G8R8X8:
      return CAIRO_FORMAT_RGB24;
    case SurfaceFormat::A8:
      return CAIRO_FORMAT_A8;
    case SurfaceFormat::R5G6B5:
      return CAIRO_FORMAT_RGB16_565;
    default:
      gfxWarning() << "Unknown image format";
      MOZ_ASSERT(false, "Unknown image format");
      return CAIRO_FORMAT_ARGB32;
  }
}

static inline cairo_content_t
GfxFormatToCairoContent(SurfaceFormat format)
{
  switch (format)
  {
    case SurfaceFormat::B8G8R8A8:
      return CAIRO_CONTENT_COLOR_ALPHA;
    case SurfaceFormat::B8G8R8X8:
    case SurfaceFormat::R5G6B5:  //fall through
      return CAIRO_CONTENT_COLOR;
    case SurfaceFormat::A8:
      return CAIRO_CONTENT_ALPHA;
    default:
      gfxWarning() << "Unknown image format";
      MOZ_ASSERT(false, "Unknown image format");
      return CAIRO_CONTENT_COLOR_ALPHA;
  }
}

static inline cairo_line_join_t
GfxLineJoinToCairoLineJoin(JoinStyle style)
{
  switch (style)
  {
    case JoinStyle::BEVEL:
      return CAIRO_LINE_JOIN_BEVEL;
    case JoinStyle::ROUND:
      return CAIRO_LINE_JOIN_ROUND;
    case JoinStyle::MITER:
      return CAIRO_LINE_JOIN_MITER;
    case JoinStyle::MITER_OR_BEVEL:
      return CAIRO_LINE_JOIN_MITER;
  }

  return CAIRO_LINE_JOIN_MITER;
}

static inline cairo_line_cap_t
GfxLineCapToCairoLineCap(CapStyle style)
{
  switch (style)
  {
    case CapStyle::BUTT:
      return CAIRO_LINE_CAP_BUTT;
    case CapStyle::ROUND:
      return CAIRO_LINE_CAP_ROUND;
    case CapStyle::SQUARE:
      return CAIRO_LINE_CAP_SQUARE;
  }

  return CAIRO_LINE_CAP_BUTT;
}

static inline SurfaceFormat
CairoContentToGfxFormat(cairo_content_t content)
{
  switch (content)
  {
    case CAIRO_CONTENT_COLOR_ALPHA:
      return SurfaceFormat::B8G8R8A8;
    case CAIRO_CONTENT_COLOR:
      // BEWARE! format may be 565
      return SurfaceFormat::B8G8R8X8;
    case CAIRO_CONTENT_ALPHA:
      return SurfaceFormat::A8;
  }

  return SurfaceFormat::B8G8R8A8;
}

static inline void
GfxMatrixToCairoMatrix(const Matrix& mat, cairo_matrix_t& retval)
{
  cairo_matrix_init(&retval, mat._11, mat._12, mat._21, mat._22, mat._31, mat._32);
}

static inline void
SetCairoStrokeOptions(cairo_t* aCtx, const StrokeOptions& aStrokeOptions)
{
  cairo_set_line_width(aCtx, aStrokeOptions.mLineWidth);

  cairo_set_miter_limit(aCtx, aStrokeOptions.mMiterLimit);

  if (aStrokeOptions.mDashPattern) {
    // Convert array of floats to array of doubles
    std::vector<double> dashes(aStrokeOptions.mDashLength);
    for (size_t i = 0; i < aStrokeOptions.mDashLength; ++i) {
      dashes[i] = aStrokeOptions.mDashPattern[i];
    }
    cairo_set_dash(aCtx, &dashes[0], aStrokeOptions.mDashLength,
                   aStrokeOptions.mDashOffset);
  }

  cairo_set_line_join(aCtx, GfxLineJoinToCairoLineJoin(aStrokeOptions.mLineJoin));

  cairo_set_line_cap(aCtx, GfxLineCapToCairoLineCap(aStrokeOptions.mLineCap));
}

static inline cairo_fill_rule_t
GfxFillRuleToCairoFillRule(FillRule rule)
{
  switch (rule)
  {
    case FillRule::FILL_WINDING:
      return CAIRO_FILL_RULE_WINDING;
    case FillRule::FILL_EVEN_ODD:
      return CAIRO_FILL_RULE_EVEN_ODD;
  }

  return CAIRO_FILL_RULE_WINDING;
}

// RAII class for temporarily changing the cairo matrix transform. It will use
// the given matrix transform while it is in scope. When it goes out of scope
// it will put the cairo context back the way it was.

class CairoTempMatrix
{
public:
  CairoTempMatrix(cairo_t* aCtx, const Matrix& aMatrix)
    : mCtx(aCtx)
  {
    cairo_get_matrix(aCtx, &mSaveMatrix);
    cairo_matrix_t matrix;
    GfxMatrixToCairoMatrix(aMatrix, matrix);
    cairo_set_matrix(aCtx, &matrix);
  }

  ~CairoTempMatrix()
  {
    cairo_set_matrix(mCtx, &mSaveMatrix);
  }

private:
  cairo_t* mCtx;
  cairo_matrix_t mSaveMatrix;
};

}
}

#endif /* MOZILLA_GFX_HELPERSCAIRO_H_ */