1 files changed, 187 insertions, 0 deletions
diff --git a/src/3rdparty/adaptagrams/libavoid/actioninfo.cpp b/src/3rdparty/adaptagrams/libavoid/actioninfo.cpp
new file mode 100644
index 0000000..b896cb9
--- /dev/null
+++ b/src/3rdparty/adaptagrams/libavoid/actioninfo.cpp
@@ -0,0 +1,187 @@
+/*
+ * vim: ts=4 sw=4 et tw=0 wm=0
+ *
+ * libavoid - Fast, Incremental, Object-avoiding Line Router
+ *
+ * Copyright (C) 2004-2011  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 <algorithm>
+
+#include "libavoid/actioninfo.h"
+#include "libavoid/shape.h"
+#include "libavoid/connector.h"
+#include "libavoid/junction.h"
+
+namespace Avoid {
+
+
+ActionInfo::ActionInfo(ActionType t, ShapeRef *s, const Polygon& p, bool fM)
+    : type(t),
+      objPtr(s),
+      newPoly(p),
+      firstMove(fM)
+{
+    COLA_ASSERT(type == ShapeMove);
+}
+
+
+ActionInfo::ActionInfo(ActionType t, ShapeRef *s)
+    : type(t),
+      objPtr(s)
+
+{
+    COLA_ASSERT((type == ShapeAdd) || (type == ShapeRemove) ||
+            (type == ShapeMove));
+}
+
+
+ActionInfo::ActionInfo(ActionType t, JunctionRef *j, const Point& p)
+    : type(t),
+      objPtr(j),
+      newPosition(p)
+{
+    COLA_ASSERT(type == JunctionMove);
+}
+
+
+ActionInfo::ActionInfo(ActionType t, JunctionRef *j)
+    : type(t),
+      objPtr(j)
+{
+    COLA_ASSERT((type == JunctionAdd) || (type == JunctionRemove) ||
+            (type == JunctionMove));
+}
+
+ActionInfo::ActionInfo(ActionType t, ConnRef *c)
+    : type(t),
+      objPtr(c)
+{
+    COLA_ASSERT(type == ConnChange);
+}
+
+
+ActionInfo::ActionInfo(ActionType t, ShapeConnectionPin *p)
+    : type(t),
+      objPtr(p)
+{
+    COLA_ASSERT(type == ConnectionPinChange);
+}
+
+
+ActionInfo::~ActionInfo()
+{
+}
+
+
+Obstacle *ActionInfo::obstacle(void) const
+{
+    COLA_ASSERT((type == ShapeMove) || (type == ShapeAdd) || 
+            (type == ShapeRemove) || (type == JunctionMove) || 
+            (type == JunctionAdd) || (type == JunctionRemove));
+    return (static_cast<Obstacle *> (objPtr));
+}
+
+
+ShapeRef *ActionInfo::shape(void) const
+{
+    return (dynamic_cast<ShapeRef *> (obstacle()));
+}
+
+
+ConnRef *ActionInfo::conn(void) const
+{
+    COLA_ASSERT(type == ConnChange);
+    return (static_cast<ConnRef *> (objPtr));
+}
+
+JunctionRef *ActionInfo::junction(void) const
+{
+    return (dynamic_cast<JunctionRef *> (obstacle()));
+}
+
+
+void ActionInfo::addConnEndUpdate(const unsigned int type, 
+        const ConnEnd& connEnd, bool isConnPinMoveUpdate)
+{
+    bool alreadyExists = false;
+    for (ConnUpdateList::iterator conn = conns.begin();
+            conn != conns.end(); ++conn)
+    {
+        // Look for an existing queued change to the same end.
+        if (conn->first == type)
+        {
+            // Found a queued change to the same endpoint of the
+            // connector. If this is a pin change as a result of a
+            // shape move, then leave the user created update
+            // that was found (since it may be moving the connection
+            // to connect to a different shape/pin.  But if this is a
+            // user change, then overwrite the previous change.
+            alreadyExists = true;
+            if (!isConnPinMoveUpdate)
+            {
+                // Overwrite the queued change with this one.
+                conn->second = connEnd;
+            }
+            break;
+        }
+    }
+
+    if (!alreadyExists)
+    {
+        // Matching change not found, so add this one.
+        conns.push_back(std::make_pair(type, connEnd));
+    }
+}
+
+
+bool ActionInfo::operator==(const ActionInfo& rhs) const
+{
+    return (type == rhs.type) && (objPtr == rhs.objPtr);
+}
+
+
+bool ActionInfo::operator<(const ActionInfo& rhs) const
+{
+    if (type != rhs.type)
+    {
+        return type < rhs.type;
+    }
+
+    if (type == ConnChange)
+    {
+        return conn()->id() < rhs.conn()->id();
+    }
+    else if (type == ConnectionPinChange)
+    {
+        // NOTE Comparing pointers may not preserve the order of
+        //      objects, but the order of Connection Pins is not
+        //      used so this is not an issue here.
+        return objPtr < rhs.objPtr;
+    }
+    else
+    {
+        return obstacle()->id() < rhs.obstacle()->id();
+    }
+}
+
+
+}
+