WebCore/FloatQuad.h

   1 /*
   2  * Copyright (C) 2008 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  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  14  *     its contributors may be used to endorse or promote products derived
  15  *     from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #ifndef FloatQuad_h
  30 #define FloatQuad_h
  31
  32 #include "FloatPoint.h"
  33 #include "FloatRect.h"
  34 #include "IntRect.h"
  35
  36 namespace WebCore {
  37
  38 // A FloatQuad is a collection of 4 points, often representing the result of
  39 // mapping a rectangle through transforms. When initialized from a rect, the
  40 // points are in clockwise order from top left.
  41 class FloatQuad {
  42 public:
  43     FloatQuad()
  44     {
  45     }
  46
  47     FloatQuad(const FloatPoint& p1, const FloatPoint& p2, const FloatPoint& p3, const FloatPoint& p4)
  48         : m_p1(p1)
  49         , m_p2(p2)
  50         , m_p3(p3)
  51         , m_p4(p4)
  52     {
  53     }
  54
  55     FloatQuad(const FloatRect& inRect)
  56         : m_p1(inRect.location())
  57         , m_p2(inRect.right(), inRect.y())
  58         , m_p3(inRect.right(), inRect.bottom())
  59         , m_p4(inRect.x(), inRect.bottom())
  60     {
  61     }
  62
  63     FloatPoint p1() const { return m_p1; }
  64     FloatPoint p2() const { return m_p2; }
  65     FloatPoint p3() const { return m_p3; }
  66     FloatPoint p4() const { return m_p4; }
  67
  68     void setP1(const FloatPoint& p) { m_p1 = p; }
  69     void setP2(const FloatPoint& p) { m_p2 = p; }
  70     void setP3(const FloatPoint& p) { m_p3 = p; }
  71     void setP4(const FloatPoint& p) { m_p4 = p; }
  72
  73     // isEmpty tests that the bounding box is empty. This will not identify
  74     // "slanted" empty quads.
  75     bool isEmpty() const { return boundingBox().isEmpty(); }
  76
  77     // Tests whether the given point is inside, or on an edge or corner of this quad.
  78     bool containsPoint(const FloatPoint&) const;
  79
  80     // Tests whether the four corners of other are inside, or coincident with the sides of this quad.
  81     // Note that this only works for convex quads, but that includes all quads that originate
  82     // from transformed rects.
  83     bool containsQuad(const FloatQuad&) const;
  84
  85     FloatRect boundingBox() const;
  86     IntRect enclosingBoundingBox() const
  87     {
  88         return enclosingIntRect(boundingBox());
  89     }
  90
  91     void move(const FloatSize& offset)
  92     {
  93         m_p1 += offset;
  94         m_p2 += offset;
  95         m_p3 += offset;
  96         m_p4 += offset;
  97     }
  98
  99     void move(float dx, float dy)
 100     {
 101         m_p1.move(dx, dy);
 102         m_p2.move(dx, dy);
 103         m_p3.move(dx, dy);
 104         m_p4.move(dx, dy);
 105     }
 106
 107 private:
 108     FloatPoint m_p1;
 109     FloatPoint m_p2;
 110     FloatPoint m_p3;
 111     FloatPoint m_p4;
 112 };
 113
 114 inline FloatQuad& operator+=(FloatQuad& a, const FloatSize& b)
 115 {
 116     a.move(b);
 117     return a;
 118 }
 119
 120 inline FloatQuad& operator-=(FloatQuad& a, const FloatSize& b)
 121 {
 122     a.move(-b.width(), -b.height());
 123     return a;
 124 }
 125
 126 inline bool operator==(const FloatQuad& a, const FloatQuad& b)
 127 {
 128     return a.p1() == b.p1() &&
 129            a.p2() == b.p2() &&
 130            a.p3() == b.p3() &&
 131            a.p4() == b.p4();
 132 }
 133
 134 inline bool operator!=(const FloatQuad& a, const FloatQuad& b)
 135 {
 136     return a.p1() != b.p1() ||
 137            a.p2() != b.p2() ||
 138            a.p3() != b.p3() ||
 139            a.p4() != b.p4();
 140 }
 141
 142 }   // namespace WebCore
 143
 144
 145 #endif // FloatQuad_h
 146