The Tor Browser: comparison gfx/thebes/gfxContext.h

--1:000000000000
+:884cc13672a5
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+* 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 GFX_CONTEXT_H
+#define GFX_CONTEXT_H
+#include "gfxTypes.h"
+#include "gfxASurface.h"
+#include "gfxPoint.h"
+#include "gfxRect.h"
+#include "gfxMatrix.h"
+#include "gfxPattern.h"
+#include "gfxPath.h"
+#include "nsTArray.h"
+#include "nsAutoPtr.h"
+#include "mozilla/gfx/2D.h"
+typedef struct _cairo cairo_t;
+struct GlyphBufferAzure;
+template <typename T> class FallibleTArray;
+/**
+* This is the main class for doing actual drawing. It is initialized using
+* a surface and can be drawn on. It manages various state information like
+* a current transformation matrix (CTM), a current path, current color,
+* etc.
+*
+* All drawing happens by creating a path and then stroking or filling it.
+* The functions like Rectangle and Arc do not do any drawing themselves.
+* When a path is drawn (stroked or filled), it is filled/stroked with a
+* pattern set by SetPattern, SetColor or SetSource.
+*
+* Note that the gfxContext takes coordinates in device pixels,
+* as opposed to app units.
+*/
+class gfxContext {
+NS_INLINE_DECL_REFCOUNTING(gfxContext)
+public:
+/**
+* Initialize this context from a surface.
+*/
+gfxContext(gfxASurface *surface);
+/**
+* Initialize this context from a DrawTarget.
+* Strips any transform from aTarget.
+* aTarget will be flushed in the gfxContext's destructor.
+*/
+gfxContext(mozilla::gfx::DrawTarget *aTarget,
+const mozilla::gfx::Point& aDeviceOffset = mozilla::gfx::Point());
+~gfxContext();
+/**
+* Create a new gfxContext wrapping aTarget and preserving aTarget's
+* transform. Note that the transform is moved from aTarget to the resulting
+* gfxContext, aTarget will no longer have its transform.
+*/
+static already_AddRefed<gfxContext> ContextForDrawTarget(mozilla::gfx::DrawTarget* aTarget);
+/**
+* Return the surface that this gfxContext was created with
+*/
+gfxASurface *OriginalSurface();
+/**
+* Return the current transparency group target, if any, along
+* with its device offsets from the top.  If no group is
+* active, returns the surface the gfxContext was created with,
+* and 0,0 in dx,dy.
+*/
+already_AddRefed<gfxASurface> CurrentSurface(gfxFloat *dx, gfxFloat *dy);
+already_AddRefed<gfxASurface> CurrentSurface() {
+return CurrentSurface(nullptr, nullptr);
+}
+/**
+* Return the raw cairo_t object.
+* XXX this should go away at some point.
+*/
+cairo_t *GetCairo();
+mozilla::gfx::DrawTarget *GetDrawTarget() { return mDT; }
+/**
+* Returns true if the cairo context is in an error state.
+*/
+bool HasError();
+/**
+** State
+**/
+// XXX document exactly what bits are saved
+void Save();
+void Restore();
+/**
+** Paths & Drawing
+**/
+/**
+* Stroke the current path using the current settings (such as line
+* width and color).
+* A path is set up using functions such as Line, Rectangle and Arc.
+*
+* Does not consume the current path.
+*/
+void Stroke();
+/**
+* Fill the current path according to the current settings.
+*
+* Does not consume the current path.
+*/
+void Fill();
+/**
+* Fill the current path according to the current settings and
+* with |aOpacity|.
+*
+* Does not consume the current path.
+*/
+void FillWithOpacity(gfxFloat aOpacity);
+/**
+* Forgets the current path.
+*/
+void NewPath();
+/**
+* Closes the path, i.e. connects the last drawn point to the first one.
+*
+* Filling a path will implicitly close it.
+*/
+void ClosePath();
+/**
+* Copies the current path and returns the copy.
+*/
+already_AddRefed<gfxPath> CopyPath();
+/**
+* Appends the given path to the current path.
+*/
+void SetPath(gfxPath* path);
+/**
+* Moves the pen to a new point without drawing a line.
+*/
+void MoveTo(const gfxPoint& pt);
+/**
+* Creates a new subpath starting at the current point.
+* Equivalent to MoveTo(CurrentPoint()).
+*/
+void NewSubPath();
+/**
+* Returns the current point in the current path.
+*/
+gfxPoint CurrentPoint();
+/**
+* Draws a line from the current point to pt.
+*
+* @see MoveTo
+*/
+void LineTo(const gfxPoint& pt);
+/**
+* Draws a cubic Bézier curve with control points pt1, pt2 and pt3.
+*/
+void CurveTo(const gfxPoint& pt1, const gfxPoint& pt2, const gfxPoint& pt3);
+/**
+* Draws a quadratic Bézier curve with control points pt1, pt2 and pt3.
+*/
+void QuadraticCurveTo(const gfxPoint& pt1, const gfxPoint& pt2);
+/**
+* Draws a clockwise arc (i.e. a circle segment).
+* @param center The center of the circle
+* @param radius The radius of the circle
+* @param angle1 Starting angle for the segment
+* @param angle2 Ending angle
+*/
+void Arc(const gfxPoint& center, gfxFloat radius,
+gfxFloat angle1, gfxFloat angle2);
+/**
+* Draws a counter-clockwise arc (i.e. a circle segment).
+* @param center The center of the circle
+* @param radius The radius of the circle
+* @param angle1 Starting angle for the segment
+* @param angle2 Ending angle
+*/
+void NegativeArc(const gfxPoint& center, gfxFloat radius,
+gfxFloat angle1, gfxFloat angle2);
+// path helpers
+/**
+* Draws a line from start to end.
+*/
+void Line(const gfxPoint& start, const gfxPoint& end); // XXX snapToPixels option?
+/**
+* Draws the rectangle given by rect.
+* @param snapToPixels ?
+*/
+void Rectangle(const gfxRect& rect, bool snapToPixels = false);
+void SnappedRectangle(const gfxRect& rect) { return Rectangle(rect, true); }
+/**
+* Draw an ellipse at the center corner with the given dimensions.
+* It extends dimensions.width / 2.0 in the horizontal direction
+* from the center, and dimensions.height / 2.0 in the vertical
+* direction.
+*/
+void Ellipse(const gfxPoint& center, const gfxSize& dimensions);
+/**
+* Draw a polygon from the given points
+*/
+void Polygon(const gfxPoint *points, uint32_t numPoints);
+/*
+* Draw a rounded rectangle, with the given outer rect and
+* corners.  The corners specify the radii of the two axes of an
+* ellipse (the horizontal and vertical directions given by the
+* width and height, respectively).  By default the ellipse is
+* drawn in a clockwise direction; if draw_clockwise is false,
+* then it's drawn counterclockwise.
+*/
+void RoundedRectangle(const gfxRect& rect,
+const gfxCornerSizes& corners,
+bool draw_clockwise = true);
+/**
+** Transformation Matrix manipulation
+**/
+/**
+* Adds a translation to the current matrix. This translation takes place
+* before the previously set transformations.
+*/
+void Translate(const gfxPoint& pt);
+/**
+* Adds a scale to the current matrix. This scaling takes place before the
+* previously set transformations.
+*/
+void Scale(gfxFloat x, gfxFloat y);
+/**
+* Adds a rotation around the origin to the current matrix. This rotation
+* takes place before the previously set transformations.
+*
+* @param angle The angle in radians.
+*/
+void Rotate(gfxFloat angle);
+/**
+* Post-multiplies 'other' onto the current CTM, i.e. this
+* matrix's transformation will take place before the previously set
+* transformations.
+*/
+void Multiply(const gfxMatrix& other);
+/**
+* As "Multiply", but also nudges any entries in the resulting matrix that
+* are close to an integer to that integer, to correct for
+* compounded rounding errors.
+*/
+void MultiplyAndNudgeToIntegers(const gfxMatrix& other);
+/**
+* Replaces the current transformation matrix with matrix.
+*/
+void SetMatrix(const gfxMatrix& matrix);
+/**
+* Sets the transformation matrix to the identity matrix.
+*/
+void IdentityMatrix();
+/**
+* Returns the current transformation matrix.
+*/
+gfxMatrix CurrentMatrix() const;
+/**
+* Snap components of the current matrix that are close to integers
+* to integers. In particular, components that are integral when
+* converted to single precision are set to those integers.
+*/
+void NudgeCurrentMatrixToIntegers();
+/**
+* Converts a point from device to user coordinates using the inverse
+* transformation matrix.
+*/
+gfxPoint DeviceToUser(const gfxPoint& point) const;
+/**
+* Converts a size from device to user coordinates. This does not apply
+* translation components of the matrix.
+*/
+gfxSize DeviceToUser(const gfxSize& size) const;
+/**
+* Converts a rectangle from device to user coordinates; this has the
+* same effect as using DeviceToUser on both the rectangle's point and
+* size.
+*/
+gfxRect DeviceToUser(const gfxRect& rect) const;
+/**
+* Converts a point from user to device coordinates using the transformation
+* matrix.
+*/
+gfxPoint UserToDevice(const gfxPoint& point) const;
+/**
+* Converts a size from user to device coordinates. This does not apply
+* translation components of the matrix.
+*/
+gfxSize UserToDevice(const gfxSize& size) const;
+/**
+* Converts a rectangle from user to device coordinates.  The
+* resulting rectangle is the minimum device-space rectangle that
+* encloses the user-space rectangle given.
+*/
+gfxRect UserToDevice(const gfxRect& rect) const;
+/**
+* Takes the given rect and tries to align it to device pixels.  If
+* this succeeds, the method will return true, and the rect will
+* be in device coordinates (already transformed by the CTM).  If it
+* fails, the method will return false, and the rect will not be
+* changed.
+*
+* If ignoreScale is true, then snapping will take place even if
+* the CTM has a scale applied.  Snapping never takes place if
+* there is a rotation in the CTM.
+*/
+bool UserToDevicePixelSnapped(gfxRect& rect, bool ignoreScale = false) const;
+/**
+* Takes the given point and tries to align it to device pixels.  If
+* this succeeds, the method will return true, and the point will
+* be in device coordinates (already transformed by the CTM).  If it
+* fails, the method will return false, and the point will not be
+* changed.
+*
+* If ignoreScale is true, then snapping will take place even if
+* the CTM has a scale applied.  Snapping never takes place if
+* there is a rotation in the CTM.
+*/
+bool UserToDevicePixelSnapped(gfxPoint& pt, bool ignoreScale = false) const;
+/**
+* Attempts to pixel snap the rectangle, add it to the current
+* path, and to set pattern as the current painting source.  This
+* should be used for drawing filled pixel-snapped rectangles (like
+* images), because the CTM at the time of the SetPattern call needs
+* to have a snapped translation, or you get smeared images.
+*/
+void PixelSnappedRectangleAndSetPattern(const gfxRect& rect, gfxPattern *pattern);
+/**
+** Painting sources
+**/
+/**
+* Set a solid color to use for drawing.  This color is in the device color space
+* and is not transformed.
+*/
+void SetDeviceColor(const gfxRGBA& c);
+/**
+* Gets the current color.  It's returned in the device color space.
+* returns false if there is something other than a color
+*         set as the current source (pattern, surface, etc)
+*/
+bool GetDeviceColor(gfxRGBA& c);
+/**
+* Set a solid color in the sRGB color space to use for drawing.
+* If CMS is not enabled, the color is treated as a device-space color
+* and this call is identical to SetDeviceColor().
+*/
+void SetColor(const gfxRGBA& c);
+/**
+* Uses a surface for drawing. This is a shorthand for creating a
+* pattern and setting it.
+*
+* @param offset from the source surface, to use only part of it.
+*        May need to make it negative.
+*/
+void SetSource(gfxASurface *surface, const gfxPoint& offset = gfxPoint(0.0, 0.0));
+/**
+* Uses a pattern for drawing.
+*/
+void SetPattern(gfxPattern *pattern);
+/**
+* Get the source pattern (solid color, normal pattern, surface, etc)
+*/
+already_AddRefed<gfxPattern> GetPattern();
+/**
+** Painting
+**/
+/**
+* Paints the current source surface/pattern everywhere in the current
+* clip region.
+*/
+void Paint(gfxFloat alpha = 1.0);
+/**
+** Painting with a Mask
+**/
+/**
+* Like Paint, except that it only draws the source where pattern is
+* non-transparent.
+*/
+void Mask(gfxPattern *pattern);
+/**
+* Shorthand for creating a pattern and calling the pattern-taking
+* variant of Mask.
+*/
+void Mask(gfxASurface *surface, const gfxPoint& offset = gfxPoint(0.0, 0.0));
+void Mask(mozilla::gfx::SourceSurface *surface, const mozilla::gfx::Point& offset = mozilla::gfx::Point());
+/**
+** Shortcuts
+**/
+/**
+* Creates a new path with a rectangle from 0,0 to size.w,size.h
+* and calls cairo_fill.
+*/
+void DrawSurface(gfxASurface *surface, const gfxSize& size);
+/**
+** Line Properties
+**/
+typedef enum {
+gfxLineSolid,
+gfxLineDashed,
+gfxLineDotted
+} gfxLineType;
+void SetDash(gfxLineType ltype);
+void SetDash(gfxFloat *dashes, int ndash, gfxFloat offset);
+// Return true if dashing is set, false if it's not enabled or the
+// context is in an error state.  |offset| can be nullptr to mean
+// "don't care".
+bool CurrentDash(FallibleTArray<gfxFloat>& dashes, gfxFloat* offset) const;
+// Returns 0.0 if dashing isn't enabled.
+gfxFloat CurrentDashOffset() const;
+/**
+* Sets the line width that's used for line drawing.
+*/
+void SetLineWidth(gfxFloat width);
+/**
+* Returns the currently set line width.
+*
+* @see SetLineWidth
+*/
+gfxFloat CurrentLineWidth() const;
+enum GraphicsLineCap {
+LINE_CAP_BUTT,
+LINE_CAP_ROUND,
+LINE_CAP_SQUARE
+};
+/**
+* Sets the line caps, i.e. how line endings are drawn.
+*/
+void SetLineCap(GraphicsLineCap cap);
+GraphicsLineCap CurrentLineCap() const;
+enum GraphicsLineJoin {
+LINE_JOIN_MITER,
+LINE_JOIN_ROUND,
+LINE_JOIN_BEVEL
+};
+/**
+* Sets the line join, i.e. how the connection between two lines is
+* drawn.
+*/
+void SetLineJoin(GraphicsLineJoin join);
+GraphicsLineJoin CurrentLineJoin() const;
+void SetMiterLimit(gfxFloat limit);
+gfxFloat CurrentMiterLimit() const;
+/**
+** Fill Properties
+**/
+enum FillRule {
+FILL_RULE_WINDING,
+FILL_RULE_EVEN_ODD
+};
+void SetFillRule(FillRule rule);
+FillRule CurrentFillRule() const;
+/**
+** Operators and Rendering control
+**/
+// define enum for operators (clear, src, dst, etc)
+enum GraphicsOperator {
+OPERATOR_CLEAR,
+OPERATOR_SOURCE,
+OPERATOR_OVER,
+OPERATOR_IN,
+OPERATOR_OUT,
+OPERATOR_ATOP,
+OPERATOR_DEST,
+OPERATOR_DEST_OVER,
+OPERATOR_DEST_IN,
+OPERATOR_DEST_OUT,
+OPERATOR_DEST_ATOP,
+OPERATOR_XOR,
+OPERATOR_ADD,
+OPERATOR_SATURATE,
+OPERATOR_MULTIPLY,
+OPERATOR_SCREEN,
+OPERATOR_OVERLAY,
+OPERATOR_DARKEN,
+OPERATOR_LIGHTEN,
+OPERATOR_COLOR_DODGE,
+OPERATOR_COLOR_BURN,
+OPERATOR_HARD_LIGHT,
+OPERATOR_SOFT_LIGHT,
+OPERATOR_DIFFERENCE,
+OPERATOR_EXCLUSION,
+OPERATOR_HUE,
+OPERATOR_SATURATION,
+OPERATOR_COLOR,
+OPERATOR_LUMINOSITY
+};
+/**
+* Sets the operator used for all further drawing. The operator affects
+* how drawing something will modify the destination. For example, the
+* OVER operator will do alpha blending of source and destination, while
+* SOURCE will replace the destination with the source.
+*
+* Note that if the flag FLAG_SIMPLIFY_OPERATORS is set on this
+* gfxContext, the actual operator set might change for optimization
+* purposes.  Check the comments below around that flag.
+*/
+void SetOperator(GraphicsOperator op);
+GraphicsOperator CurrentOperator() const;
+/**
+* MODE_ALIASED means that only pixels whose centers are in the drawn area
+* should be modified, and they should be modified to take the value drawn
+* at the pixel center.
+*/
+enum AntialiasMode {
+MODE_ALIASED,
+MODE_COVERAGE
+};
+void SetAntialiasMode(AntialiasMode mode);
+AntialiasMode CurrentAntialiasMode() const;
+/**
+** Clipping
+**/
+/**
+* Clips all further drawing to the current path.
+* This does not consume the current path.
+*/
+void Clip();
+/**
+* Undoes any clipping. Further drawings will only be restricted by the
+* surface dimensions.
+*/
+void ResetClip();
+/**
+* Helper functions that will create a rect path and call Clip().
+* Any current path will be destroyed by these functions!
+*/
+void Clip(const gfxRect& rect); // will clip to a rect
+/**
+* This will ensure that the surface actually has its clip set.
+* Useful if you are doing native drawing.
+*/
+void UpdateSurfaceClip();
+/**
+* This will return the current bounds of the clip region in user
+* space.
+*/
+gfxRect GetClipExtents();
+/**
+* Returns true if the given rectangle is fully contained in the current clip.
+* This is conservative; it may return false even when the given rectangle is
+* fully contained by the current clip.
+*/
+bool ClipContainsRect(const gfxRect& aRect);
+/**
+* Groups
+*/
+void PushGroup(gfxContentType content = gfxContentType::COLOR);
+/**
+* Like PushGroup, but if the current surface is gfxContentType::COLOR and
+* content is gfxContentType::COLOR_ALPHA, makes the pushed surface gfxContentType::COLOR
+* instead and copies the contents of the current surface to the pushed
+* surface. This is good for pushing opacity groups, since blending the
+* group back to the current surface with some alpha applied will give
+* the correct results and using an opaque pushed surface gives better
+* quality and performance.
+* This API really only makes sense if you do a PopGroupToSource and
+* immediate Paint with OPERATOR_OVER.
+*/
+void PushGroupAndCopyBackground(gfxContentType content = gfxContentType::COLOR);
+already_AddRefed<gfxPattern> PopGroup();
+void PopGroupToSource();
+/**
+** Hit Testing - check if given point is in the current path
+**/
+bool PointInFill(const gfxPoint& pt);
+bool PointInStroke(const gfxPoint& pt);
+/**
+** Extents - returns user space extent of current path
+**/
+gfxRect GetUserPathExtent();
+gfxRect GetUserFillExtent();
+gfxRect GetUserStrokeExtent();
+mozilla::gfx::Point GetDeviceOffset() const;
+/**
+** Flags
+**/
+enum {
+/* If this flag is set, operators other than CLEAR, SOURCE, or
+* OVER will be converted to OVER before being sent to cairo.
+*
+* This is most useful with a printing surface, where
+* operators such as ADD are used to avoid seams for on-screen
+* display, but where such errors aren't noticeable in print.
+* This approach is currently used in border rendering.
+*
+* However, when printing complex renderings such as SVG,
+* care should be taken to clear this flag.
+*/
+FLAG_SIMPLIFY_OPERATORS = (1 << 0),
+/**
+* When this flag is set, snapping to device pixels is disabled.
+* It simply never does anything.
+*/
+FLAG_DISABLE_SNAPPING = (1 << 1),
+/**
+* Disable copying of backgrounds in PushGroupAndCopyBackground.
+*/
+FLAG_DISABLE_COPY_BACKGROUND = (1 << 2)
+};
+void SetFlag(int32_t aFlag) { mFlags |= aFlag; }
+void ClearFlag(int32_t aFlag) { mFlags &= ~aFlag; }
+int32_t GetFlags() const { return mFlags; }
+bool IsCairo() const { return !mDT; }
+// Work out whether cairo will snap inter-glyph spacing to pixels.
+void GetRoundOffsetsToPixels(bool *aRoundX, bool *aRoundY);
+#ifdef MOZ_DUMP_PAINTING
+/**
+* Debug functions to encode the current surface as a PNG and export it.
+*/
+/**
+* Writes a binary PNG file.
+*/
+void WriteAsPNG(const char* aFile);
+/**
+* Write as a PNG encoded Data URL to stdout.
+*/
+void DumpAsDataURL();
+/**
+* Copy a PNG encoded Data URL to the clipboard.
+*/
+void CopyAsDataURL();
+#endif
+static mozilla::gfx::UserDataKey sDontUseAsSourceKey;
+private:
+friend class GeneralPattern;
+friend struct GlyphBufferAzure;
+typedef mozilla::gfx::Matrix Matrix;
+typedef mozilla::gfx::DrawTarget DrawTarget;
+typedef mozilla::gfx::Color Color;
+typedef mozilla::gfx::StrokeOptions StrokeOptions;
+typedef mozilla::gfx::Float Float;
+typedef mozilla::gfx::Rect Rect;
+typedef mozilla::gfx::CompositionOp CompositionOp;
+typedef mozilla::gfx::Path Path;
+typedef mozilla::gfx::PathBuilder PathBuilder;
+typedef mozilla::gfx::SourceSurface SourceSurface;
+struct AzureState {
+AzureState()
+: op(mozilla::gfx::CompositionOp::OP_OVER)
+, opIsClear(false)
+, color(0, 0, 0, 1.0f)
+, clipWasReset(false)
+, fillRule(mozilla::gfx::FillRule::FILL_WINDING)
+, aaMode(mozilla::gfx::AntialiasMode::SUBPIXEL)
+, patternTransformChanged(false)
+{}
+mozilla::gfx::CompositionOp op;
+bool opIsClear;
+Color color;
+nsRefPtr<gfxPattern> pattern;
+nsRefPtr<gfxASurface> sourceSurfCairo;
+mozilla::RefPtr<SourceSurface> sourceSurface;
+mozilla::gfx::Point sourceSurfaceDeviceOffset;
+Matrix surfTransform;
+Matrix transform;
+struct PushedClip {
+mozilla::RefPtr<Path> path;
+Rect rect;
+Matrix transform;
+};
+nsTArray<PushedClip> pushedClips;
+nsTArray<Float> dashPattern;
+bool clipWasReset;
+mozilla::gfx::FillRule fillRule;
+StrokeOptions strokeOptions;
+mozilla::RefPtr<DrawTarget> drawTarget;
+mozilla::RefPtr<DrawTarget> parentTarget;
+mozilla::gfx::AntialiasMode aaMode;
+bool patternTransformChanged;
+Matrix patternTransform;
+// This is used solely for using minimal intermediate surface size.
+mozilla::gfx::Point deviceOffset;
+};
+// This ensures mPath contains a valid path (in user space!)
+void EnsurePath();
+// This ensures mPathBuilder contains a valid PathBuilder (in user space!)
+void EnsurePathBuilder();
+void FillAzure(mozilla::gfx::Float aOpacity);
+void PushClipsToDT(mozilla::gfx::DrawTarget *aDT);
+CompositionOp GetOp();
+void ChangeTransform(const mozilla::gfx::Matrix &aNewMatrix, bool aUpdatePatternTransform = true);
+Rect GetAzureDeviceSpaceClipBounds();
+Matrix GetDeviceTransform() const;
+Matrix GetDTTransform() const;
+void PushNewDT(gfxContentType content);
+bool mPathIsRect;
+bool mTransformChanged;
+Matrix mPathTransform;
+Rect mRect;
+mozilla::RefPtr<PathBuilder> mPathBuilder;
+mozilla::RefPtr<Path> mPath;
+Matrix mTransform;
+nsTArray<AzureState> mStateStack;
+AzureState &CurrentState() { return mStateStack[mStateStack.Length() - 1]; }
+const AzureState &CurrentState() const { return mStateStack[mStateStack.Length() - 1]; }
+cairo_t *mCairo;
+cairo_t *mRefCairo;
+nsRefPtr<gfxASurface> mSurface;
+int32_t mFlags;
+mozilla::RefPtr<DrawTarget> mDT;
+mozilla::RefPtr<DrawTarget> mOriginalDT;
+};
+/**
+* Sentry helper class for functions with multiple return points that need to
+* call Save() on a gfxContext and have Restore() called automatically on the
+* gfxContext before they return.
+*/
+class gfxContextAutoSaveRestore
+{
+public:
+gfxContextAutoSaveRestore() : mContext(nullptr) {}
+gfxContextAutoSaveRestore(gfxContext *aContext) : mContext(aContext) {
+mContext->Save();
+}
+~gfxContextAutoSaveRestore() {
+if (mContext) {
+mContext->Restore();
+}
+}
+void SetContext(gfxContext *aContext) {
+NS_ASSERTION(!mContext, "Not going to call Restore() on some context!!!");
+mContext = aContext;
+mContext->Save();
+}
+void Reset(gfxContext *aContext) {
+// Do the equivalent of destroying and re-creating this object.
+NS_PRECONDITION(aContext, "must provide a context");
+if (mContext) {
+mContext->Restore();
+}
+mContext = aContext;
+mContext->Save();
+}
+private:
+gfxContext *mContext;
+};
+/**
+* Sentry helper class for functions with multiple return points that need to
+* back up the current path of a context and have it automatically restored
+* before they return. This class assumes that the transformation matrix will
+* be the same when Save and Restore are called. The calling function must
+* ensure that this is the case or the path will be copied incorrectly.
+*/
+class gfxContextPathAutoSaveRestore
+{
+public:
+gfxContextPathAutoSaveRestore() : mContext(nullptr) {}
+gfxContextPathAutoSaveRestore(gfxContext *aContext, bool aSave = true) : mContext(aContext)
+{
+if (aSave)
+Save();
+}
+~gfxContextPathAutoSaveRestore()
+{
+Restore();
+}
+void SetContext(gfxContext *aContext, bool aSave = true)
+{
+mContext = aContext;
+if (aSave)
+Save();
+}
+/**
+* If a path is already saved, does nothing. Else copies the current path
+* so that it may be restored.
+*/
+void Save()
+{
+if (!mPath && mContext) {
+mPath = mContext->CopyPath();
+}
+}
+/**
+* If no path is saved, does nothing. Else replaces the context's path with
+* a copy of the saved one, and clears the saved path.
+*/
+void Restore()
+{
+if (mPath) {
+mContext->SetPath(mPath);
+mPath = nullptr;
+}
+}
+private:
+gfxContext *mContext;
+nsRefPtr<gfxPath> mPath;
+};
+/**
+* Sentry helper class for functions with multiple return points that need to
+* back up the current matrix of a context and have it automatically restored
+* before they return.
+*/
+class gfxContextMatrixAutoSaveRestore
+{
+public:
+gfxContextMatrixAutoSaveRestore() :
+mContext(nullptr)
+{
+}
+gfxContextMatrixAutoSaveRestore(gfxContext *aContext) :
+mContext(aContext), mMatrix(aContext->CurrentMatrix())
+{
+}
+~gfxContextMatrixAutoSaveRestore()
+{
+if (mContext) {
+mContext->SetMatrix(mMatrix);
+}
+}
+void SetContext(gfxContext *aContext)
+{
+NS_ASSERTION(!mContext, "Not going to restore the matrix on some context!");
+mContext = aContext;
+mMatrix = aContext->CurrentMatrix();
+}
+void Restore()
+{
+if (mContext) {
+mContext->SetMatrix(mMatrix);
+}
+}
+const gfxMatrix& Matrix()
+{
+MOZ_ASSERT(mContext, "mMatrix doesn't contain a useful matrix");
+return mMatrix;
+}
+private:
+gfxContext *mContext;
+gfxMatrix   mMatrix;
+};
+class gfxContextAutoDisableSubpixelAntialiasing {
+public:
+gfxContextAutoDisableSubpixelAntialiasing(gfxContext *aContext, bool aDisable)
+{
+if (aDisable) {
+if (aContext->IsCairo()) {
+mSurface = aContext->CurrentSurface();
+if (!mSurface) {
+return;
+}
+mSubpixelAntialiasingEnabled = mSurface->GetSubpixelAntialiasingEnabled();
+mSurface->SetSubpixelAntialiasingEnabled(false);
+} else {
+mDT = aContext->GetDrawTarget();
+mSubpixelAntialiasingEnabled = mDT->GetPermitSubpixelAA();
+mDT->SetPermitSubpixelAA(false);
+}
+}
+}
+~gfxContextAutoDisableSubpixelAntialiasing()
+{
+if (mSurface) {
+mSurface->SetSubpixelAntialiasingEnabled(mSubpixelAntialiasingEnabled);
+} else if (mDT) {
+mDT->SetPermitSubpixelAA(mSubpixelAntialiasingEnabled);
+}
+}
+private:
+nsRefPtr<gfxASurface> mSurface;
+mozilla::RefPtr<mozilla::gfx::DrawTarget> mDT;
+bool mSubpixelAntialiasingEnabled;
+};
+#endif /* GFX_CONTEXT_H */

The Tor Browser / file comparison

comparison: gfx/thebes/gfxContext.h

gfx/thebes/gfxContext.h