O2D: Implement the COPY_WITH_FADING paint operator, and change some of the ot...

core/cross/cairo/renderer_cairo.cc

 /*
  * Copyright 2011, 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 67 matching lines @@
 }
 
 void RendererCairo::Paint() {
   // TODO(tschmelcher): Don't keep creating and destroying the drawing context.
   cairo_t* current_drawing = cairo_create(main_surface_);
 
   // Redirect drawing to an off-screen surface (holding only colour information,
   // without an alpha channel).
   cairo_push_group_with_content(current_drawing, CAIRO_CONTENT_COLOR);
 
+  // Set fill (and clip) rule.
+  cairo_set_fill_rule(current_drawing, CAIRO_FILL_RULE_EVEN_ODD);
+
   // Sort layers by z value.
   // TODO(tschmelcher): Only sort when changes are made.
   layer_list_.sort(LayerZValueLessThan);
 
   // Paint the background.
   PaintBackground(current_drawing);
 
   // Core process of painting.
   for (LayerList::iterator i = layer_list_.begin();
        i != layer_list_.end(); i++) {
     Layer* cur = *i;
     if (!cur->ShouldPaint()) continue;
 
     Pattern* pattern = cur->pattern();
 
     // Save the current drawing state.
     cairo_save(current_drawing);
 
-    // Clip areas that will be obscured anyway.
-    LayerList::iterator start_mask_it = i;
-    start_mask_it++;
-    ClipArea(current_drawing, start_mask_it);
-
-    // Define the region to fill.
+    // Clip the region outside the current Layer.
     cairo_rectangle(current_drawing,
                     cur->x(),
                     cur->y(),
                     cur->width(),
                     cur->height());
+    cairo_clip(current_drawing);
 
-    // Transform the pattern to fit into the fill region.
+    // Clip the regions within other Layers that will obscure this one.
+    LayerList::iterator start_mask_it = i;
+    start_mask_it++;
+    ClipArea(current_drawing, start_mask_it);
+
+    // Transform the pattern to fit into the Layer's region.
     cairo_translate(current_drawing, cur->x(), cur->y());
     cairo_scale(current_drawing, cur->scale_x(), cur->scale_y());
 
     // Set source pattern.
     cairo_set_source(current_drawing, pattern->pattern());
 
     // Paint the pattern to the off-screen surface.
     switch (cur->paint_operator()) {
       case Layer::BLEND:
-        cairo_fill(current_drawing);
+        cairo_paint(current_drawing);
         break;
 
       case Layer::BLEND_WITH_TRANSPARENCY:
-        {
-          cairo_pattern_t* mask = cairo_pattern_create_rgba(0.0,
-                                                            0.0,
-                                                            0.0,
-                                                            cur->alpha());
-          cairo_mask(current_drawing, mask);
-          cairo_pattern_destroy(mask);
-        }
+        cairo_paint_with_alpha(current_drawing, cur->alpha());
         break;
 
-        // TODO(tschmelcher): COPY_WITH_FADING is not implemented yet. For now
-        // we treat it the same as COPY.
-      case Layer::COPY_WITH_FADING:
       case Layer::COPY:
         // Set Cairo to copy the pattern's alpha content instead of blending.
         cairo_set_operator(current_drawing, CAIRO_OPERATOR_SOURCE);
-        cairo_fill(current_drawing);
+        cairo_paint(current_drawing);
+        break;
+
+      case Layer::COPY_WITH_FADING:
+        // TODO(tschmelcher): This can also be done in a single operation with:
+        //
+        //   cairo_set_operator(current_drawing, CAIRO_OPERATOR_IN);
+        //   cairo_paint_with_alpha(current_drawing, cur->alpha());
+        //
+        // but surprisingly that is slightly slower for me. We should figure out
+        // why.
+        cairo_set_operator(current_drawing, CAIRO_OPERATOR_CLEAR);
+        cairo_paint(current_drawing);
+        cairo_set_operator(current_drawing, CAIRO_OPERATOR_OVER);
+        cairo_paint_with_alpha(current_drawing, cur->alpha());
         break;
 
       default:
         DCHECK(false);
     }
 
     // Restore to a clean state.
     cairo_restore(current_drawing);
   }
 
@@ skipping 11 matching lines @@
   cairo_save(cr);
   ClipArea(cr, layer_list_.begin());
 
   cairo_rectangle(cr, 0, 0, display_width(), display_height());
   cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
   cairo_fill(cr);
   cairo_restore(cr);
 }
 
 void RendererCairo::ClipArea(cairo_t* cr,  LayerList::iterator it) {
-  cairo_set_fill_rule(cr, CAIRO_FILL_RULE_EVEN_ODD);
-
   for (LayerList::iterator i = it; i != layer_list_.end(); i++) {
     // Preparing and updating the Layer.
     Layer* cur = *i;
     if (!cur->ShouldClip()) continue;
 
     cairo_rectangle(cr, 0, 0, display_width(), display_height());
     cairo_rectangle(cr,
                     cur->x(),
                     cur->y(),
                     cur->width(),
@@ skipping 273 matching lines @@
   NOTIMPLEMENTED();
 }
 
 void RendererCairo::PopRenderStates() {
   NOTIMPLEMENTED();
 }
 
 }  // namespace o2d
 
 }  // namespace o3d