cc/output/filter_operation.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CC_OUTPUT_FILTER_OPERATION_H_
   6 #define CC_OUTPUT_FILTER_OPERATION_H_
   7
   8 #include "base/logging.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "cc/base/cc_export.h"
  11 #include "third_party/skia/include/core/SkColor.h"
  12 #include "third_party/skia/include/core/SkScalar.h"
  13 #include "ui/gfx/point.h"
  14
  15 namespace base {
  16 class Value;
  17 }
  18
  19 namespace cc {
  20
  21 class CC_EXPORT FilterOperation {
  22  public:
  23   enum FilterType {
  24     GRAYSCALE,
  25     SEPIA,
  26     SATURATE,
  27     HUE_ROTATE,
  28     INVERT,
  29     BRIGHTNESS,
  30     CONTRAST,
  31     OPACITY,
  32     BLUR,
  33     DROP_SHADOW,
  34     COLOR_MATRIX,
  35     ZOOM,
  36     SATURATING_BRIGHTNESS,  // Not used in CSS/SVG.
  37   };
  38
  39   FilterType type() const { return type_; }
  40
  41   float amount() const {
  42     DCHECK_NE(type_, COLOR_MATRIX);
  43     return amount_;
  44   }
  45
  46   gfx::Point drop_shadow_offset() const {
  47     DCHECK_EQ(type_, DROP_SHADOW);
  48     return drop_shadow_offset_;
  49   }
  50
  51   SkColor drop_shadow_color() const {
  52     DCHECK_EQ(type_, DROP_SHADOW);
  53     return drop_shadow_color_;
  54   }
  55
  56   const SkScalar* matrix() const {
  57     DCHECK_EQ(type_, COLOR_MATRIX);
  58     return matrix_;
  59   }
  60
  61   int zoom_inset() const {
  62     DCHECK_EQ(type_, ZOOM);
  63     return zoom_inset_;
  64   }
  65
  66   static FilterOperation CreateGrayscaleFilter(float amount) {
  67     return FilterOperation(GRAYSCALE, amount);
  68   }
  69
  70   static FilterOperation CreateSepiaFilter(float amount) {
  71     return FilterOperation(SEPIA, amount);
  72   }
  73
  74   static FilterOperation CreateSaturateFilter(float amount) {
  75     return FilterOperation(SATURATE, amount);
  76   }
  77
  78   static FilterOperation CreateHueRotateFilter(float amount) {
  79     return FilterOperation(HUE_ROTATE, amount);
  80   }
  81
  82   static FilterOperation CreateInvertFilter(float amount) {
  83     return FilterOperation(INVERT, amount);
  84   }
  85
  86   static FilterOperation CreateBrightnessFilter(float amount) {
  87     return FilterOperation(BRIGHTNESS, amount);
  88   }
  89
  90   static FilterOperation CreateContrastFilter(float amount) {
  91     return FilterOperation(CONTRAST, amount);
  92   }
  93
  94   static FilterOperation CreateOpacityFilter(float amount) {
  95     return FilterOperation(OPACITY, amount);
  96   }
  97
  98   static FilterOperation CreateBlurFilter(float amount) {
  99     return FilterOperation(BLUR, amount);
 100   }
 101
 102   static FilterOperation CreateDropShadowFilter(gfx::Point offset,
 103                                                 float std_deviation,
 104                                                 SkColor color) {
 105     return FilterOperation(DROP_SHADOW, offset, std_deviation, color);
 106   }
 107
 108   static FilterOperation CreateColorMatrixFilter(SkScalar matrix[20]) {
 109     return FilterOperation(COLOR_MATRIX, matrix);
 110   }
 111
 112   static FilterOperation CreateZoomFilter(float amount, int inset) {
 113     return FilterOperation(ZOOM, amount, inset);
 114   }
 115
 116   static FilterOperation CreateSaturatingBrightnessFilter(float amount) {
 117     return FilterOperation(SATURATING_BRIGHTNESS, amount);
 118   }
 119
 120   bool operator==(const FilterOperation& other) const;
 121
 122   bool operator!=(const FilterOperation& other) const {
 123     return !(*this == other);
 124   }
 125
 126   // Methods for restoring a FilterOperation.
 127   static FilterOperation CreateEmptyFilter() {
 128     return FilterOperation(GRAYSCALE, 0.f);
 129   }
 130
 131   void set_type(FilterType type) { type_ = type; }
 132
 133   void set_amount(float amount) {
 134     DCHECK_NE(type_, COLOR_MATRIX);
 135     amount_ = amount;
 136   }
 137
 138   void set_drop_shadow_offset(gfx::Point offset) {
 139     DCHECK_EQ(type_, DROP_SHADOW);
 140     drop_shadow_offset_ = offset;
 141   }
 142
 143   void set_drop_shadow_color(SkColor color) {
 144     DCHECK_EQ(type_, DROP_SHADOW);
 145     drop_shadow_color_ = color;
 146   }
 147
 148   void set_matrix(const SkScalar matrix[20]) {
 149     DCHECK_EQ(type_, COLOR_MATRIX);
 150     for (unsigned i = 0; i < 20; ++i)
 151       matrix_[i] = matrix[i];
 152   }
 153
 154   void set_zoom_inset(int inset) {
 155     DCHECK_EQ(type_, ZOOM);
 156     zoom_inset_ = inset;
 157   }
 158
 159   // Given two filters of the same type, returns a filter operation created by
 160   // linearly interpolating a |progress| fraction from |from| to |to|. If either
 161   // |from| or |to| (but not both) is null, it is treated as a no-op filter of
 162   // the same type as the other given filter. If both |from| and |to| are null,
 163   // or if |from| and |to| are non-null but of different types, returns a
 164   // no-op filter.
 165   static FilterOperation Blend(const FilterOperation* from,
 166                                const FilterOperation* to,
 167                                double progress);
 168
 169   scoped_ptr<base::Value> AsValue() const;
 170
 171  private:
 172   FilterOperation(FilterType type, float amount);
 173
 174   FilterOperation(FilterType type,
 175                   gfx::Point offset,
 176                   float stdDeviation,
 177                   SkColor color);
 178
 179   FilterOperation(FilterType, SkScalar matrix[20]);
 180
 181   FilterOperation(FilterType type, float amount, int inset);
 182
 183   FilterType type_;
 184   float amount_;
 185   gfx::Point drop_shadow_offset_;
 186   SkColor drop_shadow_color_;
 187   SkScalar matrix_[20];
 188   int zoom_inset_;
 189 };
 190
 191 }  // namespace cc
 192
 193 #endif  // CC_OUTPUT_FILTER_OPERATION_H_