gfx/layers/client/ClientContainerLayer.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_CLIENTCONTAINERLAYER_H
   7 #define GFX_CLIENTCONTAINERLAYER_H
   8
   9 #include <stdint.h>                     // for uint32_t
  10 #include "ClientLayerManager.h"         // for ClientLayerManager, etc
  11 #include "Layers.h"                     // for Layer, ContainerLayer, etc
  12 #include "gfx3DMatrix.h"                // for gfx3DMatrix
  13 #include "gfxMatrix.h"                  // for gfxMatrix
  14 #include "gfxPlatform.h"                // for gfxPlatform
  15 #include "nsDebug.h"                    // for NS_ASSERTION
  16 #include "nsISupportsUtils.h"           // for NS_ADDREF, NS_RELEASE
  17 #include "nsRegion.h"                   // for nsIntRegion
  18 #include "nsTArray.h"                   // for nsAutoTArray
  19 #include "nsTraceRefcnt.h"              // for MOZ_COUNT_CTOR, etc
  20
  21 namespace mozilla {
  22 namespace layers {
  23
  24 class ShadowableLayer;
  25
  26 class ClientContainerLayer : public ContainerLayer,
  27                              public ClientLayer
  28 {
  29 public:
  30   ClientContainerLayer(ClientLayerManager* aManager) :
  31     ContainerLayer(aManager,
  32                    static_cast<ClientLayer*>(MOZ_THIS_IN_INITIALIZER_LIST()))
  33   {
  34     MOZ_COUNT_CTOR(ClientContainerLayer);
  35     mSupportsComponentAlphaChildren = true;
  36   }
  37   virtual ~ClientContainerLayer()
  38   {
  39     while (mFirstChild) {
  40       ContainerLayer::RemoveChild(mFirstChild);
  41     }
  42
  43     MOZ_COUNT_DTOR(ClientContainerLayer);
  44   }
  45
  46   virtual void RenderLayer()
  47   {
  48     if (GetMaskLayer()) {
  49       ToClientLayer(GetMaskLayer())->RenderLayer();
  50     }
  51
  52     // Setup mSupportsComponentAlphaChildren in the same way
  53     // that ContainerLayerComposite will do.
  54     if (UseIntermediateSurface()) {
  55       if (GetEffectiveVisibleRegion().GetNumRects() != 1 ||
  56           !(GetContentFlags() & Layer::CONTENT_OPAQUE))
  57       {
  58         const gfx3DMatrix& transform3D = GetEffectiveTransform();
  59         gfxMatrix transform;
  60         if (HasOpaqueAncestorLayer(this) &&
  61             transform3D.Is2D(&transform) &&
  62             !transform.HasNonIntegerTranslation()) {
  63           SetSupportsComponentAlphaChildren(
  64             gfxPlatform::ComponentAlphaEnabled());
  65         }
  66       }
  67     } else {
  68       SetSupportsComponentAlphaChildren(
  69         (GetContentFlags() & Layer::CONTENT_OPAQUE) ||
  70         (GetParent() && GetParent()->SupportsComponentAlphaChildren()));
  71     }
  72
  73     nsAutoTArray<Layer*, 12> children;
  74     SortChildrenBy3DZOrder(children);
  75
  76     for (uint32_t i = 0; i < children.Length(); i++) {
  77       if (children.ElementAt(i)->GetEffectiveVisibleRegion().IsEmpty()) {
  78         continue;
  79       }
  80
  81       ToClientLayer(children.ElementAt(i))->RenderLayer();
  82     }
  83   }
  84
  85   virtual void SetVisibleRegion(const nsIntRegion& aRegion)
  86   {
  87     NS_ASSERTION(ClientManager()->InConstruction(),
  88                  "Can only set properties in construction phase");
  89     ContainerLayer::SetVisibleRegion(aRegion);
  90   }
  91   virtual void InsertAfter(Layer* aChild, Layer* aAfter) MOZ_OVERRIDE
  92   {
  93     NS_ASSERTION(ClientManager()->InConstruction(),
  94                  "Can only set properties in construction phase");
  95     ClientManager()->InsertAfter(ClientManager()->Hold(this),
  96                                  ClientManager()->Hold(aChild),
  97                                  aAfter ? ClientManager()->Hold(aAfter) : nullptr);
  98     ContainerLayer::InsertAfter(aChild, aAfter);
  99   }
 100
 101   virtual void RemoveChild(Layer* aChild) MOZ_OVERRIDE
 102   {
 103     NS_ASSERTION(ClientManager()->InConstruction(),
 104                  "Can only set properties in construction phase");
 105     ClientManager()->RemoveChild(ClientManager()->Hold(this),
 106                                  ClientManager()->Hold(aChild));
 107     ContainerLayer::RemoveChild(aChild);
 108   }
 109
 110   virtual void RepositionChild(Layer* aChild, Layer* aAfter) MOZ_OVERRIDE
 111   {
 112     NS_ASSERTION(ClientManager()->InConstruction(),
 113                  "Can only set properties in construction phase");
 114     ClientManager()->RepositionChild(ClientManager()->Hold(this),
 115                                      ClientManager()->Hold(aChild),
 116                                      aAfter ? ClientManager()->Hold(aAfter) : nullptr);
 117     ContainerLayer::RepositionChild(aChild, aAfter);
 118   }
 119
 120   virtual Layer* AsLayer() { return this; }
 121   virtual ShadowableLayer* AsShadowableLayer() { return this; }
 122
 123   virtual void ComputeEffectiveTransforms(const gfx3DMatrix& aTransformToSurface)
 124   {
 125     DefaultComputeEffectiveTransforms(aTransformToSurface);
 126   }
 127
 128   void ForceIntermediateSurface() { mUseIntermediateSurface = true; }
 129
 130   void SetSupportsComponentAlphaChildren(bool aSupports) { mSupportsComponentAlphaChildren = aSupports; }
 131
 132 protected:
 133   ClientLayerManager* ClientManager()
 134   {
 135     return static_cast<ClientLayerManager*>(mManager);
 136   }
 137 };
 138
 139 class ClientRefLayer : public RefLayer,
 140                        public ClientLayer {
 141 public:
 142   ClientRefLayer(ClientLayerManager* aManager) :
 143     RefLayer(aManager,
 144              static_cast<ClientLayer*>(MOZ_THIS_IN_INITIALIZER_LIST()))
 145   {
 146     MOZ_COUNT_CTOR(ClientRefLayer);
 147   }
 148   virtual ~ClientRefLayer()
 149   {
 150     MOZ_COUNT_DTOR(ClientRefLayer);
 151   }
 152
 153   virtual Layer* AsLayer() { return this; }
 154   virtual ShadowableLayer* AsShadowableLayer() { return this; }
 155
 156   virtual void Disconnect()
 157   {
 158     ClientLayer::Disconnect();
 159   }
 160
 161   virtual void RenderLayer() { }
 162
 163   virtual void ComputeEffectiveTransforms(const gfx3DMatrix& aTransformToSurface)
 164   {
 165     DefaultComputeEffectiveTransforms(aTransformToSurface);
 166   }
 167
 168 private:
 169   ClientLayerManager* ClientManager()
 170   {
 171     return static_cast<ClientLayerManager*>(mManager);
 172   }
 173 };
 174
 175 }
 176 }
 177
 178 #endif