gfx/2d/PathRecording.cpp
author Sebastian Hengst <archaeopteryx@coole-files.de>
Mon, 22 Oct 2018 16:33:06 +0300
changeset 442291 c44fbdd5173548c9035256dda8fd3512f67118a8
parent 389027 5f74d262924171a8fa0b4483a64f4cac34c4c9b8
child 448947 6f3709b3878117466168c40affa7bca0b60cf75b
permissions -rw-r--r--
Bug 1496764 - Disable browser_UsageTelemetry_searchbar.js until telemetry probe has been extended to fix permafail on version increase. a=version-increase-fix

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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/. */

#include "PathRecording.h"
#include "DrawEventRecorder.h"
#include "RecordedEventImpl.h"

namespace mozilla {
namespace gfx {

using namespace std;

void
PathBuilderRecording::MoveTo(const Point &aPoint)
{
  PathOp op;
  op.mType = PathOp::OP_MOVETO;
  op.mP1 = aPoint;
  mPathOps.push_back(op);
  mPathBuilder->MoveTo(aPoint);
}

void
PathBuilderRecording::LineTo(const Point &aPoint)
{
  PathOp op;
  op.mType = PathOp::OP_LINETO;
  op.mP1 = aPoint;
  mPathOps.push_back(op);
  mPathBuilder->LineTo(aPoint);
}

void
PathBuilderRecording::BezierTo(const Point &aCP1, const Point &aCP2, const Point &aCP3)
{
  PathOp op;
  op.mType = PathOp::OP_BEZIERTO;
  op.mP1 = aCP1;
  op.mP2 = aCP2;
  op.mP3 = aCP3;
  mPathOps.push_back(op);
  mPathBuilder->BezierTo(aCP1, aCP2, aCP3);
}

void
PathBuilderRecording::QuadraticBezierTo(const Point &aCP1, const Point &aCP2)
{
  PathOp op;
  op.mType = PathOp::OP_QUADRATICBEZIERTO;
  op.mP1 = aCP1;
  op.mP2 = aCP2;
  mPathOps.push_back(op);
  mPathBuilder->QuadraticBezierTo(aCP1, aCP2);
}

void
PathBuilderRecording::Close()
{
  PathOp op;
  op.mType = PathOp::OP_CLOSE;
  mPathOps.push_back(op);
  mPathBuilder->Close();
}

Point
PathBuilderRecording::CurrentPoint() const
{
  return mPathBuilder->CurrentPoint();
}

already_AddRefed<Path>
PathBuilderRecording::Finish()
{
  RefPtr<Path> path = mPathBuilder->Finish();
  return MakeAndAddRef<PathRecording>(path, mPathOps, mFillRule);
}

PathRecording::~PathRecording()
{
  for (size_t i = 0; i < mStoredRecorders.size(); i++) {
    mStoredRecorders[i]->RemoveStoredObject(this);
    mStoredRecorders[i]->RecordEvent(RecordedPathDestruction(this));
  }
}

already_AddRefed<PathBuilder>
PathRecording::CopyToBuilder(FillRule aFillRule) const
{
  RefPtr<PathBuilder> pathBuilder = mPath->CopyToBuilder(aFillRule);
  RefPtr<PathBuilderRecording> recording = new PathBuilderRecording(pathBuilder, aFillRule);
  recording->mPathOps = mPathOps;
  return recording.forget();
}

already_AddRefed<PathBuilder>
PathRecording::TransformedCopyToBuilder(const Matrix &aTransform, FillRule aFillRule) const
{
  RefPtr<PathBuilder> pathBuilder = mPath->TransformedCopyToBuilder(aTransform, aFillRule);
  RefPtr<PathBuilderRecording> recording = new PathBuilderRecording(pathBuilder, aFillRule);
  typedef std::vector<PathOp> pathOpVec;
  for (pathOpVec::const_iterator iter = mPathOps.begin(); iter != mPathOps.end(); iter++) {
    PathOp newPathOp;
    newPathOp.mType = iter->mType;
    if (sPointCount[newPathOp.mType] >= 1) {
      newPathOp.mP1 = aTransform.TransformPoint(iter->mP1);
    }
    if (sPointCount[newPathOp.mType] >= 2) {
      newPathOp.mP2 = aTransform.TransformPoint(iter->mP2);
    }
    if (sPointCount[newPathOp.mType] >= 3) {
      newPathOp.mP3 = aTransform.TransformPoint(iter->mP3);
    }
    recording->mPathOps.push_back(newPathOp);
  }
  return recording.forget();
}

} // namespace gfx
} // namespace mozilla