src/third_party/WebKit/Source/platform/graphics/filters/FilterOperation.h

   1 /*
   2  * Copyright (C) 2011 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef FilterOperation_h
  27 #define FilterOperation_h
  28
  29 #include "platform/Length.h"
  30 #include "platform/PlatformExport.h"
  31 #include "platform/graphics/Color.h"
  32 #include "platform/graphics/filters/Filter.h"
  33 #include "platform/graphics/filters/ReferenceFilter.h"
  34 #include "wtf/OwnPtr.h"
  35 #include "wtf/PassOwnPtr.h"
  36 #include "wtf/RefCounted.h"
  37 #include "wtf/text/WTFString.h"
  38
  39 namespace WebCore {
  40
  41 // CSS Filters
  42
  43 class PLATFORM_EXPORT FilterOperation : public RefCounted<FilterOperation> {
  44 public:
  45     enum OperationType {
  46         REFERENCE, // url(#somefilter)
  47         GRAYSCALE,
  48         SEPIA,
  49         SATURATE,
  50         HUE_ROTATE,
  51         INVERT,
  52         OPACITY,
  53         BRIGHTNESS,
  54         CONTRAST,
  55         BLUR,
  56         DROP_SHADOW,
  57         CUSTOM,
  58         VALIDATED_CUSTOM,
  59         NONE
  60     };
  61
  62     static bool canInterpolate(FilterOperation::OperationType type)
  63     {
  64         switch (type) {
  65         case GRAYSCALE:
  66         case SEPIA:
  67         case SATURATE:
  68         case HUE_ROTATE:
  69         case INVERT:
  70         case OPACITY:
  71         case BRIGHTNESS:
  72         case CONTRAST:
  73         case BLUR:
  74         case DROP_SHADOW:
  75         case CUSTOM:
  76         case VALIDATED_CUSTOM:
  77             return true;
  78         case REFERENCE:
  79             return false;
  80         case NONE:
  81             break;
  82         }
  83         ASSERT_NOT_REACHED();
  84         return false;
  85     }
  86
  87     virtual ~FilterOperation() { }
  88
  89     static PassRefPtr<FilterOperation> blend(const FilterOperation* from, const FilterOperation* to, double progress);
  90     virtual bool operator==(const FilterOperation&) const = 0;
  91     bool operator!=(const FilterOperation& o) const { return !(*this == o); }
  92
  93     OperationType type() const { return m_type; }
  94     virtual bool isSameType(const FilterOperation& o) const { return o.type() == m_type; }
  95
  96     // True if the alpha channel of any pixel can change under this operation.
  97     virtual bool affectsOpacity() const { return false; }
  98     // True if the the value of one pixel can affect the value of another pixel under this operation, such as blur.
  99     virtual bool movesPixels() const { return false; }
 100
 101 protected:
 102     FilterOperation(OperationType type)
 103         : m_type(type)
 104     {
 105     }
 106
 107     OperationType m_type;
 108
 109 private:
 110     virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress) const = 0;
 111 };
 112
 113 #define DEFINE_FILTER_OPERATION_TYPE_CASTS(thisType, operationType) \
 114     DEFINE_TYPE_CASTS(thisType, FilterOperation, op, op->type() == FilterOperation::operationType, op.type() == FilterOperation::operationType);
 115
 116 class PLATFORM_EXPORT ReferenceFilterOperation : public FilterOperation {
 117 public:
 118     static PassRefPtr<ReferenceFilterOperation> create(const String& url, const AtomicString& fragment)
 119     {
 120         return adoptRef(new ReferenceFilterOperation(url, fragment));
 121     }
 122
 123     virtual bool affectsOpacity() const OVERRIDE { return true; }
 124     virtual bool movesPixels() const OVERRIDE { return true; }
 125
 126     const String& url() const { return m_url; }
 127     const AtomicString& fragment() const { return m_fragment; }
 128
 129     ReferenceFilter* filter() const { return m_filter.get(); }
 130     void setFilter(PassRefPtr<ReferenceFilter> filter) { m_filter = filter; }
 131
 132 private:
 133     virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress) const OVERRIDE
 134     {
 135         ASSERT_NOT_REACHED();
 136         return nullptr;
 137     }
 138
 139     virtual bool operator==(const FilterOperation& o) const OVERRIDE
 140     {
 141         if (!isSameType(o))
 142             return false;
 143         const ReferenceFilterOperation* other = static_cast<const ReferenceFilterOperation*>(&o);
 144         return m_url == other->m_url;
 145     }
 146
 147     ReferenceFilterOperation(const String& url, const AtomicString& fragment)
 148         : FilterOperation(REFERENCE)
 149         , m_url(url)
 150         , m_fragment(fragment)
 151     {
 152     }
 153
 154     String m_url;
 155     AtomicString m_fragment;
 156     RefPtr<ReferenceFilter> m_filter;
 157 };
 158
 159 DEFINE_FILTER_OPERATION_TYPE_CASTS(ReferenceFilterOperation, REFERENCE);
 160
 161 // GRAYSCALE, SEPIA, SATURATE and HUE_ROTATE are variations on a basic color matrix effect.
 162 // For HUE_ROTATE, the angle of rotation is stored in m_amount.
 163 class PLATFORM_EXPORT BasicColorMatrixFilterOperation : public FilterOperation {
 164 public:
 165     static PassRefPtr<BasicColorMatrixFilterOperation> create(double amount, OperationType type)
 166     {
 167         return adoptRef(new BasicColorMatrixFilterOperation(amount, type));
 168     }
 169
 170     double amount() const { return m_amount; }
 171
 172
 173 private:
 174     virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress) const OVERRIDE;
 175     virtual bool operator==(const FilterOperation& o) const OVERRIDE
 176     {
 177         if (!isSameType(o))
 178             return false;
 179         const BasicColorMatrixFilterOperation* other = static_cast<const BasicColorMatrixFilterOperation*>(&o);
 180         return m_amount == other->m_amount;
 181     }
 182
 183     BasicColorMatrixFilterOperation(double amount, OperationType type)
 184         : FilterOperation(type)
 185         , m_amount(amount)
 186     {
 187     }
 188
 189     double m_amount;
 190 };
 191
 192 inline bool isBasicColorMatrixFilterOperation(const FilterOperation& operation)
 193 {
 194     FilterOperation::OperationType type = operation.type();
 195     return type == FilterOperation::GRAYSCALE || type == FilterOperation::SEPIA || type == FilterOperation::SATURATE || type == FilterOperation::HUE_ROTATE;
 196 }
 197
 198 DEFINE_TYPE_CASTS(BasicColorMatrixFilterOperation, FilterOperation, op, isBasicColorMatrixFilterOperation(*op), isBasicColorMatrixFilterOperation(op));
 199
 200 // INVERT, BRIGHTNESS, CONTRAST and OPACITY are variations on a basic component transfer effect.
 201 class PLATFORM_EXPORT BasicComponentTransferFilterOperation : public FilterOperation {
 202 public:
 203     static PassRefPtr<BasicComponentTransferFilterOperation> create(double amount, OperationType type)
 204     {
 205         return adoptRef(new BasicComponentTransferFilterOperation(amount, type));
 206     }
 207
 208     double amount() const { return m_amount; }
 209
 210     virtual bool affectsOpacity() const OVERRIDE { return m_type == OPACITY; }
 211
 212
 213 private:
 214     virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress) const OVERRIDE;
 215     virtual bool operator==(const FilterOperation& o) const OVERRIDE
 216     {
 217         if (!isSameType(o))
 218             return false;
 219         const BasicComponentTransferFilterOperation* other = static_cast<const BasicComponentTransferFilterOperation*>(&o);
 220         return m_amount == other->m_amount;
 221     }
 222
 223     BasicComponentTransferFilterOperation(double amount, OperationType type)
 224         : FilterOperation(type)
 225         , m_amount(amount)
 226     {
 227     }
 228
 229     double m_amount;
 230 };
 231
 232 inline bool isBasicComponentTransferFilterOperation(const FilterOperation& operation)
 233 {
 234     FilterOperation::OperationType type = operation.type();
 235     return type == FilterOperation::INVERT || type == FilterOperation::OPACITY || type == FilterOperation::BRIGHTNESS || type == FilterOperation::CONTRAST;
 236 }
 237
 238 DEFINE_TYPE_CASTS(BasicComponentTransferFilterOperation, FilterOperation, op, isBasicComponentTransferFilterOperation(*op), isBasicComponentTransferFilterOperation(op));
 239
 240 class PLATFORM_EXPORT BlurFilterOperation : public FilterOperation {
 241 public:
 242     static PassRefPtr<BlurFilterOperation> create(Length stdDeviation)
 243     {
 244         return adoptRef(new BlurFilterOperation(stdDeviation));
 245     }
 246
 247     Length stdDeviation() const { return m_stdDeviation; }
 248
 249     virtual bool affectsOpacity() const OVERRIDE { return true; }
 250     virtual bool movesPixels() const OVERRIDE { return true; }
 251
 252
 253 private:
 254     virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress) const OVERRIDE;
 255     virtual bool operator==(const FilterOperation& o) const OVERRIDE
 256     {
 257         if (!isSameType(o))
 258             return false;
 259         const BlurFilterOperation* other = static_cast<const BlurFilterOperation*>(&o);
 260         return m_stdDeviation == other->m_stdDeviation;
 261     }
 262
 263     BlurFilterOperation(Length stdDeviation)
 264         : FilterOperation(BLUR)
 265         , m_stdDeviation(stdDeviation)
 266     {
 267     }
 268
 269     Length m_stdDeviation;
 270 };
 271
 272 DEFINE_FILTER_OPERATION_TYPE_CASTS(BlurFilterOperation, BLUR);
 273
 274 class PLATFORM_EXPORT DropShadowFilterOperation : public FilterOperation {
 275 public:
 276     static PassRefPtr<DropShadowFilterOperation> create(const IntPoint& location, int stdDeviation, Color color)
 277     {
 278         return adoptRef(new DropShadowFilterOperation(location, stdDeviation, color));
 279     }
 280
 281     int x() const { return m_location.x(); }
 282     int y() const { return m_location.y(); }
 283     IntPoint location() const { return m_location; }
 284     int stdDeviation() const { return m_stdDeviation; }
 285     Color color() const { return m_color; }
 286
 287     virtual bool affectsOpacity() const OVERRIDE { return true; }
 288     virtual bool movesPixels() const OVERRIDE { return true; }
 289
 290
 291 private:
 292     virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress) const OVERRIDE;
 293     virtual bool operator==(const FilterOperation& o) const OVERRIDE
 294     {
 295         if (!isSameType(o))
 296             return false;
 297         const DropShadowFilterOperation* other = static_cast<const DropShadowFilterOperation*>(&o);
 298         return m_location == other->m_location && m_stdDeviation == other->m_stdDeviation && m_color == other->m_color;
 299     }
 300
 301     DropShadowFilterOperation(const IntPoint& location, int stdDeviation, Color color)
 302         : FilterOperation(DROP_SHADOW)
 303         , m_location(location)
 304         , m_stdDeviation(stdDeviation)
 305         , m_color(color)
 306     {
 307     }
 308
 309     IntPoint m_location; // FIXME: should location be in Lengths?
 310     int m_stdDeviation;
 311     Color m_color;
 312 };
 313
 314 DEFINE_FILTER_OPERATION_TYPE_CASTS(DropShadowFilterOperation, DROP_SHADOW);
 315
 316 } // namespace WebCore
 317
 318
 319 #endif // FilterOperation_h