mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-21 09:15:35 +00:00
11ac9e9cf8
* Remove redundant virtual keywords
* Mark all destructors of inheriting classes as virtual for clarity
* Mark all classes without virtual destructor as final (exposed errors)
* Make destructor virtual where it needed to be (some were missing)
* Replace empty ({}) code declaration in header with = default
* Remove virtual unused methods
I probably missed some, it quickly became a rabbit hole.
Differential Revision: https://phabricator.services.mozilla.com/D26060
--HG--
extra : moz-landing-system : lando
145 lines
5.5 KiB
C++
145 lines
5.5 KiB
C++
/* -*- 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/. */
|
|
|
|
#ifndef GFX_BASICLAYERSIMPL_H
|
|
#define GFX_BASICLAYERSIMPL_H
|
|
|
|
#include "BasicImplData.h" // for BasicImplData
|
|
#include "BasicLayers.h" // for BasicLayerManager
|
|
#include "ReadbackLayer.h" // for ReadbackLayer
|
|
#include "gfxContext.h" // for gfxContext, etc
|
|
#include "mozilla/Attributes.h" // for MOZ_STACK_CLASS
|
|
#include "mozilla/Maybe.h" // for Maybe
|
|
#include "nsDebug.h" // for NS_ASSERTION
|
|
#include "nsISupportsImpl.h" // for gfxContext::Release, etc
|
|
#include "nsRegion.h" // for nsIntRegion
|
|
|
|
namespace mozilla {
|
|
namespace gfx {
|
|
class DrawTarget;
|
|
} // namespace gfx
|
|
|
|
namespace layers {
|
|
|
|
class AutoMoz2DMaskData;
|
|
class Layer;
|
|
|
|
class AutoSetOperator {
|
|
typedef mozilla::gfx::CompositionOp CompositionOp;
|
|
|
|
public:
|
|
AutoSetOperator(gfxContext* aContext, CompositionOp aOperator) {
|
|
if (aOperator != CompositionOp::OP_OVER) {
|
|
aContext->SetOp(aOperator);
|
|
mContext = aContext;
|
|
}
|
|
}
|
|
~AutoSetOperator() {
|
|
if (mContext) {
|
|
mContext->SetOp(CompositionOp::OP_OVER);
|
|
}
|
|
}
|
|
|
|
private:
|
|
RefPtr<gfxContext> mContext;
|
|
};
|
|
|
|
class BasicReadbackLayer : public ReadbackLayer, public BasicImplData {
|
|
public:
|
|
explicit BasicReadbackLayer(BasicLayerManager* aLayerManager)
|
|
: ReadbackLayer(aLayerManager, static_cast<BasicImplData*>(this)) {
|
|
MOZ_COUNT_CTOR(BasicReadbackLayer);
|
|
}
|
|
|
|
protected:
|
|
virtual ~BasicReadbackLayer() { MOZ_COUNT_DTOR(BasicReadbackLayer); }
|
|
|
|
public:
|
|
void SetVisibleRegion(const LayerIntRegion& aRegion) override {
|
|
NS_ASSERTION(BasicManager()->InConstruction(),
|
|
"Can only set properties in construction phase");
|
|
ReadbackLayer::SetVisibleRegion(aRegion);
|
|
}
|
|
|
|
protected:
|
|
BasicLayerManager* BasicManager() {
|
|
return static_cast<BasicLayerManager*>(mManager);
|
|
}
|
|
};
|
|
|
|
/*
|
|
* Extract a mask surface for a mask layer
|
|
* Returns true and through outparams a surface for the mask layer if
|
|
* a mask layer is present and has a valid surface and transform;
|
|
* false otherwise.
|
|
* The transform for the layer will be put in aMaskData
|
|
*/
|
|
bool GetMaskData(Layer* aMaskLayer, const gfx::Point& aDeviceOffset,
|
|
AutoMoz2DMaskData* aMaskData);
|
|
|
|
already_AddRefed<gfx::SourceSurface> GetMaskForLayer(
|
|
Layer* aLayer, gfx::Matrix* aMaskTransform);
|
|
|
|
// Paint the current source to a context using a mask, if present
|
|
void PaintWithMask(gfxContext* aContext, float aOpacity, Layer* aMaskLayer);
|
|
|
|
// Fill the rect with the source, using a mask and opacity, if present
|
|
void FillRectWithMask(gfx::DrawTarget* aDT, const gfx::Rect& aRect,
|
|
const gfx::Color& aColor,
|
|
const gfx::DrawOptions& aOptions,
|
|
gfx::SourceSurface* aMaskSource = nullptr,
|
|
const gfx::Matrix* aMaskTransform = nullptr);
|
|
void FillRectWithMask(gfx::DrawTarget* aDT, const gfx::Rect& aRect,
|
|
gfx::SourceSurface* aSurface,
|
|
gfx::SamplingFilter aSamplingFilter,
|
|
const gfx::DrawOptions& aOptions,
|
|
gfx::ExtendMode aExtendMode,
|
|
gfx::SourceSurface* aMaskSource = nullptr,
|
|
const gfx::Matrix* aMaskTransform = nullptr,
|
|
const gfx::Matrix* aSurfaceTransform = nullptr);
|
|
void FillRectWithMask(gfx::DrawTarget* aDT, const gfx::Point& aDeviceOffset,
|
|
const gfx::Rect& aRect, gfx::SourceSurface* aSurface,
|
|
gfx::SamplingFilter aSamplingFilter,
|
|
const gfx::DrawOptions& aOptions, Layer* aMaskLayer);
|
|
void FillRectWithMask(gfx::DrawTarget* aDT, const gfx::Point& aDeviceOffset,
|
|
const gfx::Rect& aRect, const gfx::Color& aColor,
|
|
const gfx::DrawOptions& aOptions, Layer* aMaskLayer);
|
|
|
|
void FillPathWithMask(gfx::DrawTarget* aDT, const gfx::Path* aPath,
|
|
const gfx::Rect& aClipRect, const gfx::Color& aColor,
|
|
const gfx::DrawOptions& aOptions,
|
|
gfx::SourceSurface* aMaskSource = nullptr,
|
|
const gfx::Matrix* aMaskTransform = nullptr);
|
|
void FillPathWithMask(gfx::DrawTarget* aDT, const gfx::Path* aPath,
|
|
const gfx::Rect& aClipRect, gfx::SourceSurface* aSurface,
|
|
gfx::SamplingFilter aSamplingFilter,
|
|
const gfx::DrawOptions& aOptions,
|
|
gfx::ExtendMode aExtendMode,
|
|
gfx::SourceSurface* aMaskSource,
|
|
const gfx::Matrix* aMaskTransform,
|
|
const gfx::Matrix* aSurfaceTransform);
|
|
|
|
BasicImplData* ToData(Layer* aLayer);
|
|
|
|
/**
|
|
* Returns the operator to be used when blending and compositing this layer.
|
|
* Currently there is no way to specify both a blending and a compositing
|
|
* operator other than normal and source over respectively.
|
|
*
|
|
* If the layer has
|
|
* an effective blend mode operator other than normal, as returned by
|
|
* GetEffectiveMixBlendMode, this operator is used for blending, and source
|
|
* over is used for compositing.
|
|
* If the blend mode for this layer is normal, the compositing operator
|
|
* returned by GetOperator is used.
|
|
*/
|
|
gfx::CompositionOp GetEffectiveOperator(Layer* aLayer);
|
|
|
|
} // namespace layers
|
|
} // namespace mozilla
|
|
|
|
#endif
|