Merge pull request #4 from FOSSEE/develop

merging dev into master

1 files changed, 226 insertions, 0 deletions

diff --git a/include/class_eda_rect.h b/include/class_eda_rect.h
new file mode 100644
index 0000000..57aa3a4
--- /dev/null
+++ b/include/class_eda_rect.h
@@ -0,0 +1,226 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2014 Jean-Pierre Charras, jp.charras at wanadoo.fr
+ * Copyright (C) 2004-2014 KiCad Developers, see change_log.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+/**
+ * @file class_eda_rect.h
+ */
+
+#ifndef CLASS_EDA_RECT_H
+#define CLASS_EDA_RECT_H
+
+/**
+ * Class EDA_RECT
+ * handles the component boundary box.
+ * This class is similar to wxRect, but some wxRect functions are very curious,
+ * and are working only if dimensions are >= 0 (not always the case in KiCad)
+ * and also KiCad needs some specific method.
+ * so I prefer this more suitable class
+ */
+class EDA_RECT
+{
+private:
+    wxPoint m_Pos;      // Rectangle Origin
+    wxSize  m_Size;     // Rectangle Size
+
+public:
+    EDA_RECT() { };
+
+    EDA_RECT( const wxPoint& aPos, const wxSize& aSize ) :
+        m_Pos( aPos ),
+        m_Size( aSize )
+    { }
+
+    wxPoint Centre() const
+    {
+        return wxPoint( m_Pos.x + ( m_Size.x >> 1 ),
+                        m_Pos.y + ( m_Size.y >> 1 ) );
+    }
+
+    /**
+     * Function Move
+     * moves the rectangle by the \a aMoveVector.
+     * @param aMoveVector A wxPoint that is the value to move this rectangle
+     */
+    void Move( const wxPoint& aMoveVector );
+
+    /**
+     * Function Normalize
+     * ensures that the height ant width are positive.
+     */
+    void Normalize();
+
+    /**
+     * Function Contains
+     * @param aPoint = the wxPoint to test
+     * @return true if aPoint is inside the boundary box. A point on a edge is seen as inside
+     */
+    bool Contains( const wxPoint& aPoint ) const;
+    /**
+     * Function Contains
+     * @param x = the x coordinate of the point to test
+     * @param y = the x coordinate of the point to test
+     * @return true if point is inside the boundary box. A point on a edge is seen as inside
+     */
+    bool Contains( int x, int y ) const { return Contains( wxPoint( x, y ) ); }
+
+    /**
+     * Function Contains
+     * @param aRect = the EDA_RECT to test
+     * @return true if aRect is Contained. A common edge is seen as contained
+     */
+    bool Contains( const EDA_RECT& aRect ) const;
+
+    const wxSize& GetSize() const { return m_Size; }
+    int GetX() const { return m_Pos.x; }
+    int GetY() const { return m_Pos.y; }
+
+    const wxPoint& GetOrigin() const { return m_Pos; }
+    const wxPoint& GetPosition() const { return m_Pos; }
+    const wxPoint GetEnd() const { return wxPoint( m_Pos.x + m_Size.x, m_Pos.y + m_Size.y ); }
+
+    int GetWidth() const { return m_Size.x; }
+    int GetHeight() const { return m_Size.y; }
+    int GetRight() const { return m_Pos.x + m_Size.x; }
+    int GetLeft() const { return m_Pos.x; }
+    int GetBottom() const { return m_Pos.y + m_Size.y; }    // Y axis from top to bottom
+
+    void SetOrigin( const wxPoint& pos ) { m_Pos = pos; }
+    void SetOrigin( int x, int y ) { m_Pos.x = x; m_Pos.y = y; }
+    void SetSize( const wxSize& size ) { m_Size = size; }
+    void SetSize( int w, int h ) { m_Size.x = w; m_Size.y = h; }
+    void Offset( int dx, int dy ) { m_Pos.x += dx; m_Pos.y += dy; }
+    void Offset( const wxPoint& offset ) { m_Pos.x += offset.x; m_Pos.y +=
+                                               offset.y; }
+    void SetX( int val ) { m_Pos.x = val; }
+    void SetY( int val ) { m_Pos.y = val; }
+    void SetWidth( int val ) { m_Size.x = val; }
+    void SetHeight( int val ) { m_Size.y = val; }
+    void SetEnd( int x, int y ) { SetEnd( wxPoint( x, y ) ); }
+    void SetEnd( const wxPoint& pos )
+    {
+        m_Size.x = pos.x - m_Pos.x; m_Size.y = pos.y - m_Pos.y;
+    }
+
+    /**
+     * Function RevertYAxis
+     * Mirror the rectangle from the X axis (negate Y pos and size)
+     */
+    void RevertYAxis()
+    {
+        m_Pos.y  = -m_Pos.y;
+        m_Size.y = -m_Size.y;
+        Normalize();
+    }
+
+    /**
+     * Function Intersects
+     * tests for a common area between rectangles.
+     *
+     * @param aRect A rectangle to test intersection with.
+     * @return bool - true if the argument rectangle intersects this rectangle.
+     * (i.e. if the 2 rectangles have at least a common point)
+     */
+    bool Intersects( const EDA_RECT& aRect ) const;
+
+    /**
+     * Function Intersects
+     * tests for a common area between a segment and this rectangle.
+     *
+     * @param aPoint1 First point of the segment to test intersection with.
+     * @param aPoint2 Second point of the segment to test intersection with.
+     * @return bool - true if the argument segment intersects this rectangle.
+     * (i.e. if the segment and rectangle have at least a common point)
+     */
+    bool Intersects( const wxPoint& aPoint1, const wxPoint& aPoint2 ) const;
+
+    /**
+     * Function operator(wxRect)
+     * overloads the cast operator to return a wxRect
+     * wxRect does not accept negative values for size, so ensure the
+     * wxRect size is always >= 0
+     */
+    operator wxRect() const
+    {
+        EDA_RECT rect( m_Pos, m_Size );
+        rect.Normalize();
+        return wxRect( rect.m_Pos, rect.m_Size );
+    }
+
+    /**
+     * Function Inflate
+     * inflates the rectangle horizontally by \a dx and vertically by \a dy. If \a dx
+     * and/or \a dy is negative the rectangle is deflated.
+     */
+    EDA_RECT& Inflate( wxCoord dx, wxCoord dy );
+
+    /**
+     * Function Inflate
+     * inflates the rectangle horizontally and vertically by \a aDelta. If \a aDelta
+     * is negative the rectangle is deflated.
+     */
+    EDA_RECT& Inflate( int aDelta );
+
+    /**
+     * Function Merge
+     * modifies the position and size of the rectangle in order to contain \a aRect.  It is
+     * mainly used to calculate bounding boxes.
+     * @param aRect  The rectangle to merge with this rectangle.
+     */
+    void Merge( const EDA_RECT& aRect );
+
+    /**
+     * Function Merge
+     * modifies the position and size of the rectangle in order to contain the given point.
+     * @param aPoint The point to merge with the rectangle.
+     */
+    void Merge( const wxPoint& aPoint );
+
+    /**
+     * Function GetArea
+     * returns the area of the rectangle.
+     * @return The area of the rectangle.
+     */
+    double GetArea() const;
+
+    /**
+     * Function Common
+     * returns the area that is common with another rectangle.
+     * @param aRect is the rectangle to find the common area with.
+     * @return The common area rect or 0-sized rectangle if there is no intersection.
+     */
+    EDA_RECT Common( const EDA_RECT& aRect ) const;
+
+    /**
+     * Function GetBoundingBoxRotated
+     * @return the bounding box of this, after rotation
+     * @param aAngle = the rotation angle in 0.1 deg.
+     * @param aRotCenter = the rotation point.
+     * useful to calculate bounding box of rotated items, when
+     * rotation if not k*90 degrees
+     */
+    const EDA_RECT GetBoundingBoxRotated( wxPoint aRotCenter, double aAngle );
+};
+
+
+#endif // CLASS_EDA_RECT_H