Remove .gitignore do nothing is ignored.

[synfig.git] / ETL / trunk / ETL / _angle.h

diff --git a/ETL/trunk/ETL/_angle.h b/ETL/trunk/ETL/_angle.h
index fcfa9a3..2ea3720 100644 (file)
--- a/ETL/trunk/ETL/_angle.h
+++ b/ETL/trunk/ETL/_angle.h
@@ -1,10 +1,10 @@
-#include <stdio.h>
 /* ========================================================================
 ** Extended Template and Library
 ** Angle Abstraction Class Implementation
 ** $Id$
 **
 ** Copyright (c) 2002 Robert B. Quattlebaum Jr.
+** Copyright (c) 2007 Chris Moore
 **
 ** This package is free software; you can redistribute it and/or
 ** modify it under the terms of the GNU General Public License as
@@ -25,11 +25,12 @@
 
 /* === S T A R T =========================================================== */
 
-#ifndef __ETL_ANGLE_H
-#define __ETL_ANGLE_H
+#ifndef __ETL__ANGLE_H
+#define __ETL__ANGLE_H
 
 /* === H E A D E R S ======================================================= */
 
+#include <cstdio>
 #include <cmath>
 #include <functional>
 
@@ -117,6 +118,7 @@ public:
                return ret;
        }
 
+#ifdef ETL_NOT_USED
        //! 180 degree rotation operator
        /*! Returns the angle directly opposite of
                the given angle, and will yield a result
@@ -128,7 +130,9 @@ public:
                ret.v = v+PI;
                return ret.mod();
        }
+#endif // ETL_NOT_USED
 
+#ifdef ETL_WRAP_ANGLES
        /*! Returns true if the shortest
                angle from the left-hand to the
                right-hand side is counter-clockwise */
@@ -174,6 +178,47 @@ public:
        bool
        operator!=(const angle &rhs)const
        { return std::abs(dist(rhs).v)>ANGLE_EPSILON; }
+#else // ETL_WRAP_ANGLES
+       /*! Returns true if the left-hand
+               side is less than the
+               right-hand side */
+       bool
+       operator<(const angle &rhs)const
+       { return v < rhs.v; }
+
+       /*! Returns true if the left-hand
+               side is greater than the
+               right-hand side */
+       bool
+       operator>(const angle &rhs)const
+       { return v > rhs.v; }
+
+       /*! Returns true if the left-hand
+               side is less or equal to the
+               right-hand side */
+       bool
+       operator<=(const angle &rhs)const
+       { return v <= rhs.v; }
+
+       /*! Returns true if the left-hand
+               side is greater than or equal
+               to the right-hand side */
+       bool
+       operator>=(const angle &rhs)const
+       { return v >= rhs.v; }
+
+       /*! Returns true if the angles
+               are the same, or close */
+       bool
+       operator==(const angle &rhs)const
+       { return std::abs(v - rhs.v)<ANGLE_EPSILON; }
+
+       /*! Returns false if the angles
+               are different */
+       bool
+       operator!=(const angle &rhs)const
+               { return std::abs(v - rhs.v)>ANGLE_EPSILON; }
+#endif // ETL_WRAP_ANGLES
 
        //! Absolute Angle Function
        /*! This function will return the
@@ -186,6 +231,7 @@ public:
                return ret;
        }
 
+#ifdef ETL_WRAP_ANGLES
        //! Angle Difference Function
        /*! This function will return the
                shortest physical distance between
@@ -210,6 +256,26 @@ public:
                ret.v-=rot_floor(ret.v);
                return ret;
        }
+#else // ETL_WRAP_ANGLES
+       //! Angle Difference Function
+       /*! This function will return the
+               difference between
+               two angles, just like
+               \sa angle operator-(const angle &) */
+       angle
+       dist(const angle &rhs)const
+       { return angle(*this)-=rhs; }
+
+       //! Rotation Modulus
+       /*! This function will return the
+               value of the angle */
+       angle
+       mod()const
+       {
+               angle ret(*this);
+               return ret;
+       }
+#endif // ETL_WRAP_ANGLES
 
        //! Zero Rotation (0 degrees)
        static angle
@@ -242,8 +308,10 @@ public:
 
 private:
 
+#ifdef ETL_WRAP_ANGLES
        static value_type rot_floor(value_type x)
        { return static_cast<value_type>(std::floor(x/(PI*2))*PI*2); }
+#endif // ETL_WRAP_ANGLES
 
 public:
        /*