← Back to branch summary

~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

« back to all changes in this revision

Viewing changes to Source/WebCore/platform/graphics/FloatPoint.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-02-18 14:24:18 UTC
  • Revision ID: package-import@ubuntu.com-20130218142418-eon0jmjg3nj438uy
Tags: upstream-2.3
Import upstream version 2.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/WebCore/platform/graphics/FloatPoint.cpp
 
1
/*
 
2
 * Copyright (C) 2004, 2006, 2007 Apple Inc.  All rights reserved.
 
3
 * Copyright (C) 2005 Nokia.  All rights reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
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
 *
 
14
 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 
15
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
16
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 
17
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 
18
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 
19
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 
20
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 
21
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 
22
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
23
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
24
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 
25
 */
 
26
 
 
27
#include "config.h"
 
28
#include "FloatPoint.h"
 
29
 
 
30
#include "AffineTransform.h"
 
31
#include "FloatConversion.h"
 
32
#include "IntPoint.h"
 
33
#include "LayoutPoint.h"
 
34
#include "LayoutSize.h"
 
35
#include "TransformationMatrix.h"
 
36
#include <limits>
 
37
#include <math.h>
 
38
 
 
39
namespace WebCore {
 
40
 
 
41
FloatPoint::FloatPoint(const IntPoint& p) : m_x(p.x()), m_y(p.y())
 
42
{
 
43
}
 
44
 
 
45
FloatPoint::FloatPoint(const LayoutPoint& p) : m_x(p.x()), m_y(p.y())
 
46
{
 
47
}
 
48
 
 
49
void FloatPoint::normalize()
 
50
{
 
51
    float tempLength = length();
 
52
 
 
53
    if (tempLength) {
 
54
        m_x /= tempLength;
 
55
        m_y /= tempLength;
 
56
    }
 
57
}
 
58
 
 
59
float FloatPoint::length() const
 
60
{
 
61
    return sqrtf(lengthSquared());
 
62
}
 
63
 
 
64
void FloatPoint::move(const LayoutSize& size)
 
65
{
 
66
    m_x += size.width();
 
67
    m_y += size.height();
 
68
}
 
69
 
 
70
void FloatPoint::moveBy(const LayoutPoint& point)
 
71
{
 
72
    m_x += point.x();
 
73
    m_y += point.y();
 
74
}
 
75
 
 
76
FloatPoint FloatPoint::matrixTransform(const AffineTransform& transform) const
 
77
{
 
78
    double newX, newY;
 
79
    transform.map(static_cast<double>(m_x), static_cast<double>(m_y), newX, newY);
 
80
    return narrowPrecision(newX, newY);
 
81
}
 
82
 
 
83
FloatPoint FloatPoint::matrixTransform(const TransformationMatrix& transform) const
 
84
{
 
85
    double newX, newY;
 
86
    transform.map(static_cast<double>(m_x), static_cast<double>(m_y), newX, newY);
 
87
    return narrowPrecision(newX, newY);
 
88
}
 
89
 
 
90
FloatPoint FloatPoint::narrowPrecision(double x, double y)
 
91
{
 
92
    return FloatPoint(narrowPrecisionToFloat(x), narrowPrecisionToFloat(y));
 
93
}
 
94
 
 
95
float findSlope(const FloatPoint& p1, const FloatPoint& p2, float& c)
 
96
{
 
97
    if (p2.x() == p1.x())
 
98
        return std::numeric_limits<float>::infinity();
 
99
 
 
100
    // y = mx + c
 
101
    float slope = (p2.y() - p1.y()) / (p2.x() - p1.x());
 
102
    c = p1.y() - slope * p1.x();
 
103
    return slope;
 
104
}
 
105
 
 
106
bool findIntersection(const FloatPoint& p1, const FloatPoint& p2, const FloatPoint& d1, const FloatPoint& d2, FloatPoint& intersection) 
 
107
{
 
108
    float pOffset = 0;
 
109
    float pSlope = findSlope(p1, p2, pOffset);
 
110
 
 
111
    float dOffset = 0;
 
112
    float dSlope = findSlope(d1, d2, dOffset);
 
113
 
 
114
    if (dSlope == pSlope)
 
115
        return false;
 
116
    
 
117
    if (pSlope == std::numeric_limits<float>::infinity()) {
 
118
        intersection.setX(p1.x());
 
119
        intersection.setY(dSlope * intersection.x() + dOffset);
 
120
        return true;
 
121
    }
 
122
    if (dSlope == std::numeric_limits<float>::infinity()) {
 
123
        intersection.setX(d1.x());
 
124
        intersection.setY(pSlope * intersection.x() + pOffset);
 
125
        return true;
 
126
    }
 
127
    
 
128
    // Find x at intersection, where ys overlap; x = (c' - c) / (m - m')
 
129
    intersection.setX((dOffset - pOffset) / (pSlope - dSlope));
 
130
    intersection.setY(pSlope * intersection.x() + pOffset);
 
131
    return true;
 
132
}
 
133
 
 
134
}