Home | History | Annotate | Download | only in rendering 
      1 /*
      2  * Copyright (C) 2012 Adobe Systems Incorporated. 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  *
      8  * 1. Redistributions of source code must retain the above
      9  *    copyright notice, this list of conditions and the following
     10  *    disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above
     12  *    copyright notice, this list of conditions and the following
     13  *    disclaimer in the documentation and/or other materials
     14  *    provided with the distribution.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AS IS AND ANY
     17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
     20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
     21  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     23  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
     25  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
     26  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     27  * SUCH DAMAGE.
     28  */
     29 
     30 #ifndef ClipPathOperation_h
     31 #define ClipPathOperation_h
     32 
     33 #include "core/rendering/style/BasicShapes.h"
     34 #include "platform/graphics/Path.h"
     35 #include "wtf/OwnPtr.h"
     36 #include "wtf/PassOwnPtr.h"
     37 #include "wtf/RefCounted.h"
     38 #include "wtf/text/WTFString.h"
     39 
     40 namespace blink {
     41 
     42 class ClipPathOperation : public RefCounted<ClipPathOperation> {
     43 public:
     44     enum OperationType {
     45         REFERENCE,
     46         SHAPE
     47     };
     48 
     49     virtual ~ClipPathOperation() { }
     50 
     51     virtual bool operator==(const ClipPathOperation&) const = 0;
     52     bool operator!=(const ClipPathOperation& o) const { return !(*this == o); }
     53 
     54     OperationType type() const { return m_type; }
     55     bool isSameType(const ClipPathOperation& o) const { return o.type() == m_type; }
     56 
     57 protected:
     58     ClipPathOperation(OperationType type)
     59         : m_type(type)
     60     {
     61     }
     62 
     63     OperationType m_type;
     64 };
     65 
     66 class ReferenceClipPathOperation FINAL : public ClipPathOperation {
     67 public:
     68     static PassRefPtr<ReferenceClipPathOperation> create(const String& url, const AtomicString& fragment)
     69     {
     70         return adoptRef(new ReferenceClipPathOperation(url, fragment));
     71     }
     72 
     73     const String& url() const { return m_url; }
     74     const AtomicString& fragment() const { return m_fragment; }
     75 
     76 private:
     77     virtual bool operator==(const ClipPathOperation& o) const OVERRIDE
     78     {
     79         return isSameType(o) && m_url == static_cast<const ReferenceClipPathOperation&>(o).m_url;
     80     }
     81 
     82     ReferenceClipPathOperation(const String& url, const AtomicString& fragment)
     83         : ClipPathOperation(REFERENCE)
     84         , m_url(url)
     85         , m_fragment(fragment)
     86     {
     87     }
     88 
     89     String m_url;
     90     AtomicString m_fragment;
     91 };
     92 
     93 DEFINE_TYPE_CASTS(ReferenceClipPathOperation, ClipPathOperation, op, op->type() == ClipPathOperation::REFERENCE, op.type() == ClipPathOperation::REFERENCE);
     94 
     95 class ShapeClipPathOperation FINAL : public ClipPathOperation {
     96 public:
     97     static PassRefPtr<ShapeClipPathOperation> create(PassRefPtr<BasicShape> shape)
     98     {
     99         return adoptRef(new ShapeClipPathOperation(shape));
    100     }
    101 
    102     const BasicShape* basicShape() const { return m_shape.get(); }
    103     bool isValid() const { return m_shape.get(); }
    104     WindRule windRule() const { return m_shape->windRule(); }
    105     const Path& path(const FloatRect& boundingRect)
    106     {
    107         ASSERT(m_shape);
    108         m_path.clear();
    109         m_path = adoptPtr(new Path);
    110         m_shape->path(*m_path, boundingRect);
    111         return *m_path;
    112     }
    113 
    114 private:
    115     virtual bool operator==(const ClipPathOperation&) const OVERRIDE;
    116 
    117     ShapeClipPathOperation(PassRefPtr<BasicShape> shape)
    118         : ClipPathOperation(SHAPE)
    119         , m_shape(shape)
    120     {
    121     }
    122 
    123     RefPtr<BasicShape> m_shape;
    124     OwnPtr<Path> m_path;
    125 };
    126 
    127 DEFINE_TYPE_CASTS(ShapeClipPathOperation, ClipPathOperation, op, op->type() == ClipPathOperation::SHAPE, op.type() == ClipPathOperation::SHAPE);
    128 
    129 inline bool ShapeClipPathOperation::operator==(const ClipPathOperation& o) const
    130 {
    131     if (!isSameType(o))
    132         return false;
    133     BasicShape* otherShape = toShapeClipPathOperation(o).m_shape.get();
    134     if (!m_shape.get() || !otherShape)
    135         return static_cast<bool>(m_shape.get()) == static_cast<bool>(otherShape);
    136     return *m_shape == *otherShape;
    137 }
    138 
    139 }
    140 
    141 #endif // ClipPathOperation_h
    142