O2D:...

core/cross/cairo/layer.h

 /*
  * Copyright 2010, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 32 matching lines @@
 namespace o3d {
 
 class IClassManager;
 
 namespace o2d {
 
 class Layer : public ObjectBase {
  public:
   typedef SmartPointer<Layer> Ref;
 
+  enum PaintOperator {
+    BLEND,
+    BLEND_WITH_TRANSPARENCY,
+    COPY,
+    COPY_WITH_FADING,
+  };
+
   virtual ~Layer();
 
+  // Methods exposed to JS.
+
   Pattern* pattern() const {
     return pattern_;
   }
 
   void set_pattern(Pattern* pattern) {
     pattern_ = Pattern::Ref(pattern);
   }
 
+  bool visible() const {
+    return visible_;
+  }
+
+  void set_visible(bool visible) {
+    visible_ = visible;
+  }
+
   double alpha() const {
     return alpha_;
   }
 
   void set_alpha(double alpha) {
     alpha_ = alpha;
   }
 
   double x() const {
     return x_;
@@ skipping 44 matching lines @@
   }
 
   double scale_y() const {
     return scale_y_;
   }
 
   void set_scale_y(double scale_y) {
     scale_y_ = scale_y;
   }
 
+  PaintOperator paint_operator() const {
+    return paint_operator_;
+  }
+
+  void set_paint_operator(PaintOperator paint_operator) {
+    paint_operator_ = paint_operator;
+  }
+
+  // Methods not exposed to JS.
+
+  // Whether we should currently paint this layer.
+  bool ShouldPaint() const {
+    return visible() && pattern() != NULL;
+  }
+
+  // Whether this layer should currently clip content behind it (i.e.,
+  // prevent it from being drawn in the first place).
+  bool ShouldClip() const {
+    // When alpha blending is used we cannot clip the background because our
+    // content will be blended with it.
+    return ShouldPaint() &&
+        (paint_operator() == COPY || paint_operator() == COPY_WITH_FADING);
+  }
+
  private:
   explicit Layer(ServiceLocator* service_locator);
 
   friend class o3d::IClassManager;
   static ObjectBase::Ref Create(ServiceLocator* service_locator);
 
   // The pattern used to paint this Layer.
   Pattern::Ref pattern_;
 
-  // Transparancy of this layer.
+  // Whether this layer should be visible or not.
+  bool visible_;
+
+  // The transparency for the BLEND_WITH_TRANSPARENCY operator or the fading for
+  // the COPY_WITH_FADING operator.
   double alpha_;
 
   // The x coordinate of the top-left corner of this layer.
   double x_;
 
   // The y coordinate of the top-left corner of this layer.
   double y_;
 
   // The z coordinate of the layer (used only to determine stacking order).
   double z_;
 
   // The width of this layer.
   double width_;
 
   // The height of this layer.
   double height_;
 
   // A scaling factor to apply to the pattern's x-axis.
   double scale_x_;
 
   // A scaling factor to apply to the pattern's y-axis.
   double scale_y_;
 
+  // The paint operator to use for painting this Layer.
+  PaintOperator paint_operator_;
+
   O3D_DECL_CLASS(Layer, ObjectBase)
 };  // Layer
 
 }  // namespace o2d
 
 }  // namespace o3d
 
 #endif  // O3D_CORE_CROSS_CAIRO_LAYER_H_