gfx/layers/LayersTypes.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef GFX_LAYERSTYPES_H
   7 #define GFX_LAYERSTYPES_H
   8
   9 #include <stdint.h>                     // for uint32_t
  10 #include "nsPoint.h"                    // for nsIntPoint
  11 #include "nsRegion.h"
  12
  13 #include "mozilla/TypedEnum.h"
  14 #include "mozilla/TypedEnumBits.h"
  15
  16 #ifdef MOZ_WIDGET_GONK
  17 #include <ui/GraphicBuffer.h>
  18 #endif
  19 #if defined(DEBUG) || defined(PR_LOGGING)
  20 #  include <stdio.h>            // FILE
  21 #  include "prlog.h"            // for PR_LOG
  22 #  ifndef MOZ_LAYERS_HAVE_LOG
  23 #    define MOZ_LAYERS_HAVE_LOG
  24 #  endif
  25 #  define MOZ_LAYERS_LOG(_args)                             \
  26   PR_LOG(LayerManager::GetLog(), PR_LOG_DEBUG, _args)
  27 #  define MOZ_LAYERS_LOG_IF_SHADOWABLE(layer, _args)         \
  28   do { if (layer->AsShadowableLayer()) { PR_LOG(LayerManager::GetLog(), PR_LOG_DEBUG, _args); } } while (0)
  29 #else
  30 struct PRLogModuleInfo;
  31 #  define MOZ_LAYERS_LOG(_args)
  32 #  define MOZ_LAYERS_LOG_IF_SHADOWABLE(layer, _args)
  33 #endif  // if defined(DEBUG) || defined(PR_LOGGING)
  34
  35 #define INVALID_OVERLAY -1
  36
  37 namespace android {
  38 class GraphicBuffer;
  39 }
  40
  41 namespace mozilla {
  42 namespace layers {
  43
  44 class TextureHost;
  45
  46 #undef NONE
  47 #undef OPAQUE
  48
  49 MOZ_BEGIN_ENUM_CLASS(LayersBackend, int8_t)
  50   LAYERS_NONE = 0,
  51   LAYERS_BASIC,
  52   LAYERS_OPENGL,
  53   LAYERS_D3D9,
  54   LAYERS_D3D10,
  55   LAYERS_D3D11,
  56   LAYERS_CLIENT,
  57   LAYERS_LAST
  58 MOZ_END_ENUM_CLASS(LayersBackend)
  59
  60 MOZ_BEGIN_ENUM_CLASS(BufferMode, int8_t)
  61   BUFFER_NONE,
  62   BUFFERED
  63 MOZ_END_ENUM_CLASS(BufferMode)
  64
  65 MOZ_BEGIN_ENUM_CLASS(DrawRegionClip, int8_t)
  66   DRAW,
  67   NONE
  68 MOZ_END_ENUM_CLASS(DrawRegionClip)
  69
  70 MOZ_BEGIN_ENUM_CLASS(SurfaceMode, int8_t)
  71   SURFACE_NONE = 0,
  72   SURFACE_OPAQUE,
  73   SURFACE_SINGLE_CHANNEL_ALPHA,
  74   SURFACE_COMPONENT_ALPHA
  75 MOZ_END_ENUM_CLASS(SurfaceMode)
  76
  77 // LayerRenderState for Composer2D
  78 // We currently only support Composer2D using gralloc. If we want to be backed
  79 // by other surfaces we will need a more generic LayerRenderState.
  80 MOZ_BEGIN_ENUM_CLASS(LayerRenderStateFlags, int8_t)
  81   LAYER_RENDER_STATE_DEFAULT = 0,
  82   ORIGIN_BOTTOM_LEFT = 1 << 0,
  83   BUFFER_ROTATION = 1 << 1,
  84   // Notify Composer2D to swap the RB pixels of gralloc buffer
  85   FORMAT_RB_SWAP = 1 << 2,
  86   // We record opaqueness here alongside the actual surface we're going to
  87   // render. This avoids confusion when a layer might return different kinds
  88   // of surfaces over time (e.g. video frames).
  89   OPAQUE = 1 << 3
  90 MOZ_END_ENUM_CLASS(LayerRenderStateFlags)
  91 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(LayerRenderStateFlags)
  92
  93 // The 'ifdef MOZ_WIDGET_GONK' sadness here is because we don't want to include
  94 // android::sp unless we have to.
  95 struct LayerRenderState {
  96   LayerRenderState()
  97 #ifdef MOZ_WIDGET_GONK
  98     : mFlags(LayerRenderStateFlags::LAYER_RENDER_STATE_DEFAULT)
  99     , mHasOwnOffset(false)
 100     , mSurface(nullptr)
 101     , mOverlayId(INVALID_OVERLAY)
 102     , mTexture(nullptr)
 103 #endif
 104   {}
 105
 106 #ifdef MOZ_WIDGET_GONK
 107   LayerRenderState(android::GraphicBuffer* aSurface,
 108                    const nsIntSize& aSize,
 109                    LayerRenderStateFlags aFlags,
 110                    TextureHost* aTexture)
 111     : mFlags(aFlags)
 112     , mHasOwnOffset(false)
 113     , mSurface(aSurface)
 114     , mOverlayId(INVALID_OVERLAY)
 115     , mSize(aSize)
 116     , mTexture(aTexture)
 117   {}
 118
 119   bool OriginBottomLeft() const
 120   { return bool(mFlags & LayerRenderStateFlags::ORIGIN_BOTTOM_LEFT); }
 121
 122   bool BufferRotated() const
 123   { return bool(mFlags & LayerRenderStateFlags::BUFFER_ROTATION); }
 124
 125   bool FormatRBSwapped() const
 126   { return bool(mFlags & LayerRenderStateFlags::FORMAT_RB_SWAP); }
 127
 128   void SetOverlayId(const int32_t& aId)
 129   { mOverlayId = aId; }
 130 #endif
 131
 132   void SetOffset(const nsIntPoint& aOffset)
 133   {
 134     mOffset = aOffset;
 135     mHasOwnOffset = true;
 136   }
 137
 138   // see LayerRenderStateFlags
 139   LayerRenderStateFlags mFlags;
 140   // true if mOffset is applicable
 141   bool mHasOwnOffset;
 142   // the location of the layer's origin on mSurface
 143   nsIntPoint mOffset;
 144 #ifdef MOZ_WIDGET_GONK
 145   // surface to render
 146   android::sp<android::GraphicBuffer> mSurface;
 147   int32_t mOverlayId;
 148   // size of mSurface
 149   nsIntSize mSize;
 150   TextureHost* mTexture;
 151 #endif
 152 };
 153
 154 MOZ_BEGIN_ENUM_CLASS(ScaleMode, int8_t)
 155   SCALE_NONE,
 156   STRETCH,
 157   SENTINEL
 158 // Unimplemented - PRESERVE_ASPECT_RATIO_CONTAIN
 159 MOZ_END_ENUM_CLASS(ScaleMode)
 160
 161 struct EventRegions {
 162   nsIntRegion mHitRegion;
 163   nsIntRegion mDispatchToContentHitRegion;
 164
 165   EventRegions()
 166   {
 167   }
 168
 169   explicit EventRegions(nsIntRegion aHitRegion)
 170     : mHitRegion(aHitRegion)
 171   {
 172   }
 173
 174   bool operator==(const EventRegions& aRegions) const
 175   {
 176     return mHitRegion == aRegions.mHitRegion &&
 177            mDispatchToContentHitRegion == aRegions.mDispatchToContentHitRegion;
 178   }
 179   bool operator!=(const EventRegions& aRegions) const
 180   {
 181     return !(*this == aRegions);
 182   }
 183
 184   void OrWith(const EventRegions& aOther)
 185   {
 186     mHitRegion.OrWith(aOther.mHitRegion);
 187     mDispatchToContentHitRegion.OrWith(aOther.mDispatchToContentHitRegion);
 188   }
 189
 190   void AndWith(const nsIntRegion& aRegion)
 191   {
 192     mHitRegion.AndWith(aRegion);
 193     mDispatchToContentHitRegion.AndWith(aRegion);
 194   }
 195
 196   void Sub(const EventRegions& aMinuend, const nsIntRegion& aSubtrahend)
 197   {
 198     mHitRegion.Sub(aMinuend.mHitRegion, aSubtrahend);
 199     mDispatchToContentHitRegion.Sub(aMinuend.mDispatchToContentHitRegion, aSubtrahend);
 200   }
 201
 202   void ApplyTranslationAndScale(float aXTrans, float aYTrans, float aXScale, float aYScale)
 203   {
 204     mHitRegion.ScaleRoundOut(aXScale, aYScale);
 205     mDispatchToContentHitRegion.ScaleRoundOut(aXScale, aYScale);
 206
 207     mHitRegion.MoveBy(aXTrans, aYTrans);
 208     mDispatchToContentHitRegion.MoveBy(aXTrans, aYTrans);
 209   }
 210
 211   void Transform(const gfx3DMatrix& aTransform)
 212   {
 213     mHitRegion.Transform(aTransform);
 214     mDispatchToContentHitRegion.Transform(aTransform);
 215   }
 216
 217   bool IsEmpty() const
 218   {
 219     return mHitRegion.IsEmpty()
 220         && mDispatchToContentHitRegion.IsEmpty();
 221   }
 222
 223   nsCString ToString() const
 224   {
 225     nsCString result = mHitRegion.ToString();
 226     result.AppendLiteral(";dispatchToContent=");
 227     result.Append(mDispatchToContentHitRegion.ToString());
 228     return result;
 229   }
 230 };
 231
 232 // Bit flags that go on a ContainerLayer (or RefLayer) and override the
 233 // event regions in the entire subtree below. This is needed for propagating
 234 // various flags across processes since the child-process layout code doesn't
 235 // know about parent-process listeners or CSS rules.
 236 enum EventRegionsOverride {
 237   // The default, no flags set
 238   NoOverride             = 0,
 239   // Treat all hit regions in the subtree as dispatch-to-content
 240   ForceDispatchToContent = (1 << 0),
 241   // Treat all hit regions in the subtree as empty
 242   ForceEmptyHitRegion    = (1 << 1),
 243   // OR union of all valid bit flags, for use in BitFlagsEnumSerializer
 244   ALL_BITS               = (1 << 2) - 1
 245 };
 246
 247 MOZ_ALWAYS_INLINE EventRegionsOverride
 248 operator|(EventRegionsOverride a, EventRegionsOverride b)
 249 {
 250   return (EventRegionsOverride)((int)a | (int)b);
 251 }
 252
 253 MOZ_ALWAYS_INLINE EventRegionsOverride&
 254 operator|=(EventRegionsOverride& a, EventRegionsOverride b)
 255 {
 256   a = a | b;
 257   return a;
 258 }
 259
 260 } // namespace
 261 } // namespace
 262
 263 #endif /* GFX_LAYERSTYPES_H */