summaryrefslogtreecommitdiffstats
path: root/src/3rdparty/adaptagrams/libavoid/connend.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/3rdparty/adaptagrams/libavoid/connend.h')
-rw-r--r--src/3rdparty/adaptagrams/libavoid/connend.h267
1 files changed, 267 insertions, 0 deletions
diff --git a/src/3rdparty/adaptagrams/libavoid/connend.h b/src/3rdparty/adaptagrams/libavoid/connend.h
new file mode 100644
index 0000000..74f8cbc
--- /dev/null
+++ b/src/3rdparty/adaptagrams/libavoid/connend.h
@@ -0,0 +1,267 @@
+/*
+ * 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 connend.h
+//! @brief Contains the interface for the ConnEnd class.
+
+
+#ifndef AVOID_CONNEND_H
+#define AVOID_CONNEND_H
+
+
+#include <cstdio>
+#include <list>
+#include <vector>
+#include <utility>
+
+#include "libavoid/dllexport.h"
+#include "libavoid/geometry.h"
+
+
+namespace Avoid {
+
+class Obstacle;
+class ShapeRef;
+class JunctionRef;
+class Router;
+class ConnRef;
+class ShapeConnectionPin;
+typedef std::list<ConnRef *> ConnRefList;
+class VertInf;
+
+
+//! @brief Flags that can be passed to the ConnEnd constructor to specify
+//! which sides of a shape this point should have visibility to if
+//! it is located within the shape's area.
+//!
+//! Like SVG, libavoid considers the Y-axis to point downwards, that is,
+//! like screen coordinates the coordinates increase from left-to-right and
+//! also from top-to-bottom.
+//!
+enum ConnDirFlag {
+ ConnDirNone = 0,
+ //! @brief This option specifies the point should be given visibility
+ //! to the top of the shape that it is located within.
+ ConnDirUp = 1,
+ //! @brief This option specifies the point should be given visibility
+ //! to the bottom of the shape that it is located within.
+ ConnDirDown = 2,
+ //! @brief This option specifies the point should be given visibility
+ //! to the left side of the shape that it is located within.
+ ConnDirLeft = 4,
+ //! @brief This option specifies the point should be given visibility
+ //! to the right side of the shape that it is located within.
+ ConnDirRight = 8,
+ //! @brief This option, provided for convenience, specifies the point
+ //! should be given visibility to all four sides of the shape
+ //! that it is located within.
+ ConnDirAll = 15
+};
+//! @brief One or more Avoid::ConnDirFlag options.
+//!
+typedef unsigned int ConnDirFlags;
+
+
+//! @brief Types that describe the kind a connection that a ConnEnd
+//! represents.
+//!
+enum ConnEndType {
+ //! @brief The ConnEnd represents a free-floating point that may or may
+ //! not have visibility in specific directions.
+ ConnEndPoint,
+ //! @brief The ConnEnd attaches to a specific ShapeConnectionPin on a
+ //! shape.
+ ConnEndShapePin,
+ //! @brief The ConnEnd attaches to a junction.
+ ConnEndJunction,
+ //! @brief The ConnEnd is empty and doesn't have any information set.
+ ConnEndEmpty
+};
+
+
+//! @brief The ConnEnd class represents different possible endpoints for
+//! connectors.
+//!
+//! ConnEnds may be free-floating points, points attached to junctions (between
+//! multiple connectors), or points attached to shapes (either to the centre of
+//! the shape or to particular pin positions on the shape).
+//!
+class AVOID_EXPORT ConnEnd
+{
+ public:
+ //! @brief Constructs a ConnEnd from a free-floating point.
+ //!
+ //! @param[in] point The position of the connector endpoint.
+ //!
+ ConnEnd(const Point& point);
+
+ //! @brief Constructs a ConnEnd from a free-floating point as well
+ //! as a set of flags specifying visibility for this point
+ //! if it is located inside a shape.
+ //!
+ //! @param[in] point The position of the connector endpoint.
+ //! @param[in] visDirs One or more Avoid::ConnDirFlag options
+ //! specifying the directions that this point
+ //! should be given visibility if it is inside
+ //! a shape. Currently has no effect if outside
+ //! of shapes.
+ //!
+ ConnEnd(const Point& point, const ConnDirFlags visDirs);
+
+ //! @brief Constructs a ConnEnd attached to one of a particular set of
+ //! connection pins on a shape.
+ //!
+ //! This is the recommended method for connecting to shapes that may
+ //! later be moved or resized and for which you don't want to track
+ //! and specify the connector endpoints yourself. See the
+ //! ShapeConnectionPin documentation for more information.
+ //!
+ //! If you to just connect to the centre of a shape you should just
+ //! create a centre connection pin
+ //! @code
+ //! const unsigned int CENTRE = 1;
+ //! new Avoid::ShapeConnectionPin(shapeRef, CENTRE, Avoid::ATTACH_POS_CENTRE, Avoid::ATTACH_POS_CENTRE);
+ //! @endcode
+ //! and attach to that with
+ //! @code
+ //! ConnEnd(shapeRef, CENTRE);
+ //! @endcode
+ //!
+ //! If a pin with the specified pin class ID doesn't exist then you
+ //! will get a warning and a straight-line path between the source
+ //! and destination endpoints of the connector will be returned
+ //! during routing.
+ //!
+ //! @param[in] shapeRef A pointer to the containing shape's
+ //! ShapeRef.
+ //! @param[in] connectionPinClassID A non-zero integer denoting the
+ //! class ID for the set of pins to
+ //! connect to.
+ //!
+ ConnEnd(ShapeRef *shapeRef, const unsigned int connectionPinClassID);
+
+ //! @brief Constructs a ConnEnd attached to one of the connection
+ //! pins on a junction.
+ //!
+ //! This is the recommended method for connecting to junctions that
+ //! may later be moved. See the ShapeConnectionPin documentation for
+ //! more information.
+ //!
+ //! @param[in] junctionRef A pointer to the containing
+ //! junction's junctionRef.
+ //!
+ ConnEnd(JunctionRef *junctionRef);
+
+
+ //! @brief Returns the kind of connection this ConnEnd represents.
+ //!
+ //! @return The ConnEndType represented by this ConnEnd.
+ //!
+ ConnEndType type(void) const;
+
+ //! @brief Returns the position of this connector endpoint.
+ //!
+ //! @return The position of this connector endpoint.
+ //!
+ const Point position(void) const;
+
+ //! @brief Returns the directions in which this connector endpoint
+ //! should be given visibility.
+ //!
+ //! @return The visibility directions for this connector endpoint.
+ //!
+ ConnDirFlags directions(void) const;
+
+ //! @brief Returns the shape this ConnEnd attaches to, or nullptr.
+ //!
+ //! Will be valid only if type() == ConnEndShapePin.
+ //!
+ //! @return The ShapeRef pointer that the ConnEnd attaches to, or nullptr.
+ //!
+ ShapeRef *shape(void) const;
+
+ //! @brief Returns the junction this ConnEnd attaches to, or nullptr.
+ //!
+ //! Will be valid only if type() == ConnEndJunction.
+ //!
+ //! @return The JunctionRef pointer that the ConnEnd attaches to,
+ //! or nullptr.
+ //!
+ JunctionRef *junction(void) const;
+
+ //! @brief Returns the pin class ID for a ConnEnd attached to a shape.
+ //!
+ //! Will be valid only if type() == ConnEndShapePin.
+ //!
+ //! @return An unsigned int representing the pin class ID for the
+ //! ConnEnd.
+ //!
+ unsigned int pinClassId(void) const;
+
+ ConnEnd();
+ ~ConnEnd();
+ private:
+ friend class Obstacle;
+ friend class JunctionRef;
+ friend class ShapeRef;
+ friend class ConnRef;
+ friend class Router;
+ friend class HyperedgeRerouter;
+ friend class ShapeConnectionPin;
+ friend class HyperedgeImprover;
+ friend class CrossingConnectorsInfo;
+
+ void connect(ConnRef *conn);
+ void disconnect(const bool shapeDeleted = false);
+ void usePin(ShapeConnectionPin *pin);
+ void usePinVertex(VertInf *pinVert);
+ void freeActivePin(void);
+ unsigned int endpointType(void) const;
+ bool isPinConnection(void) const;
+ std::vector<Point> possiblePinPoints(void) const;
+ void assignPinVisibilityTo(VertInf *dummyConnectionVert,
+ VertInf *targetVert);
+ void outputCode(FILE *fp, const char *srcDst) const;
+ std::pair<bool, VertInf *> getHyperedgeVertex(Router *router) const;
+
+ ConnEndType m_type;
+ Point m_point;
+ ConnDirFlags m_directions;
+ unsigned int m_connection_pin_class_id;
+
+ // For referencing ConnEnds
+ Obstacle *m_anchor_obj; // The shape/junction this is attached to.
+ ConnRef *m_conn_ref; // The parent connector.
+
+ // The pin to which the ConnEnd is attached.
+ ShapeConnectionPin *m_active_pin;
+};
+
+
+}
+
+
+#endif
+
+