mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-19 00:05:36 +00:00
a5249b6201
Backed out changeset 31c0aadae8e7 (bug 1156742) Backed out changeset f08df57ff700 (bug 1156742) Backed out changeset 90c026d5dcb1 (bug 1156742) Backed out changeset 8c6d14d80238 (bug 1156742) Backed out changeset 72d86b0471c9 (bug 1156742) Backed out changeset 363829accc09 (bug 1156742) Backed out changeset 16360fe94d54 (bug 1156742) Backed out changeset 5355c636a81a (bug 1156742) Backed out changeset 18844d26b873 (bug 1156742) Backed out changeset 99df86591613 (bug 1156742) Backed out changeset 7ac1c7e15a11 (bug 1156742) Backed out changeset de352000aae1 (bug 1156742) Backed out changeset 4dd34ea230c6 (bug 1156742) Backed out changeset 48c6ce65a5c2 (bug 1156742) Backed out changeset dd52947f73c6 (bug 1156742) Backed out changeset 5fe429ee880c (bug 1156742) Backed out changeset dedca8fb19b0 (bug 1156742) Backed out changeset d748b1354f92 (bug 1156742) Backed out changeset 7f8e59588518 (bug 1156742) Backed out changeset b90d302c57f6 (bug 1156742) Backed out changeset 7a4da453572c (bug 1156742) Backed out changeset a40eea914519 (bug 1156742) Backed out changeset 99a8859afcdb (bug 1156742) Backed out changeset 4934e88b2d7a (bug 1156742) Backed out changeset 79733166f05e (bug 1156742) for build bustage in SkOSLibrary_win.cpp CLOSED TREE --HG-- extra : amend_source : beeb6abbcc724b79ac166e828efa78dc4c5301da
1080 lines
32 KiB
C++
1080 lines
32 KiB
C++
/* -*- 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_RECORDEDEVENT_H_
|
|
#define MOZILLA_GFX_RECORDEDEVENT_H_
|
|
|
|
#include "2D.h"
|
|
#include <ostream>
|
|
#include <sstream>
|
|
#include <cstring>
|
|
#include "RecordingTypes.h"
|
|
#include "PathRecording.h"
|
|
|
|
namespace mozilla {
|
|
namespace gfx {
|
|
|
|
// A change in major revision means a change in event binary format, causing
|
|
// loss of backwards compatibility. Old streams will not work in a player
|
|
// using a newer major revision. And new streams will not work in a player
|
|
// using an older major revision.
|
|
const uint16_t kMajorRevision = 3;
|
|
// A change in minor revision means additions of new events. New streams will
|
|
// not play in older players.
|
|
const uint16_t kMinorRevision = 2;
|
|
|
|
struct ReferencePtr
|
|
{
|
|
ReferencePtr()
|
|
: mLongPtr(0)
|
|
{}
|
|
|
|
MOZ_IMPLICIT ReferencePtr(const void* aLongPtr)
|
|
: mLongPtr(uint64_t(aLongPtr))
|
|
{}
|
|
|
|
template <typename T>
|
|
MOZ_IMPLICIT ReferencePtr(const RefPtr<T>& aPtr)
|
|
: mLongPtr(uint64_t(aPtr.get()))
|
|
{}
|
|
|
|
ReferencePtr &operator =(const void* aLongPtr) {
|
|
mLongPtr = uint64_t(aLongPtr);
|
|
return *this;
|
|
}
|
|
|
|
template <typename T>
|
|
ReferencePtr &operator =(const RefPtr<T>& aPtr) {
|
|
mLongPtr = uint64_t(aPtr.get());
|
|
return *this;
|
|
}
|
|
|
|
operator void*() const {
|
|
return (void*)mLongPtr;
|
|
}
|
|
|
|
uint64_t mLongPtr;
|
|
};
|
|
|
|
// Used by the Azure drawing debugger (player2d)
|
|
inline std::string StringFromPtr(ReferencePtr aPtr)
|
|
{
|
|
std::stringstream stream;
|
|
stream << aPtr;
|
|
return stream.str();
|
|
}
|
|
|
|
class Translator
|
|
{
|
|
public:
|
|
virtual ~Translator() {}
|
|
|
|
virtual DrawTarget *LookupDrawTarget(ReferencePtr aRefPtr) = 0;
|
|
virtual Path *LookupPath(ReferencePtr aRefPtr) = 0;
|
|
virtual SourceSurface *LookupSourceSurface(ReferencePtr aRefPtr) = 0;
|
|
virtual FilterNode *LookupFilterNode(ReferencePtr aRefPtr) = 0;
|
|
virtual GradientStops *LookupGradientStops(ReferencePtr aRefPtr) = 0;
|
|
virtual ScaledFont *LookupScaledFont(ReferencePtr aRefPtr) = 0;
|
|
virtual void AddDrawTarget(ReferencePtr aRefPtr, DrawTarget *aDT) = 0;
|
|
virtual void RemoveDrawTarget(ReferencePtr aRefPtr) = 0;
|
|
virtual void AddPath(ReferencePtr aRefPtr, Path *aPath) = 0;
|
|
virtual void RemovePath(ReferencePtr aRefPtr) = 0;
|
|
virtual void AddSourceSurface(ReferencePtr aRefPtr, SourceSurface *aPath) = 0;
|
|
virtual void RemoveSourceSurface(ReferencePtr aRefPtr) = 0;
|
|
virtual void AddFilterNode(mozilla::gfx::ReferencePtr aRefPtr, FilterNode *aSurface) = 0;
|
|
virtual void RemoveFilterNode(mozilla::gfx::ReferencePtr aRefPtr) = 0;
|
|
virtual void AddGradientStops(ReferencePtr aRefPtr, GradientStops *aPath) = 0;
|
|
virtual void RemoveGradientStops(ReferencePtr aRefPtr) = 0;
|
|
virtual void AddScaledFont(ReferencePtr aRefPtr, ScaledFont *aScaledFont) = 0;
|
|
virtual void RemoveScaledFont(ReferencePtr aRefPtr) = 0;
|
|
|
|
virtual DrawTarget *GetReferenceDrawTarget() = 0;
|
|
virtual FontType GetDesiredFontType() = 0;
|
|
};
|
|
|
|
struct ColorPatternStorage
|
|
{
|
|
Color mColor;
|
|
};
|
|
|
|
struct LinearGradientPatternStorage
|
|
{
|
|
Point mBegin;
|
|
Point mEnd;
|
|
ReferencePtr mStops;
|
|
Matrix mMatrix;
|
|
};
|
|
|
|
struct RadialGradientPatternStorage
|
|
{
|
|
Point mCenter1;
|
|
Point mCenter2;
|
|
Float mRadius1;
|
|
Float mRadius2;
|
|
ReferencePtr mStops;
|
|
Matrix mMatrix;
|
|
};
|
|
|
|
struct SurfacePatternStorage
|
|
{
|
|
ExtendMode mExtend;
|
|
Filter mFilter;
|
|
ReferencePtr mSurface;
|
|
Matrix mMatrix;
|
|
};
|
|
|
|
struct PatternStorage
|
|
{
|
|
PatternType mType;
|
|
union {
|
|
char *mStorage;
|
|
char mColor[sizeof(ColorPatternStorage)];
|
|
char mLinear[sizeof(LinearGradientPatternStorage)];
|
|
char mRadial[sizeof(RadialGradientPatternStorage)];
|
|
char mSurface[sizeof(SurfacePatternStorage)];
|
|
};
|
|
};
|
|
|
|
class RecordedEvent {
|
|
public:
|
|
enum EventType {
|
|
DRAWTARGETCREATION = 0,
|
|
DRAWTARGETDESTRUCTION,
|
|
FILLRECT,
|
|
STROKERECT,
|
|
STROKELINE,
|
|
CLEARRECT,
|
|
COPYSURFACE,
|
|
SETTRANSFORM,
|
|
PUSHCLIP,
|
|
PUSHCLIPRECT,
|
|
POPCLIP,
|
|
FILL,
|
|
FILLGLYPHS,
|
|
MASK,
|
|
STROKE,
|
|
DRAWSURFACE,
|
|
DRAWSURFACEWITHSHADOW,
|
|
PATHCREATION,
|
|
PATHDESTRUCTION,
|
|
SOURCESURFACECREATION,
|
|
SOURCESURFACEDESTRUCTION,
|
|
GRADIENTSTOPSCREATION,
|
|
GRADIENTSTOPSDESTRUCTION,
|
|
SNAPSHOT,
|
|
SCALEDFONTCREATION,
|
|
SCALEDFONTDESTRUCTION,
|
|
MASKSURFACE,
|
|
FILTERNODECREATION,
|
|
FILTERNODEDESTRUCTION,
|
|
DRAWFILTER,
|
|
FILTERNODESETATTRIBUTE,
|
|
FILTERNODESETINPUT
|
|
};
|
|
static const uint32_t kTotalEventTypes = RecordedEvent::FILTERNODESETINPUT + 1;
|
|
|
|
static std::string GetEventName(EventType aType);
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const {}
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const {}
|
|
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const { }
|
|
|
|
void RecordPatternData(std::ostream &aStream, const PatternStorage &aPatternStorage) const;
|
|
void ReadPatternData(std::istream &aStream, PatternStorage &aPatternStorage) const;
|
|
void StorePattern(PatternStorage &aDestination, const Pattern &aSource) const;
|
|
void RecordStrokeOptions(std::ostream &aStream, const StrokeOptions &aStrokeOptions) const;
|
|
void ReadStrokeOptions(std::istream &aStream, StrokeOptions &aStrokeOptions);
|
|
|
|
virtual std::string GetName() const = 0;
|
|
|
|
virtual ReferencePtr GetObjectRef() const = 0;
|
|
|
|
virtual ReferencePtr GetDestinedDT() { return nullptr; }
|
|
|
|
void OutputSimplePatternInfo(const PatternStorage &aStorage, std::stringstream &aOutput) const;
|
|
|
|
static RecordedEvent *LoadEventFromStream(std::istream &aStream, EventType aType);
|
|
|
|
EventType GetType() { return (EventType)mType; }
|
|
protected:
|
|
friend class DrawEventRecorderPrivate;
|
|
|
|
MOZ_IMPLICIT RecordedEvent(int32_t aType) : mType(aType)
|
|
{}
|
|
|
|
int32_t mType;
|
|
std::vector<Float> mDashPatternStorage;
|
|
};
|
|
|
|
class RecordedDrawingEvent : public RecordedEvent
|
|
{
|
|
public:
|
|
virtual ReferencePtr GetDestinedDT() { return mDT; }
|
|
|
|
protected:
|
|
RecordedDrawingEvent(EventType aType, DrawTarget *aTarget)
|
|
: RecordedEvent(aType), mDT(aTarget)
|
|
{
|
|
}
|
|
|
|
RecordedDrawingEvent(EventType aType, std::istream &aStream);
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
|
|
virtual ReferencePtr GetObjectRef() const;
|
|
|
|
ReferencePtr mDT;
|
|
};
|
|
|
|
class RecordedDrawTargetCreation : public RecordedEvent {
|
|
public:
|
|
RecordedDrawTargetCreation(ReferencePtr aRefPtr, BackendType aType, const IntSize &aSize, SurfaceFormat aFormat,
|
|
bool aHasExistingData = false, SourceSurface *aExistingData = nullptr)
|
|
: RecordedEvent(DRAWTARGETCREATION), mRefPtr(aRefPtr), mBackendType(aType), mSize(aSize), mFormat(aFormat)
|
|
, mHasExistingData(aHasExistingData), mExistingData(aExistingData)
|
|
{}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "DrawTarget Creation"; }
|
|
virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
|
|
|
|
ReferencePtr mRefPtr;
|
|
BackendType mBackendType;
|
|
IntSize mSize;
|
|
SurfaceFormat mFormat;
|
|
bool mHasExistingData;
|
|
RefPtr<SourceSurface> mExistingData;
|
|
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedDrawTargetCreation(std::istream &aStream);
|
|
};
|
|
|
|
class RecordedDrawTargetDestruction : public RecordedEvent {
|
|
public:
|
|
MOZ_IMPLICIT RecordedDrawTargetDestruction(ReferencePtr aRefPtr)
|
|
: RecordedEvent(DRAWTARGETDESTRUCTION), mRefPtr(aRefPtr)
|
|
{}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "DrawTarget Destruction"; }
|
|
virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
|
|
|
|
ReferencePtr mRefPtr;
|
|
|
|
BackendType mBackendType;
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedDrawTargetDestruction(std::istream &aStream);
|
|
};
|
|
|
|
class RecordedFillRect : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedFillRect(DrawTarget *aDT, const Rect &aRect, const Pattern &aPattern, const DrawOptions &aOptions)
|
|
: RecordedDrawingEvent(FILLRECT, aDT), mRect(aRect), mOptions(aOptions)
|
|
{
|
|
StorePattern(mPattern, aPattern);
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "FillRect"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedFillRect(std::istream &aStream);
|
|
|
|
Rect mRect;
|
|
PatternStorage mPattern;
|
|
DrawOptions mOptions;
|
|
};
|
|
|
|
class RecordedStrokeRect : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedStrokeRect(DrawTarget *aDT, const Rect &aRect, const Pattern &aPattern,
|
|
const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions)
|
|
: RecordedDrawingEvent(STROKERECT, aDT), mRect(aRect),
|
|
mStrokeOptions(aStrokeOptions), mOptions(aOptions)
|
|
{
|
|
StorePattern(mPattern, aPattern);
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "StrokeRect"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedStrokeRect(std::istream &aStream);
|
|
|
|
Rect mRect;
|
|
PatternStorage mPattern;
|
|
StrokeOptions mStrokeOptions;
|
|
DrawOptions mOptions;
|
|
};
|
|
|
|
class RecordedStrokeLine : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedStrokeLine(DrawTarget *aDT, const Point &aBegin, const Point &aEnd,
|
|
const Pattern &aPattern, const StrokeOptions &aStrokeOptions,
|
|
const DrawOptions &aOptions)
|
|
: RecordedDrawingEvent(STROKELINE, aDT), mBegin(aBegin), mEnd(aEnd),
|
|
mStrokeOptions(aStrokeOptions), mOptions(aOptions)
|
|
{
|
|
StorePattern(mPattern, aPattern);
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "StrokeLine"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedStrokeLine(std::istream &aStream);
|
|
|
|
Point mBegin;
|
|
Point mEnd;
|
|
PatternStorage mPattern;
|
|
StrokeOptions mStrokeOptions;
|
|
DrawOptions mOptions;
|
|
};
|
|
|
|
class RecordedFill : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedFill(DrawTarget *aDT, ReferencePtr aPath, const Pattern &aPattern, const DrawOptions &aOptions)
|
|
: RecordedDrawingEvent(FILL, aDT), mPath(aPath), mOptions(aOptions)
|
|
{
|
|
StorePattern(mPattern, aPattern);
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "Fill"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedFill(std::istream &aStream);
|
|
|
|
ReferencePtr mPath;
|
|
PatternStorage mPattern;
|
|
DrawOptions mOptions;
|
|
};
|
|
|
|
class RecordedFillGlyphs : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedFillGlyphs(DrawTarget *aDT, ReferencePtr aScaledFont, const Pattern &aPattern, const DrawOptions &aOptions,
|
|
const Glyph *aGlyphs, uint32_t aNumGlyphs)
|
|
: RecordedDrawingEvent(FILLGLYPHS, aDT), mScaledFont(aScaledFont), mOptions(aOptions)
|
|
{
|
|
StorePattern(mPattern, aPattern);
|
|
mNumGlyphs = aNumGlyphs;
|
|
mGlyphs = new Glyph[aNumGlyphs];
|
|
memcpy(mGlyphs, aGlyphs, sizeof(Glyph) * aNumGlyphs);
|
|
}
|
|
virtual ~RecordedFillGlyphs();
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "FillGlyphs"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedFillGlyphs(std::istream &aStream);
|
|
|
|
ReferencePtr mScaledFont;
|
|
PatternStorage mPattern;
|
|
DrawOptions mOptions;
|
|
Glyph *mGlyphs;
|
|
uint32_t mNumGlyphs;
|
|
};
|
|
|
|
class RecordedMask : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedMask(DrawTarget *aDT, const Pattern &aSource, const Pattern &aMask, const DrawOptions &aOptions)
|
|
: RecordedDrawingEvent(MASK, aDT), mOptions(aOptions)
|
|
{
|
|
StorePattern(mSource, aSource);
|
|
StorePattern(mMask, aMask);
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "Mask"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedMask(std::istream &aStream);
|
|
|
|
PatternStorage mSource;
|
|
PatternStorage mMask;
|
|
DrawOptions mOptions;
|
|
};
|
|
|
|
class RecordedStroke : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedStroke(DrawTarget *aDT, ReferencePtr aPath, const Pattern &aPattern,
|
|
const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions)
|
|
: RecordedDrawingEvent(STROKE, aDT), mPath(aPath),
|
|
mStrokeOptions(aStrokeOptions), mOptions(aOptions)
|
|
{
|
|
StorePattern(mPattern, aPattern);
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "Stroke"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedStroke(std::istream &aStream);
|
|
|
|
ReferencePtr mPath;
|
|
PatternStorage mPattern;
|
|
StrokeOptions mStrokeOptions;
|
|
DrawOptions mOptions;
|
|
};
|
|
|
|
class RecordedClearRect : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedClearRect(DrawTarget *aDT, const Rect &aRect)
|
|
: RecordedDrawingEvent(CLEARRECT, aDT), mRect(aRect)
|
|
{
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "ClearRect"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedClearRect(std::istream &aStream);
|
|
|
|
Rect mRect;
|
|
};
|
|
|
|
class RecordedCopySurface : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedCopySurface(DrawTarget *aDT, ReferencePtr aSourceSurface,
|
|
const IntRect &aSourceRect, const IntPoint &aDest)
|
|
: RecordedDrawingEvent(COPYSURFACE, aDT), mSourceSurface(aSourceSurface),
|
|
mSourceRect(aSourceRect), mDest(aDest)
|
|
{
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "CopySurface"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedCopySurface(std::istream &aStream);
|
|
|
|
ReferencePtr mSourceSurface;
|
|
IntRect mSourceRect;
|
|
IntPoint mDest;
|
|
};
|
|
|
|
class RecordedPushClip : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedPushClip(DrawTarget *aDT, ReferencePtr aPath)
|
|
: RecordedDrawingEvent(PUSHCLIP, aDT), mPath(aPath)
|
|
{
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "PushClip"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedPushClip(std::istream &aStream);
|
|
|
|
ReferencePtr mPath;
|
|
};
|
|
|
|
class RecordedPushClipRect : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedPushClipRect(DrawTarget *aDT, const Rect &aRect)
|
|
: RecordedDrawingEvent(PUSHCLIPRECT, aDT), mRect(aRect)
|
|
{
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "PushClipRect"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedPushClipRect(std::istream &aStream);
|
|
|
|
Rect mRect;
|
|
};
|
|
|
|
class RecordedPopClip : public RecordedDrawingEvent {
|
|
public:
|
|
MOZ_IMPLICIT RecordedPopClip(DrawTarget *aDT)
|
|
: RecordedDrawingEvent(POPCLIP, aDT)
|
|
{}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "PopClip"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedPopClip(std::istream &aStream);
|
|
};
|
|
|
|
class RecordedSetTransform : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedSetTransform(DrawTarget *aDT, const Matrix &aTransform)
|
|
: RecordedDrawingEvent(SETTRANSFORM, aDT), mTransform(aTransform)
|
|
{
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "SetTransform"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedSetTransform(std::istream &aStream);
|
|
|
|
Matrix mTransform;
|
|
};
|
|
|
|
class RecordedDrawSurface : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedDrawSurface(DrawTarget *aDT, ReferencePtr aRefSource, const Rect &aDest,
|
|
const Rect &aSource, const DrawSurfaceOptions &aDSOptions,
|
|
const DrawOptions &aOptions)
|
|
: RecordedDrawingEvent(DRAWSURFACE, aDT), mRefSource(aRefSource), mDest(aDest)
|
|
, mSource(aSource), mDSOptions(aDSOptions), mOptions(aOptions)
|
|
{
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "DrawSurface"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedDrawSurface(std::istream &aStream);
|
|
|
|
ReferencePtr mRefSource;
|
|
Rect mDest;
|
|
Rect mSource;
|
|
DrawSurfaceOptions mDSOptions;
|
|
DrawOptions mOptions;
|
|
};
|
|
|
|
class RecordedDrawSurfaceWithShadow : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedDrawSurfaceWithShadow(DrawTarget *aDT, ReferencePtr aRefSource, const Point &aDest,
|
|
const Color &aColor, const Point &aOffset,
|
|
Float aSigma, CompositionOp aOp)
|
|
: RecordedDrawingEvent(DRAWSURFACEWITHSHADOW, aDT), mRefSource(aRefSource), mDest(aDest)
|
|
, mColor(aColor), mOffset(aOffset), mSigma(aSigma), mOp(aOp)
|
|
{
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "DrawSurfaceWithShadow"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedDrawSurfaceWithShadow(std::istream &aStream);
|
|
|
|
ReferencePtr mRefSource;
|
|
Point mDest;
|
|
Color mColor;
|
|
Point mOffset;
|
|
Float mSigma;
|
|
CompositionOp mOp;
|
|
};
|
|
|
|
class RecordedDrawFilter : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedDrawFilter(DrawTarget *aDT, ReferencePtr aNode,
|
|
const Rect &aSourceRect,
|
|
const Point &aDestPoint,
|
|
const DrawOptions &aOptions)
|
|
: RecordedDrawingEvent(DRAWFILTER, aDT), mNode(aNode), mSourceRect(aSourceRect)
|
|
, mDestPoint(aDestPoint), mOptions(aOptions)
|
|
{
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "DrawFilter"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedDrawFilter(std::istream &aStream);
|
|
|
|
ReferencePtr mNode;
|
|
Rect mSourceRect;
|
|
Point mDestPoint;
|
|
DrawOptions mOptions;
|
|
};
|
|
|
|
class RecordedPathCreation : public RecordedEvent {
|
|
public:
|
|
MOZ_IMPLICIT RecordedPathCreation(PathRecording *aPath);
|
|
~RecordedPathCreation();
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "Path Creation"; }
|
|
virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
ReferencePtr mRefPtr;
|
|
FillRule mFillRule;
|
|
std::vector<PathOp> mPathOps;
|
|
|
|
MOZ_IMPLICIT RecordedPathCreation(std::istream &aStream);
|
|
};
|
|
|
|
class RecordedPathDestruction : public RecordedEvent {
|
|
public:
|
|
MOZ_IMPLICIT RecordedPathDestruction(PathRecording *aPath)
|
|
: RecordedEvent(PATHDESTRUCTION), mRefPtr(aPath)
|
|
{
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "Path Destruction"; }
|
|
virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
ReferencePtr mRefPtr;
|
|
|
|
MOZ_IMPLICIT RecordedPathDestruction(std::istream &aStream);
|
|
};
|
|
|
|
class RecordedSourceSurfaceCreation : public RecordedEvent {
|
|
public:
|
|
RecordedSourceSurfaceCreation(ReferencePtr aRefPtr, uint8_t *aData, int32_t aStride,
|
|
const IntSize &aSize, SurfaceFormat aFormat)
|
|
: RecordedEvent(SOURCESURFACECREATION), mRefPtr(aRefPtr), mData(aData)
|
|
, mStride(aStride), mSize(aSize), mFormat(aFormat), mDataOwned(false)
|
|
{
|
|
}
|
|
|
|
~RecordedSourceSurfaceCreation();
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "SourceSurface Creation"; }
|
|
virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
ReferencePtr mRefPtr;
|
|
uint8_t *mData;
|
|
int32_t mStride;
|
|
IntSize mSize;
|
|
SurfaceFormat mFormat;
|
|
bool mDataOwned;
|
|
|
|
MOZ_IMPLICIT RecordedSourceSurfaceCreation(std::istream &aStream);
|
|
};
|
|
|
|
class RecordedSourceSurfaceDestruction : public RecordedEvent {
|
|
public:
|
|
MOZ_IMPLICIT RecordedSourceSurfaceDestruction(ReferencePtr aRefPtr)
|
|
: RecordedEvent(SOURCESURFACEDESTRUCTION), mRefPtr(aRefPtr)
|
|
{
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "SourceSurface Destruction"; }
|
|
virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
ReferencePtr mRefPtr;
|
|
|
|
MOZ_IMPLICIT RecordedSourceSurfaceDestruction(std::istream &aStream);
|
|
};
|
|
|
|
class RecordedFilterNodeCreation : public RecordedEvent {
|
|
public:
|
|
RecordedFilterNodeCreation(ReferencePtr aRefPtr, FilterType aType)
|
|
: RecordedEvent(FILTERNODECREATION), mRefPtr(aRefPtr), mType(aType)
|
|
{
|
|
}
|
|
|
|
~RecordedFilterNodeCreation();
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "FilterNode Creation"; }
|
|
virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
ReferencePtr mRefPtr;
|
|
FilterType mType;
|
|
|
|
MOZ_IMPLICIT RecordedFilterNodeCreation(std::istream &aStream);
|
|
};
|
|
|
|
class RecordedFilterNodeDestruction : public RecordedEvent {
|
|
public:
|
|
MOZ_IMPLICIT RecordedFilterNodeDestruction(ReferencePtr aRefPtr)
|
|
: RecordedEvent(FILTERNODEDESTRUCTION), mRefPtr(aRefPtr)
|
|
{
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "FilterNode Destruction"; }
|
|
virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
ReferencePtr mRefPtr;
|
|
|
|
MOZ_IMPLICIT RecordedFilterNodeDestruction(std::istream &aStream);
|
|
};
|
|
|
|
class RecordedGradientStopsCreation : public RecordedEvent {
|
|
public:
|
|
RecordedGradientStopsCreation(ReferencePtr aRefPtr, GradientStop *aStops,
|
|
uint32_t aNumStops, ExtendMode aExtendMode)
|
|
: RecordedEvent(GRADIENTSTOPSCREATION), mRefPtr(aRefPtr), mStops(aStops)
|
|
, mNumStops(aNumStops), mExtendMode(aExtendMode), mDataOwned(false)
|
|
{
|
|
}
|
|
|
|
~RecordedGradientStopsCreation();
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "GradientStops Creation"; }
|
|
virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
ReferencePtr mRefPtr;
|
|
GradientStop *mStops;
|
|
uint32_t mNumStops;
|
|
ExtendMode mExtendMode;
|
|
bool mDataOwned;
|
|
|
|
MOZ_IMPLICIT RecordedGradientStopsCreation(std::istream &aStream);
|
|
};
|
|
|
|
class RecordedGradientStopsDestruction : public RecordedEvent {
|
|
public:
|
|
MOZ_IMPLICIT RecordedGradientStopsDestruction(ReferencePtr aRefPtr)
|
|
: RecordedEvent(GRADIENTSTOPSDESTRUCTION), mRefPtr(aRefPtr)
|
|
{
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "GradientStops Destruction"; }
|
|
virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
ReferencePtr mRefPtr;
|
|
|
|
MOZ_IMPLICIT RecordedGradientStopsDestruction(std::istream &aStream);
|
|
};
|
|
|
|
class RecordedSnapshot : public RecordedEvent {
|
|
public:
|
|
RecordedSnapshot(ReferencePtr aRefPtr, DrawTarget *aDT)
|
|
: RecordedEvent(SNAPSHOT), mRefPtr(aRefPtr), mDT(aDT)
|
|
{
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "Snapshot"; }
|
|
virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
ReferencePtr mRefPtr;
|
|
ReferencePtr mDT;
|
|
|
|
MOZ_IMPLICIT RecordedSnapshot(std::istream &aStream);
|
|
};
|
|
|
|
class RecordedScaledFontCreation : public RecordedEvent {
|
|
public:
|
|
static void FontDataProc(const uint8_t *aData, uint32_t aSize, uint32_t aIndex, Float aGlyphSize, void* aBaton)
|
|
{
|
|
static_cast<RecordedScaledFontCreation*>(aBaton)->SetFontData(aData, aSize, aIndex, aGlyphSize);
|
|
}
|
|
|
|
RecordedScaledFontCreation(ReferencePtr aRefPtr, ScaledFont *aScaledFont)
|
|
: RecordedEvent(SCALEDFONTCREATION), mRefPtr(aRefPtr), mData(nullptr)
|
|
{
|
|
aScaledFont->GetFontFileData(&FontDataProc, this);
|
|
}
|
|
|
|
~RecordedScaledFontCreation();
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "ScaledFont Creation"; }
|
|
virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
|
|
|
|
void SetFontData(const uint8_t *aData, uint32_t aSize, uint32_t aIndex, Float aGlyphSize);
|
|
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
ReferencePtr mRefPtr;
|
|
uint8_t *mData;
|
|
uint32_t mSize;
|
|
Float mGlyphSize;
|
|
uint32_t mIndex;
|
|
|
|
MOZ_IMPLICIT RecordedScaledFontCreation(std::istream &aStream);
|
|
};
|
|
|
|
class RecordedScaledFontDestruction : public RecordedEvent {
|
|
public:
|
|
MOZ_IMPLICIT RecordedScaledFontDestruction(ReferencePtr aRefPtr)
|
|
: RecordedEvent(SCALEDFONTDESTRUCTION), mRefPtr(aRefPtr)
|
|
{
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "ScaledFont Destruction"; }
|
|
virtual ReferencePtr GetObjectRef() const { return mRefPtr; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
ReferencePtr mRefPtr;
|
|
|
|
MOZ_IMPLICIT RecordedScaledFontDestruction(std::istream &aStream);
|
|
};
|
|
|
|
class RecordedMaskSurface : public RecordedDrawingEvent {
|
|
public:
|
|
RecordedMaskSurface(DrawTarget *aDT, const Pattern &aPattern, ReferencePtr aRefMask,
|
|
const Point &aOffset, const DrawOptions &aOptions)
|
|
: RecordedDrawingEvent(MASKSURFACE, aDT), mRefMask(aRefMask), mOffset(aOffset)
|
|
, mOptions(aOptions)
|
|
{
|
|
StorePattern(mPattern, aPattern);
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "MaskSurface"; }
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
MOZ_IMPLICIT RecordedMaskSurface(std::istream &aStream);
|
|
|
|
PatternStorage mPattern;
|
|
ReferencePtr mRefMask;
|
|
Point mOffset;
|
|
DrawOptions mOptions;
|
|
};
|
|
|
|
class RecordedFilterNodeSetAttribute : public RecordedEvent
|
|
{
|
|
public:
|
|
enum ArgType {
|
|
ARGTYPE_UINT32,
|
|
ARGTYPE_BOOL,
|
|
ARGTYPE_FLOAT,
|
|
ARGTYPE_SIZE,
|
|
ARGTYPE_INTSIZE,
|
|
ARGTYPE_INTPOINT,
|
|
ARGTYPE_RECT,
|
|
ARGTYPE_INTRECT,
|
|
ARGTYPE_POINT,
|
|
ARGTYPE_MATRIX5X4,
|
|
ARGTYPE_POINT3D,
|
|
ARGTYPE_COLOR,
|
|
ARGTYPE_FLOAT_ARRAY
|
|
};
|
|
|
|
template<typename T>
|
|
RecordedFilterNodeSetAttribute(FilterNode *aNode, uint32_t aIndex, T aArgument, ArgType aArgType)
|
|
: RecordedEvent(FILTERNODESETATTRIBUTE), mNode(aNode), mIndex(aIndex), mArgType(aArgType)
|
|
{
|
|
mPayload.resize(sizeof(T));
|
|
memcpy(&mPayload.front(), &aArgument, sizeof(T));
|
|
}
|
|
|
|
RecordedFilterNodeSetAttribute(FilterNode *aNode, uint32_t aIndex, const Float *aFloat, uint32_t aSize)
|
|
: RecordedEvent(FILTERNODESETATTRIBUTE), mNode(aNode), mIndex(aIndex), mArgType(ARGTYPE_FLOAT_ARRAY)
|
|
{
|
|
mPayload.resize(sizeof(Float) * aSize);
|
|
memcpy(&mPayload.front(), aFloat, sizeof(Float) * aSize);
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "SetAttribute"; }
|
|
|
|
virtual ReferencePtr GetObjectRef() const { return mNode; }
|
|
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
ReferencePtr mNode;
|
|
|
|
uint32_t mIndex;
|
|
ArgType mArgType;
|
|
std::vector<uint8_t> mPayload;
|
|
|
|
MOZ_IMPLICIT RecordedFilterNodeSetAttribute(std::istream &aStream);
|
|
};
|
|
|
|
class RecordedFilterNodeSetInput : public RecordedEvent
|
|
{
|
|
public:
|
|
RecordedFilterNodeSetInput(FilterNode* aNode, uint32_t aIndex, FilterNode* aInputNode)
|
|
: RecordedEvent(FILTERNODESETINPUT), mNode(aNode), mIndex(aIndex)
|
|
, mInputFilter(aInputNode), mInputSurface(nullptr)
|
|
{
|
|
}
|
|
|
|
RecordedFilterNodeSetInput(FilterNode *aNode, uint32_t aIndex, SourceSurface *aInputSurface)
|
|
: RecordedEvent(FILTERNODESETINPUT), mNode(aNode), mIndex(aIndex)
|
|
, mInputFilter(nullptr), mInputSurface(aInputSurface)
|
|
{
|
|
}
|
|
|
|
virtual void PlayEvent(Translator *aTranslator) const;
|
|
virtual void RecordToStream(std::ostream &aStream) const;
|
|
virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const;
|
|
|
|
virtual std::string GetName() const { return "SetInput"; }
|
|
|
|
virtual ReferencePtr GetObjectRef() const { return mNode; }
|
|
|
|
private:
|
|
friend class RecordedEvent;
|
|
|
|
ReferencePtr mNode;
|
|
uint32_t mIndex;
|
|
ReferencePtr mInputFilter;
|
|
ReferencePtr mInputSurface;
|
|
|
|
MOZ_IMPLICIT RecordedFilterNodeSetInput(std::istream &aStream);
|
|
};
|
|
|
|
} // namespace gfx
|
|
} // namespace mozilla
|
|
|
|
#endif
|