1 files changed, 476 insertions, 0 deletions
diff --git a/src/3rdparty/adaptagrams/libavoid/connectionpin.cpp b/src/3rdparty/adaptagrams/libavoid/connectionpin.cpp
new file mode 100644
index 0000000..3d9ba46
--- /dev/null
+++ b/src/3rdparty/adaptagrams/libavoid/connectionpin.cpp
@@ -0,0 +1,476 @@
+/*
+ * vim: ts=4 sw=4 et tw=0 wm=0
+ *
+ * libavoid - Fast, Incremental, Object-avoiding Line Router
+ *
+ * Copyright (C) 2010-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
+*/
+
+#include <cfloat>
+
+#include "libavoid/connectionpin.h"
+#include "libavoid/shape.h"
+#include "libavoid/junction.h"
+#include "libavoid/vertices.h"
+#include "libavoid/router.h"
+#include "libavoid/visibility.h"
+#include "libavoid/debug.h"
+
+
+namespace Avoid {
+
+ShapeConnectionPin::ShapeConnectionPin(ShapeRef *shape, 
+        const unsigned int classId, const double xPortionOffset,
+        const double yPortionOffset, const bool proportional,
+        const double insideOffset, const ConnDirFlags visDirs)
+    : m_shape(shape),
+      m_junction(nullptr),
+      m_class_id(classId),
+      m_x_offset(xPortionOffset),
+      m_y_offset(yPortionOffset),
+      m_inside_offset(insideOffset),
+      m_visibility_directions(visDirs),
+      m_exclusive(true),
+      m_connection_cost(0.0),
+      m_vertex(nullptr),
+      m_using_proportional_offsets(proportional)
+{
+    commonInitForShapeConnection();
+}
+
+ShapeConnectionPin::ShapeConnectionPin(ShapeRef *shape, 
+        const unsigned int classId, const double xOffset,
+        const double yOffset, const double insideOffset,
+        const ConnDirFlags visDirs)
+    : m_shape(shape),
+      m_junction(nullptr),
+      m_class_id(classId),
+      m_x_offset(xOffset),
+      m_y_offset(yOffset),
+      m_inside_offset(insideOffset),
+      m_visibility_directions(visDirs),
+      m_exclusive(true),
+      m_connection_cost(0.0),
+      m_vertex(nullptr),
+      m_using_proportional_offsets(true)
+{
+    commonInitForShapeConnection();
+}
+
+
+void ShapeConnectionPin::commonInitForShapeConnection(void)
+{
+    COLA_ASSERT(m_shape != nullptr);
+    COLA_ASSERT(m_class_id > 0);
+
+    if (m_using_proportional_offsets)
+    {
+        // Parameter checking
+        if ((m_x_offset < 0) || (m_x_offset > 1))
+        {
+            err_printf("xPortionOffset value (%g) in ShapeConnectionPin "
+                    "constructor not between 0 and 1.\n", m_x_offset);
+        }
+        if ((m_y_offset < 0) || (m_y_offset > 1))
+        {
+            err_printf("yPortionOffset value (%g) in ShapeConnectionPin "
+                    "constructor not between 0 and 1.\n", m_y_offset);
+        }
+    }
+    else
+    {
+        const Box shapeBox = m_shape->polygon().offsetBoundingBox(0.0);
+        // Parameter checking
+        if (m_x_offset > shapeBox.width())
+        {
+            err_printf("xOffset value (%g) in ShapeConnectionPin constructor "
+                    "greater than shape width (%g).\n", m_x_offset, 
+                    shapeBox.width());
+        }
+        if (m_y_offset > shapeBox.height())
+        {
+            err_printf("yOffset value (%g) in ShapeConnectionPin constructor "
+                    "greater than shape height (%g).\n", m_y_offset,
+                    shapeBox.height());
+        }
+    }
+
+    m_router = m_shape->router();
+    m_shape->addConnectionPin(this);
+    
+    // Create a visibility vertex for this ShapeConnectionPin.
+    VertID id(m_shape->id(), kShapeConnectionPin, 
+            VertID::PROP_ConnPoint | VertID::PROP_ConnectionPin);
+    m_vertex = new VertInf(m_router, id, this->position());
+    m_vertex->visDirections = this->directions();
+    
+    if (m_vertex->visDirections == ConnDirAll)
+    {
+        // A pin with visibility in all directions is not exclusive 
+        // by default.
+        m_exclusive = false;
+    }
+
+    if (m_router->m_allows_polyline_routing)
+    {
+        vertexVisibility(m_vertex, nullptr, true, true);
+    }
+}
+
+
+ShapeConnectionPin::ShapeConnectionPin(JunctionRef *junction, 
+        const unsigned int classId, const ConnDirFlags visDirs)
+    : m_shape(nullptr),
+      m_junction(junction),
+      m_class_id(classId),
+      m_x_offset(0.0),
+      m_y_offset(0.0),
+      m_inside_offset(0.0),
+      m_visibility_directions(visDirs),
+      m_exclusive(true),
+      m_connection_cost(0.0),
+      m_vertex(nullptr),
+      m_using_proportional_offsets(false)
+{
+    COLA_ASSERT(m_junction != nullptr);
+    m_router = m_junction->router();
+    m_junction->addConnectionPin(this);
+    
+    // Create a visibility vertex for this ShapeConnectionPin.
+    // XXX These IDs should really be uniquely identifiable in case there
+    //     are multiple pins on a shape.  I think currently this case will
+    //     break rubber-band routing.
+    VertID id(m_junction->id(), kShapeConnectionPin, 
+            VertID::PROP_ConnPoint | VertID::PROP_ConnectionPin);
+    m_vertex = new VertInf(m_router, id, m_junction->position());
+    m_vertex->visDirections = visDirs;
+
+    if (m_router->m_allows_polyline_routing)
+    {
+        vertexVisibility(m_vertex, nullptr, true, true);
+    }
+}
+
+
+ShapeConnectionPin::~ShapeConnectionPin()
+{
+    COLA_ASSERT(m_shape || m_junction);
+    if (m_shape)
+    {
+        m_shape->removeConnectionPin(this);
+    }
+    else if (m_junction)
+    {
+        m_junction->removeConnectionPin(this);
+    }
+
+    // Disconnect connend using this pin.
+    while (!m_connend_users.empty())
+    {
+        ConnEnd *connend = *(m_connend_users.begin());
+        connend->freeActivePin();
+    }
+
+    if (m_vertex)
+    {
+        m_vertex->removeFromGraph();
+        m_router->vertices.removeVertex(m_vertex);
+        delete m_vertex;
+        m_vertex = nullptr;
+    }
+}
+
+void ShapeConnectionPin::updatePositionAndVisibility(void)
+{
+    m_vertex->Reset(this->position());
+    m_vertex->visDirections = this->directions();
+    updateVisibility();
+}
+
+void ShapeConnectionPin::updateVisibility(void)
+{
+    m_vertex->removeFromGraph();
+    if (m_router->m_allows_polyline_routing)
+    {
+        vertexVisibility(m_vertex, nullptr, true, true);
+    }
+}
+
+void ShapeConnectionPin::setConnectionCost(const double cost)
+{
+    COLA_ASSERT(cost >= 0);
+
+    m_connection_cost = cost;
+}
+ 
+
+void ShapeConnectionPin::setExclusive(const bool exclusive)
+{
+    m_exclusive = exclusive;
+}
+
+bool ShapeConnectionPin::isExclusive(void) const
+{
+    return m_exclusive;
+}
+
+void ShapeConnectionPin::updatePosition(const Point& newPosition)
+{
+    m_vertex->Reset(newPosition);
+}
+
+
+void ShapeConnectionPin::updatePosition(const Polygon& newPoly)
+{
+    m_vertex->Reset(position(newPoly));
+}
+
+
+const Point ShapeConnectionPin::position(const Polygon& newPoly) const
+{
+    if (m_junction)
+    {
+        return m_junction->position();
+    }
+
+    const Polygon& poly = (newPoly.empty()) ? m_shape->polygon() : newPoly;
+    const Box shapeBox = poly.offsetBoundingBox(0.0);
+
+    Point point;
+
+    if (m_using_proportional_offsets)
+    {
+        // We want to place connection points exactly on the edges of shapes, 
+        // or possibly slightly inside them (if m_insideOfset is set).
+        if (m_x_offset == ATTACH_POS_LEFT)
+        {
+            point.x = shapeBox.min.x + m_inside_offset;
+            point.vn = 6;
+        }
+        else if (m_x_offset == ATTACH_POS_RIGHT)
+        {
+            point.x = shapeBox.max.x - m_inside_offset;
+            point.vn = 4;
+        }
+        else
+        {
+            point.x = shapeBox.min.x + (m_x_offset * shapeBox.width());
+        }
+
+        if (m_y_offset == ATTACH_POS_TOP)
+        {
+            point.y = shapeBox.min.y + m_inside_offset;
+            point.vn = 5;
+        }
+        else if (m_y_offset == ATTACH_POS_BOTTOM)
+        {
+            point.y = shapeBox.max.y - m_inside_offset;
+            point.vn = 7;
+        }
+        else
+        {
+            point.y = shapeBox.min.y + (m_y_offset * shapeBox.height());
+        }
+    }
+    else
+    {
+        // Using absolute offsets for connection pin position.
+        if (m_x_offset == ATTACH_POS_MIN_OFFSET)
+        {
+            point.x = shapeBox.min.x + m_inside_offset;
+            point.vn = 6;
+        }
+        else if ((m_x_offset == ATTACH_POS_MAX_OFFSET) ||
+                 (m_x_offset == shapeBox.width()))
+        {
+            point.x = shapeBox.max.x - m_inside_offset;
+            point.vn = 4;
+        }
+        else
+        {
+            point.x = shapeBox.min.x + m_x_offset;
+        }
+
+        if (m_y_offset == ATTACH_POS_MIN_OFFSET)
+        {
+            point.y = shapeBox.min.y + m_inside_offset;
+            point.vn = 5;
+        }
+        else if ((m_y_offset == ATTACH_POS_MAX_OFFSET) ||
+                 (m_y_offset == shapeBox.height()))
+        {
+            point.y = shapeBox.max.y - m_inside_offset;
+            point.vn = 7;
+        }
+        else
+        {
+            point.y = shapeBox.min.y + m_y_offset;
+        }
+    }
+
+    return point;
+}
+
+
+ConnDirFlags ShapeConnectionPin::directions(void) const
+{
+    ConnDirFlags visDir = m_visibility_directions;
+    if (m_visibility_directions == ConnDirNone)
+    {
+        // None is set, use the defaults:
+        if (m_x_offset == ATTACH_POS_LEFT)
+        {
+            visDir |= ConnDirLeft;
+        }
+        else if (m_x_offset == ATTACH_POS_RIGHT)
+        {
+            visDir |= ConnDirRight;
+        }
+
+        if (m_y_offset == ATTACH_POS_TOP)
+        {
+            visDir |= ConnDirUp;
+        }
+        else if (m_y_offset == ATTACH_POS_BOTTOM)
+        {
+            visDir |= ConnDirDown;
+        }
+
+        if (visDir == ConnDirNone)
+        {
+            visDir = ConnDirAll;
+        }
+    }
+    return visDir;
+}
+
+void ShapeConnectionPin::outputCode(FILE *fp) const
+{
+    COLA_ASSERT(m_shape || m_junction);
+    if (m_shape)
+    {
+        fprintf(fp, "    connPin = new ShapeConnectionPin(shapeRef%u, %u, "
+                "%" PREC "g, %" PREC "g, %s, %g, (ConnDirFlags) %u);\n",
+                m_shape->id(), m_class_id, m_x_offset, m_y_offset, 
+                (m_using_proportional_offsets ? "true" : "false"),
+                m_inside_offset, (unsigned int) m_visibility_directions);
+    }
+    else if (m_junction)
+    {
+        fprintf(fp, "    connPin = new ShapeConnectionPin(junctionRef%u, %u, "
+                "(ConnDirFlags) %u);\n", m_junction->id(), m_class_id, 
+                (unsigned int) m_visibility_directions);
+    }
+
+    if ((m_vertex->visDirections != ConnDirAll) && (m_exclusive == false))
+    {
+        // Directional port is not exclusive (the default), so output this.
+        fprintf(fp, "    connPin->setExclusive(false);\n");
+    }
+}
+
+ConnectionPinIds ShapeConnectionPin::ids(void) const
+{
+    return std::make_pair(containingObjectId(), m_class_id);
+}
+
+unsigned int ShapeConnectionPin::containingObjectId(void) const
+{
+    COLA_ASSERT(m_shape || m_junction);
+    return (m_shape) ? m_shape->id() : m_junction->id();
+}
+
+bool ShapeConnectionPin::operator==(const ShapeConnectionPin& rhs) const
+{
+    COLA_ASSERT(m_router == rhs.m_router);
+
+    if (containingObjectId() != rhs.containingObjectId())
+    {
+        return false;
+    }
+
+    // The shape/junction is equal, so examine the unique members.
+    if (m_class_id != rhs.m_class_id)
+    {
+        return false;
+    }
+    if (m_visibility_directions != rhs.m_visibility_directions)
+    {
+        return false;
+    }
+    if (m_x_offset != rhs.m_x_offset)
+    {
+       return false;
+    }
+    if (m_y_offset != rhs.m_y_offset)
+    {
+       return false;
+    }
+    if (m_inside_offset != rhs.m_inside_offset)
+    {
+       return false;
+    } 
+    return true;  
+}
+
+bool ShapeConnectionPin::operator<(const ShapeConnectionPin& rhs) const
+{
+    COLA_ASSERT(m_router == rhs.m_router);
+
+    if (containingObjectId() != rhs.containingObjectId())
+    {
+        return containingObjectId() < rhs.containingObjectId();
+    }
+    // Note: operator< is used for set ordering within each shape or junction,
+    // so the m_shape/m_junction values should match and we needn't perform the
+    // above test in most cases and could just assert the following:
+    // COLA_ASSERT(m_shape == rhs.m_shape);
+    // COLA_ASSERT(m_junction == rhs.m_junction);
+
+    if (m_class_id != rhs.m_class_id)
+    {
+        return m_class_id < rhs.m_class_id;
+    }
+    if (m_visibility_directions != rhs.m_visibility_directions)
+    {
+        return m_visibility_directions < rhs.m_visibility_directions;
+    }
+    if (m_x_offset != rhs.m_x_offset)
+    {
+        return m_x_offset < rhs.m_x_offset;
+    }
+    if (m_y_offset != rhs.m_y_offset)
+    {
+        return m_y_offset < rhs.m_y_offset;
+    }
+    if (m_inside_offset != rhs.m_inside_offset)
+    {
+        return m_inside_offset < rhs.m_inside_offset;
+    }
+
+    // Otherwise, they are considered the same.
+    return false;
+} 
+
+
+//============================================================================
+
+}
+
+