1 files changed, 150 insertions, 0 deletions
diff --git a/src/3rdparty/adaptagrams/libavoid/obstacle.h b/src/3rdparty/adaptagrams/libavoid/obstacle.h
new file mode 100644
index 0000000..12c5eca
--- /dev/null
+++ b/src/3rdparty/adaptagrams/libavoid/obstacle.h
@@ -0,0 +1,150 @@
+/*
+ * vim: ts=4 sw=4 et tw=0 wm=0
+ *
+ * libavoid - Fast, Incremental, Object-avoiding Line Router
+ *
+ * Copyright (C) 2004-2014  Monash University
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * See the file LICENSE.LGPL distributed with the library.
+ *
+ * Licensees holding a valid commercial license may use this file in
+ * accordance with the commercial license agreement provided with the 
+ * library.
+ *
+ * This library 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.  
+ *
+ * Author(s):   Michael Wybrow
+*/
+
+//! @file    obstacle.h
+//! @brief   Contains the interface for the Obstacle class, 
+//!          the superclass for ShapeRef and JunctionRef.
+
+
+#ifndef AVOID_OBSTACLE_H
+#define AVOID_OBSTACLE_H
+
+#include <list>
+#include <set>
+
+#include <cstdio>
+
+#include "libavoid/geometry.h"
+#include "libavoid/connectionpin.h"
+
+
+namespace Avoid {
+
+class VertInf;
+class Router;
+class Obstacle;
+class ConnEnd;
+class ConnRef;
+typedef std::list<Obstacle *> ObstacleList;
+typedef std::list<ConnRef *> ConnRefList;
+
+
+// @brief   The Obstacle class represents an obstacle that must be 
+//          routed around.  Superclass of ShapeRef and JunctionRef.
+//
+class Obstacle
+{
+    public:
+        //! @brief  Obstacle reference constructor.
+        //!
+        //! Creates an obstacle object reference.  It is expected that you
+        //! would not instantiate an Obstacle directly, but would instead
+        //! use either ShapeRef() or JunctionRef().
+        //!
+        //! @param[in]  router  The router scene to place the shape into.
+        //! @param[in]  poly    A Polygon representing the boundary of the 
+        //!                     shape.
+        //! @param[in]  id      A unique positive integer ID for the shape.  
+        Obstacle(Router *router, Polygon poly, const unsigned int id = 0);
+
+// To prevent C++ objects from being destroyed in garbage collected languages
+// when the libraries are called from SWIG, we hide the declarations of the
+// destructors and prevent generation of default destructors.
+#ifndef SWIG
+        //! @brief  Obstacle reference destructor.
+        //!
+        virtual ~Obstacle();
+#endif
+        
+        //! @brief   Returns the ID of this obstacle.
+        //! @returns The ID of the obstacle.
+        unsigned int id(void) const;
+        //! @brief   Returns a reference to the polygon boundary of this
+        //!          obstacle.
+        //! @returns A reference to the polygon boundary of the obstacle.
+        const Polygon& polygon(void) const;
+        //! @brief   Returns a pointer to the router scene this obstacle
+        //!          is in.
+        //! @returns A pointer to the router scene for this obstacle.
+        Router *router(void) const;
+        //! @brief   Returns the position of this obstacle.
+        //! @returns A point representing the position of this obstacle.
+        virtual Point position(void) const = 0;
+        
+        void setNewPoly(const Polygon& poly);
+        VertInf *firstVert(void);
+        VertInf *lastVert(void);
+        Box routingBox(void) const;
+        Polygon routingPolygon(void) const;
+        ConnRefList attachedConnectors(void) const;
+
+    private:
+        friend class Router;
+        friend class ConnEnd;
+        friend class ShapeConnectionPin;
+        friend class HyperedgeRerouter;
+        friend class HyperedgeImprover;
+        friend class MinimumTerminalSpanningTree;
+
+        // Defined in visibility.cpp:
+        void computeVisibilityNaive(void);
+        void computeVisibilitySweep(void);
+       
+        virtual void outputCode(FILE *fp) const = 0;
+        void makeActive(void);
+        void makeInactive(void);
+        bool isActive(void) const;
+        void updatePinPolyLineVisibility(void);
+        void removeFromGraph(void);
+        Point shapeCentre(void);
+
+        VertInf *getPointVertex(const Point& point);
+
+        void addFollowingConnEnd(ConnEnd *connEnd);
+        void removeFollowingConnEnd(ConnEnd *connEnd);
+        size_t addConnectionPin(ShapeConnectionPin *pin);
+        void removeConnectionPin(ShapeConnectionPin *pin);
+        void assignPinVisibilityTo(const unsigned int pinClassId, 
+                VertInf *dummyConnectionVert);
+        std::vector<Point> possiblePinPoints(unsigned int pinClassId) const;
+
+    protected:
+        Router *m_router;
+        unsigned int m_id;
+        Polygon m_polygon;
+        bool m_active;
+        ObstacleList::iterator m_router_obstacles_pos;
+        VertInf *m_first_vert;
+        VertInf *m_last_vert;
+        std::set<ConnEnd *> m_following_conns;
+        ShapeConnectionPinSet m_connection_pins;
+};
+
+
+}
+
+
+#endif
+
+