tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

DrawTargetOffset.cpp (9007B)

      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
      3 /* This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #include "DrawTargetOffset.h"
      8 #include "Logging.h"
      9 #include "PathHelpers.h"
     10 
     11 namespace mozilla {
     12 namespace gfx {
     13 
     14 DrawTargetOffset::DrawTargetOffset() = default;
     15 
     16 bool DrawTargetOffset::Init(DrawTarget* aDrawTarget, IntPoint aOrigin) {
     17  mDrawTarget = aDrawTarget;
     18  mOrigin = aOrigin;
     19  mDrawTarget->SetTransform(Matrix::Translation(-mOrigin.x, -mOrigin.y));
     20  mFormat = mDrawTarget->GetFormat();
     21  SetPermitSubpixelAA(IsOpaque(mFormat));
     22  return true;
     23 }
     24 
     25 already_AddRefed<SourceSurface> DrawTargetOffset::Snapshot() {
     26  RefPtr<SourceSurface> snapshot = mDrawTarget->Snapshot();
     27 
     28  if (!snapshot) {
     29    return nullptr;
     30  }
     31 
     32  return MakeAndAddRef<SourceSurfaceOffset>(snapshot, mOrigin);
     33 }
     34 
     35 void DrawTargetOffset::DetachAllSnapshots() {}
     36 
     37 // Skip the mClippedOut check since this is only used for Flush() which
     38 // should happen even if we're clipped.
     39 #define OFFSET_COMMAND(command) \
     40  void DrawTargetOffset::command() { mDrawTarget->command(); }
     41 #define OFFSET_COMMAND1(command, type1) \
     42  void DrawTargetOffset::command(type1 arg1) { mDrawTarget->command(arg1); }
     43 #define OFFSET_COMMAND3(command, type1, type2, type3)                  \
     44  void DrawTargetOffset::command(type1 arg1, type2 arg2, type3 arg3) { \
     45    mDrawTarget->command(arg1, arg2, arg3);                            \
     46  }
     47 #define OFFSET_COMMAND4(command, type1, type2, type3, type4)         \
     48  void DrawTargetOffset::command(type1 arg1, type2 arg2, type3 arg3, \
     49                                 type4 arg4) {                       \
     50    mDrawTarget->command(arg1, arg2, arg3, arg4);                    \
     51  }
     52 #define OFFSET_COMMAND5(command, type1, type2, type3, type4, type5)  \
     53  void DrawTargetOffset::command(type1 arg1, type2 arg2, type3 arg3, \
     54                                 type4 arg4, type5 arg5) {           \
     55    mDrawTarget->command(arg1, arg2, arg3, arg4, arg5);              \
     56  }
     57 
     58 OFFSET_COMMAND(Flush)
     59 OFFSET_COMMAND1(ClearRect, const Rect&)
     60 OFFSET_COMMAND4(MaskSurface, const Pattern&, SourceSurface*, Point,
     61                const DrawOptions&)
     62 OFFSET_COMMAND4(FillGlyphs, ScaledFont*, const GlyphBuffer&, const Pattern&,
     63                const DrawOptions&)
     64 OFFSET_COMMAND5(StrokeGlyphs, ScaledFont*, const GlyphBuffer&, const Pattern&,
     65                const StrokeOptions&, const DrawOptions&)
     66 OFFSET_COMMAND3(FillRoundedRect, const RoundedRect&, const Pattern&,
     67                const DrawOptions&)
     68 
     69 bool DrawTargetOffset::Draw3DTransformedSurface(SourceSurface* aSrc,
     70                                                const Matrix4x4& aMatrix) {
     71  return mDrawTarget->Draw3DTransformedSurface(aSrc, aMatrix);
     72 }
     73 
     74 OFFSET_COMMAND3(Mask, const Pattern&, const Pattern&, const DrawOptions&)
     75 
     76 void DrawTargetOffset::DrawFilter(FilterNode* aNode, const Rect& aSourceRect,
     77                                  const Point& aDestPoint,
     78                                  const DrawOptions& aOptions) {
     79  auto clone = mTransform;
     80  bool invertible = clone.Invert();
     81  // aSourceRect is in filter space. The filter outputs from aSourceRect need
     82  // to be drawn at aDestPoint in user space.
     83  Rect userSpaceSource = Rect(aDestPoint, aSourceRect.Size());
     84  if (invertible) {
     85    // Try to reduce the source rect so that it's not much bigger
     86    // than the draw target. The result is not minimal. Examples
     87    // are left as an exercise for the reader.
     88    auto destRect = Rect(mDrawTarget->GetRect() + mOrigin);
     89    Rect userSpaceBounds = clone.TransformBounds(destRect);
     90    userSpaceSource = userSpaceSource.Intersect(userSpaceBounds);
     91  }
     92 
     93  // Compute how much we moved the top-left of the source rect by, and use that
     94  // to compute the new dest point, and move our intersected source rect back
     95  // into the (new) filter space.
     96  Point shift = userSpaceSource.TopLeft() - aDestPoint;
     97  Rect filterSpaceSource =
     98      Rect(aSourceRect.TopLeft() + shift, userSpaceSource.Size());
     99  mDrawTarget->DrawFilter(aNode, filterSpaceSource, aDestPoint + shift,
    100                          aOptions);
    101 }
    102 
    103 void DrawTargetOffset::PushClip(const Path* aPath) {
    104  mDrawTarget->PushClip(aPath);
    105 }
    106 
    107 void DrawTargetOffset::PushClipRect(const Rect& aRect) {
    108  mDrawTarget->PushClipRect(aRect);
    109 }
    110 
    111 void DrawTargetOffset::PopClip() { mDrawTarget->PopClip(); }
    112 
    113 void DrawTargetOffset::CopySurface(SourceSurface* aSurface,
    114                                   const IntRect& aSourceRect,
    115                                   const IntPoint& aDestination) {
    116  IntPoint tileOrigin = mOrigin;
    117  // CopySurface ignores the transform, account for that here.
    118  mDrawTarget->CopySurface(aSurface, aSourceRect, aDestination - tileOrigin);
    119 }
    120 
    121 void DrawTargetOffset::SetTransform(const Matrix& aTransform) {
    122  Matrix mat = aTransform;
    123  mat.PostTranslate(Float(-mOrigin.x), Float(-mOrigin.y));
    124  mDrawTarget->SetTransform(mat);
    125 
    126  DrawTarget::SetTransform(aTransform);
    127 }
    128 
    129 void DrawTargetOffset::SetPermitSubpixelAA(bool aPermitSubpixelAA) {
    130  mDrawTarget->SetPermitSubpixelAA(aPermitSubpixelAA);
    131 }
    132 
    133 void DrawTargetOffset::DrawSurface(SourceSurface* aSurface, const Rect& aDest,
    134                                   const Rect& aSource,
    135                                   const DrawSurfaceOptions& aSurfaceOptions,
    136                                   const DrawOptions& aDrawOptions) {
    137  mDrawTarget->DrawSurface(aSurface, aDest, aSource, aSurfaceOptions,
    138                           aDrawOptions);
    139 }
    140 
    141 void DrawTargetOffset::FillRect(const Rect& aRect, const Pattern& aPattern,
    142                                const DrawOptions& aDrawOptions) {
    143  mDrawTarget->FillRect(aRect, aPattern, aDrawOptions);
    144 }
    145 
    146 void DrawTargetOffset::Stroke(const Path* aPath, const Pattern& aPattern,
    147                              const StrokeOptions& aStrokeOptions,
    148                              const DrawOptions& aDrawOptions) {
    149  mDrawTarget->Stroke(aPath, aPattern, aStrokeOptions, aDrawOptions);
    150 }
    151 
    152 void DrawTargetOffset::StrokeRect(const Rect& aRect, const Pattern& aPattern,
    153                                  const StrokeOptions& aStrokeOptions,
    154                                  const DrawOptions& aDrawOptions) {
    155  mDrawTarget->StrokeRect(aRect, aPattern, aStrokeOptions, aDrawOptions);
    156 }
    157 
    158 void DrawTargetOffset::StrokeLine(const Point& aStart, const Point& aEnd,
    159                                  const Pattern& aPattern,
    160                                  const StrokeOptions& aStrokeOptions,
    161                                  const DrawOptions& aDrawOptions) {
    162  mDrawTarget->StrokeLine(aStart, aEnd, aPattern, aStrokeOptions, aDrawOptions);
    163 }
    164 
    165 void DrawTargetOffset::Fill(const Path* aPath, const Pattern& aPattern,
    166                            const DrawOptions& aDrawOptions) {
    167  mDrawTarget->Fill(aPath, aPattern, aDrawOptions);
    168 }
    169 
    170 void DrawTargetOffset::PushLayer(bool aOpaque, Float aOpacity,
    171                                 SourceSurface* aMask,
    172                                 const Matrix& aMaskTransform,
    173                                 const IntRect& aBounds, bool aCopyBackground) {
    174  IntRect bounds = aBounds - mOrigin;
    175 
    176  mDrawTarget->PushLayer(aOpaque, aOpacity, aMask, aMaskTransform, bounds,
    177                         aCopyBackground);
    178  SetPermitSubpixelAA(mDrawTarget->GetPermitSubpixelAA());
    179 }
    180 
    181 already_AddRefed<SourceSurface> DrawTargetOffset::IntoLuminanceSource(
    182    LuminanceType aLuminanceType, float aOpacity) {
    183  RefPtr<SourceSurface> surface =
    184      mDrawTarget->IntoLuminanceSource(aLuminanceType, aOpacity);
    185 
    186  if (!surface) {
    187    return nullptr;
    188  }
    189 
    190  return MakeAndAddRef<SourceSurfaceOffset>(surface, mOrigin);
    191 }
    192 
    193 void DrawTargetOffset::PushLayerWithBlend(bool aOpaque, Float aOpacity,
    194                                          SourceSurface* aMask,
    195                                          const Matrix& aMaskTransform,
    196                                          const IntRect& aBounds,
    197                                          bool aCopyBackground,
    198                                          CompositionOp aOp) {
    199  IntRect bounds = aBounds - mOrigin;
    200 
    201  mDrawTarget->PushLayerWithBlend(aOpaque, aOpacity, aMask, aMaskTransform,
    202                                  bounds, aCopyBackground, aOp);
    203  SetPermitSubpixelAA(mDrawTarget->GetPermitSubpixelAA());
    204 }
    205 
    206 void DrawTargetOffset::PopLayer() {
    207  mDrawTarget->PopLayer();
    208  SetPermitSubpixelAA(mDrawTarget->GetPermitSubpixelAA());
    209 }
    210 
    211 RefPtr<DrawTarget> DrawTargetOffset::CreateClippedDrawTarget(
    212    const Rect& aBounds, SurfaceFormat aFormat) {
    213  RefPtr<DrawTarget> result;
    214  RefPtr<DrawTarget> dt =
    215      mDrawTarget->CreateClippedDrawTarget(aBounds, aFormat);
    216  if (dt) {
    217    result = gfx::Factory::CreateOffsetDrawTarget(dt, mOrigin);
    218    if (result) {
    219      result->SetTransform(mTransform);
    220    }
    221  }
    222  return result;
    223 }
    224 
    225 }  // namespace gfx
    226 }  // namespace mozilla