// Bindings utilities
/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function WrapperObject() {
}
WrapperObject.prototype = Object.create(WrapperObject.prototype);
WrapperObject.prototype.constructor = WrapperObject;
WrapperObject.prototype.__class__ = WrapperObject;
WrapperObject.__cache__ = {};
Module['WrapperObject'] = WrapperObject;
/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant)
@param {*=} __class__ */
function getCache(__class__) {
return (__class__ || WrapperObject).__cache__;
}
Module['getCache'] = getCache;
/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant)
@param {*=} __class__ */
function wrapPointer(ptr, __class__) {
var cache = getCache(__class__);
var ret = cache[ptr];
if (ret) return ret;
ret = Object.create((__class__ || WrapperObject).prototype);
ret.ptr = ptr;
return cache[ptr] = ret;
}
Module['wrapPointer'] = wrapPointer;
/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function castObject(obj, __class__) {
return wrapPointer(obj.ptr, __class__);
}
Module['castObject'] = castObject;
Module['NULL'] = wrapPointer(0);
/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function destroy(obj) {
if (!obj['__destroy__']) throw 'Error: Cannot destroy object. (Did you create it yourself?)';
obj['__destroy__']();
// Remove from cache, so the object can be GC'd and refs added onto it released
delete getCache(obj.__class__)[obj.ptr];
}
Module['destroy'] = destroy;
/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function compare(obj1, obj2) {
return obj1.ptr === obj2.ptr;
}
Module['compare'] = compare;
/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function getPointer(obj) {
return obj.ptr;
}
Module['getPointer'] = getPointer;
/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function getClass(obj) {
return obj.__class__;
}
Module['getClass'] = getClass;
// Converts big (string or array) values into a C-style storage, in temporary space
/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
var ensureCache = {
buffer: 0, // the main buffer of temporary storage
size: 0, // the size of buffer
pos: 0, // the next free offset in buffer
temps: [], // extra allocations
needed: 0, // the total size we need next time
prepare: function() {
if (ensureCache.needed) {
// clear the temps
for (var i = 0; i < ensureCache.temps.length; i++) {
Module['_free'](ensureCache.temps[i]);
}
ensureCache.temps.length = 0;
// prepare to allocate a bigger buffer
Module['_free'](ensureCache.buffer);
ensureCache.buffer = 0;
ensureCache.size += ensureCache.needed;
// clean up
ensureCache.needed = 0;
}
if (!ensureCache.buffer) { // happens first time, or when we need to grow
ensureCache.size += 128; // heuristic, avoid many small grow events
ensureCache.buffer = Module['_malloc'](ensureCache.size);
assert(ensureCache.buffer);
}
ensureCache.pos = 0;
},
alloc: function(array, view) {
assert(ensureCache.buffer);
var bytes = view.BYTES_PER_ELEMENT;
var len = array.length * bytes;
len = (len + 7) & -8; // keep things aligned to 8 byte boundaries
var ret;
if (ensureCache.pos + len >= ensureCache.size) {
// we failed to allocate in the buffer, ensureCache time around :(
assert(len > 0); // null terminator, at least
ensureCache.needed += len;
ret = Module['_malloc'](len);
ensureCache.temps.push(ret);
} else {
// we can allocate in the buffer
ret = ensureCache.buffer + ensureCache.pos;
ensureCache.pos += len;
}
return ret;
},
copy: function(array, view, offset) {
offset >>>= 0;
var bytes = view.BYTES_PER_ELEMENT;
switch (bytes) {
case 2: offset >>>= 1; break;
case 4: offset >>>= 2; break;
case 8: offset >>>= 3; break;
}
for (var i = 0; i < array.length; i++) {
view[offset + i] = array[i];
}
},
};
/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function ensureString(value) {
if (typeof value === 'string') {
var intArray = intArrayFromString(value);
var offset = ensureCache.alloc(intArray, HEAP8);
ensureCache.copy(intArray, HEAP8, offset);
return offset;
}
return value;
}
/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function ensureInt8(value) {
if (typeof value === 'object') {
var offset = ensureCache.alloc(value, HEAP8);
ensureCache.copy(value, HEAP8, offset);
return offset;
}
return value;
}
/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function ensureInt16(value) {
if (typeof value === 'object') {
var offset = ensureCache.alloc(value, HEAP16);
ensureCache.copy(value, HEAP16, offset);
return offset;
}
return value;
}
/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function ensureInt32(value) {
if (typeof value === 'object') {
var offset = ensureCache.alloc(value, HEAP32);
ensureCache.copy(value, HEAP32, offset);
return offset;
}
return value;
}
/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function ensureFloat32(value) {
if (typeof value === 'object') {
var offset = ensureCache.alloc(value, HEAPF32);
ensureCache.copy(value, HEAPF32, offset);
return offset;
}
return value;
}
/** @suppress {duplicate} (TODO: avoid emitting this multiple times, it is redundant) */
function ensureFloat64(value) {
if (typeof value === 'object') {
var offset = ensureCache.alloc(value, HEAPF64);
ensureCache.copy(value, HEAPF64, offset);
return offset;
}
return value;
}
// VoidPtr
/**
* @class
*/
function VoidPtr() { throw "cannot construct a VoidPtr, no constructor in IDL" }
VoidPtr.prototype = Object.create(WrapperObject.prototype);
VoidPtr.prototype.constructor = VoidPtr;
VoidPtr.prototype.__class__ = VoidPtr;
VoidPtr.__cache__ = {};
Module['VoidPtr'] = VoidPtr;
VoidPtr.prototype['__destroy__'] = VoidPtr.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_VoidPtr___destroy___0(self);
};
// HyperedgeImprover
/**
* @class
*/
function HyperedgeImprover() {
this.ptr = _emscripten_bind_HyperedgeImprover_HyperedgeImprover_0();
getCache(HyperedgeImprover)[this.ptr] = this;
};;
HyperedgeImprover.prototype = Object.create(WrapperObject.prototype);
HyperedgeImprover.prototype.constructor = HyperedgeImprover;
HyperedgeImprover.prototype.__class__ = HyperedgeImprover;
HyperedgeImprover.__cache__ = {};
Module['HyperedgeImprover'] = HyperedgeImprover;
/**
*
* @returns Void
*/
HyperedgeImprover.prototype['clear'] = HyperedgeImprover.prototype.clear = function() {
var self = this.ptr;
_emscripten_bind_HyperedgeImprover_clear_0(self);
};;
/**
* @param {Router} router
* @returns Void
*/
HyperedgeImprover.prototype['setRouter'] = HyperedgeImprover.prototype.setRouter = function(router) {
var self = this.ptr;
if (router && typeof router === 'object') router = router.ptr;
_emscripten_bind_HyperedgeImprover_setRouter_1(self, router);
};;
HyperedgeImprover.prototype['__destroy__'] = HyperedgeImprover.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_HyperedgeImprover___destroy___0(self);
};
// Box
/**
* @class
*/
function Box() {
this.ptr = _emscripten_bind_Box_Box_0();
getCache(Box)[this.ptr] = this;
};;
Box.prototype = Object.create(WrapperObject.prototype);
Box.prototype.constructor = Box;
Box.prototype.__class__ = Box;
Box.__cache__ = {};
Module['Box'] = Box;
/**
* aaa
* @param {UnsignedLong} dimension
* @returns Double
*/
Box.prototype['length'] = Box.prototype.length = function(dimension) {
var self = this.ptr;
if (dimension && typeof dimension === 'object') dimension = dimension.ptr;
return _emscripten_bind_Box_length_1(self, dimension);
};;
/**
*
* @returns {number}
*/
Box.prototype['width'] = Box.prototype.width = function() {
var self = this.ptr;
return _emscripten_bind_Box_width_0(self);
};;
/**
*
* @returns Double
*/
Box.prototype['height'] = Box.prototype.height = function() {
var self = this.ptr;
return _emscripten_bind_Box_height_0(self);
};;
/* docss */
Box.prototype['get_min'] = Box.prototype.get_min = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_Box_get_min_0(self), Point);
};
/* docsa */
Box.prototype['set_min'] = Box.prototype.set_min = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_Box_set_min_1(self, arg0);
};
Object.defineProperty(Box.prototype, 'min', { get: Box.prototype.get_min, set: Box.prototype.set_min });
/* docss */
Box.prototype['get_max'] = Box.prototype.get_max = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_Box_get_max_0(self), Point);
};
/* docsa */
Box.prototype['set_max'] = Box.prototype.set_max = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_Box_set_max_1(self, arg0);
};
Object.defineProperty(Box.prototype, 'max', { get: Box.prototype.get_max, set: Box.prototype.set_max });
Box.prototype['__destroy__'] = Box.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_Box___destroy___0(self);
};
// PolygonInterface
/**
* @class
*/
function PolygonInterface() { throw "cannot construct a PolygonInterface, no constructor in IDL" }
PolygonInterface.prototype = Object.create(WrapperObject.prototype);
PolygonInterface.prototype.constructor = PolygonInterface;
PolygonInterface.prototype.__class__ = PolygonInterface;
PolygonInterface.__cache__ = {};
Module['PolygonInterface'] = PolygonInterface;
/**
*
* @returns Void
*/
PolygonInterface.prototype['clear'] = PolygonInterface.prototype.clear = function() {
var self = this.ptr;
_emscripten_bind_PolygonInterface_clear_0(self);
};;
/**
*
* @returns Boolean
*/
PolygonInterface.prototype['empty'] = PolygonInterface.prototype.empty = function() {
var self = this.ptr;
return !!(_emscripten_bind_PolygonInterface_empty_0(self));
};;
/**
*
* @returns UnsignedLong
*/
PolygonInterface.prototype['size'] = PolygonInterface.prototype.size = function() {
var self = this.ptr;
return _emscripten_bind_PolygonInterface_size_0(self);
};;
/**
*
* @returns Long
*/
PolygonInterface.prototype['id'] = PolygonInterface.prototype.id = function() {
var self = this.ptr;
return _emscripten_bind_PolygonInterface_id_0(self);
};;
/**
* @param {UnsignedLong} index
* @returns Point (Wrapper)
*/
PolygonInterface.prototype['at'] = PolygonInterface.prototype.at = function(index) {
var self = this.ptr;
if (index && typeof index === 'object') index = index.ptr;
return wrapPointer(_emscripten_bind_PolygonInterface_at_1(self, index), Point);
};;
/**
*
* @returns Polygon (Wrapper)
*/
PolygonInterface.prototype['boundingRectPolygon'] = PolygonInterface.prototype.boundingRectPolygon = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_PolygonInterface_boundingRectPolygon_0(self), Polygon);
};;
/**
* @param {Double} offset
* @returns Box (Wrapper)
*/
PolygonInterface.prototype['offsetBoundingBox'] = PolygonInterface.prototype.offsetBoundingBox = function(offset) {
var self = this.ptr;
if (offset && typeof offset === 'object') offset = offset.ptr;
return wrapPointer(_emscripten_bind_PolygonInterface_offsetBoundingBox_1(self, offset), Box);
};;
/**
* @param {Double} offset
* @returns Polygon (Wrapper)
*/
PolygonInterface.prototype['offsetPolygon'] = PolygonInterface.prototype.offsetPolygon = function(offset) {
var self = this.ptr;
if (offset && typeof offset === 'object') offset = offset.ptr;
return wrapPointer(_emscripten_bind_PolygonInterface_offsetPolygon_1(self, offset), Polygon);
};;
PolygonInterface.prototype['__destroy__'] = PolygonInterface.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_PolygonInterface___destroy___0(self);
};
// Polygon
/**
* @class
*/
function Polygon(n) {
if (n && typeof n === 'object') n = n.ptr;
if (n === undefined) { this.ptr = _emscripten_bind_Polygon_Polygon_0(); getCache(Polygon)[this.ptr] = this;return }
this.ptr = _emscripten_bind_Polygon_Polygon_1(n);
getCache(Polygon)[this.ptr] = this;
};;
Polygon.prototype = Object.create(WrapperObject.prototype);
Polygon.prototype.constructor = Polygon;
Polygon.prototype.__class__ = Polygon;
Polygon.__cache__ = {};
Module['Polygon'] = Polygon;
/**
* @param {UnsignedLong} index
* @param {Point} point
* @returns Void
*/
Polygon.prototype['setPoint'] = Polygon.prototype.setPoint = function(index, point) {
var self = this.ptr;
if (index && typeof index === 'object') index = index.ptr;
if (point && typeof point === 'object') point = point.ptr;
_emscripten_bind_Polygon_setPoint_2(self, index, point);
};;
/**
*
* @returns UnsignedLong
*/
Polygon.prototype['size'] = Polygon.prototype.size = function() {
var self = this.ptr;
return _emscripten_bind_Polygon_size_0(self);
};;
/* docss */
Polygon.prototype['get_ps'] = Polygon.prototype.get_ps = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
return wrapPointer(_emscripten_bind_Polygon_get_ps_1(self, arg0), Point);
};
/* docsa */
Polygon.prototype['set_ps'] = Polygon.prototype.set_ps = function(arg0, arg1) {
var self = this.ptr;
ensureCache.prepare();
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
if (arg1 && typeof arg1 === 'object') arg1 = arg1.ptr;
_emscripten_bind_Polygon_set_ps_2(self, arg0, arg1);
};
Object.defineProperty(Polygon.prototype, 'ps', { get: Polygon.prototype.get_ps, set: Polygon.prototype.set_ps });
Polygon.prototype['__destroy__'] = Polygon.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_Polygon___destroy___0(self);
};
// Point
/**
* @class
*/
function Point(xv, yv) {
if (xv && typeof xv === 'object') xv = xv.ptr;
if (yv && typeof yv === 'object') yv = yv.ptr;
if (xv === undefined) { this.ptr = _emscripten_bind_Point_Point_0(); getCache(Point)[this.ptr] = this;return }
if (yv === undefined) { this.ptr = _emscripten_bind_Point_Point_1(xv); getCache(Point)[this.ptr] = this;return }
this.ptr = _emscripten_bind_Point_Point_2(xv, yv);
getCache(Point)[this.ptr] = this;
};;
Point.prototype = Object.create(WrapperObject.prototype);
Point.prototype.constructor = Point;
Point.prototype.__class__ = Point;
Point.__cache__ = {};
Module['Point'] = Point;
/**
* @param {Point} rhs
* @returns Boolean
*/
Point.prototype['equal'] = Point.prototype.equal = function(rhs) {
var self = this.ptr;
if (rhs && typeof rhs === 'object') rhs = rhs.ptr;
return !!(_emscripten_bind_Point_equal_1(self, rhs));
};;
/* docss */
Point.prototype['get_x'] = Point.prototype.get_x = function() {
var self = this.ptr;
return _emscripten_bind_Point_get_x_0(self);
};
/* docsa */
Point.prototype['set_x'] = Point.prototype.set_x = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_Point_set_x_1(self, arg0);
};
Object.defineProperty(Point.prototype, 'x', { get: Point.prototype.get_x, set: Point.prototype.set_x });
/* docss */
Point.prototype['get_y'] = Point.prototype.get_y = function() {
var self = this.ptr;
return _emscripten_bind_Point_get_y_0(self);
};
/* docsa */
Point.prototype['set_y'] = Point.prototype.set_y = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_Point_set_y_1(self, arg0);
};
Object.defineProperty(Point.prototype, 'y', { get: Point.prototype.get_y, set: Point.prototype.set_y });
/* docss */
Point.prototype['get_id'] = Point.prototype.get_id = function() {
var self = this.ptr;
return _emscripten_bind_Point_get_id_0(self);
};
/* docsa */
Point.prototype['set_id'] = Point.prototype.set_id = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_Point_set_id_1(self, arg0);
};
Object.defineProperty(Point.prototype, 'id', { get: Point.prototype.get_id, set: Point.prototype.set_id });
/* docss */
Point.prototype['get_vn'] = Point.prototype.get_vn = function() {
var self = this.ptr;
return _emscripten_bind_Point_get_vn_0(self);
};
/* docsa */
Point.prototype['set_vn'] = Point.prototype.set_vn = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_Point_set_vn_1(self, arg0);
};
Object.defineProperty(Point.prototype, 'vn', { get: Point.prototype.get_vn, set: Point.prototype.set_vn });
Point.prototype['__destroy__'] = Point.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_Point___destroy___0(self);
};
// HyperedgeTreeNode
/**
* @class
*/
function HyperedgeTreeNode() {
this.ptr = _emscripten_bind_HyperedgeTreeNode_HyperedgeTreeNode_0();
getCache(HyperedgeTreeNode)[this.ptr] = this;
};;
HyperedgeTreeNode.prototype = Object.create(WrapperObject.prototype);
HyperedgeTreeNode.prototype.constructor = HyperedgeTreeNode;
HyperedgeTreeNode.prototype.__class__ = HyperedgeTreeNode;
HyperedgeTreeNode.__cache__ = {};
Module['HyperedgeTreeNode'] = HyperedgeTreeNode;
/**
* @param {HyperedgeTreeEdge} ignored
* @param {UnsignedLong} pass
* @returns Void
*/
HyperedgeTreeNode.prototype['writeEdgesToConns'] = HyperedgeTreeNode.prototype.writeEdgesToConns = function(ignored, pass) {
var self = this.ptr;
if (ignored && typeof ignored === 'object') ignored = ignored.ptr;
if (pass && typeof pass === 'object') pass = pass.ptr;
_emscripten_bind_HyperedgeTreeNode_writeEdgesToConns_2(self, ignored, pass);
};;
HyperedgeTreeNode.prototype['__destroy__'] = HyperedgeTreeNode.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_HyperedgeTreeNode___destroy___0(self);
};
// HyperedgeTreeEdge
/**
* @class
*/
function HyperedgeTreeEdge(node1, node2, conn) {
if (node1 && typeof node1 === 'object') node1 = node1.ptr;
if (node2 && typeof node2 === 'object') node2 = node2.ptr;
if (conn && typeof conn === 'object') conn = conn.ptr;
this.ptr = _emscripten_bind_HyperedgeTreeEdge_HyperedgeTreeEdge_3(node1, node2, conn);
getCache(HyperedgeTreeEdge)[this.ptr] = this;
};;
HyperedgeTreeEdge.prototype = Object.create(WrapperObject.prototype);
HyperedgeTreeEdge.prototype.constructor = HyperedgeTreeEdge;
HyperedgeTreeEdge.prototype.__class__ = HyperedgeTreeEdge;
HyperedgeTreeEdge.__cache__ = {};
Module['HyperedgeTreeEdge'] = HyperedgeTreeEdge;
HyperedgeTreeEdge.prototype['__destroy__'] = HyperedgeTreeEdge.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_HyperedgeTreeEdge___destroy___0(self);
};
// AStarPath
/**
* @class
*/
function AStarPath() {
this.ptr = _emscripten_bind_AStarPath_AStarPath_0();
getCache(AStarPath)[this.ptr] = this;
};;
AStarPath.prototype = Object.create(WrapperObject.prototype);
AStarPath.prototype.constructor = AStarPath;
AStarPath.prototype.__class__ = AStarPath;
AStarPath.__cache__ = {};
Module['AStarPath'] = AStarPath;
/**
* @param {ConnRef} lineRef
* @param {VertInf} src
* @param {VertInf} tar
* @param {VertInf} start
* @returns Void
*/
AStarPath.prototype['search'] = AStarPath.prototype.search = function(lineRef, src, tar, start) {
var self = this.ptr;
if (lineRef && typeof lineRef === 'object') lineRef = lineRef.ptr;
if (src && typeof src === 'object') src = src.ptr;
if (tar && typeof tar === 'object') tar = tar.ptr;
if (start && typeof start === 'object') start = start.ptr;
_emscripten_bind_AStarPath_search_4(self, lineRef, src, tar, start);
};;
AStarPath.prototype['__destroy__'] = AStarPath.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_AStarPath___destroy___0(self);
};
// ConnEnd
/**
* @class
*/
function ConnEnd(point, visDirs) {
if (point && typeof point === 'object') point = point.ptr;
if (visDirs && typeof visDirs === 'object') visDirs = visDirs.ptr;
if (visDirs === undefined) { this.ptr = _emscripten_bind_ConnEnd_ConnEnd_1(point); getCache(ConnEnd)[this.ptr] = this;return }
this.ptr = _emscripten_bind_ConnEnd_ConnEnd_2(point, visDirs);
getCache(ConnEnd)[this.ptr] = this;
};;
ConnEnd.prototype = Object.create(WrapperObject.prototype);
ConnEnd.prototype.constructor = ConnEnd;
ConnEnd.prototype.__class__ = ConnEnd;
ConnEnd.__cache__ = {};
Module['ConnEnd'] = ConnEnd;
ConnEnd.prototype['__destroy__'] = ConnEnd.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_ConnEnd___destroy___0(self);
};
// ActionInfo
/**
* @class
*/
function ActionInfo(t, s, p, fm) {
if (t && typeof t === 'object') t = t.ptr;
if (s && typeof s === 'object') s = s.ptr;
if (p && typeof p === 'object') p = p.ptr;
if (fm && typeof fm === 'object') fm = fm.ptr;
if (p === undefined) { this.ptr = _emscripten_bind_ActionInfo_ActionInfo_2(t, s); getCache(ActionInfo)[this.ptr] = this;return }
if (fm === undefined) { this.ptr = _emscripten_bind_ActionInfo_ActionInfo_3(t, s, p); getCache(ActionInfo)[this.ptr] = this;return }
this.ptr = _emscripten_bind_ActionInfo_ActionInfo_4(t, s, p, fm);
getCache(ActionInfo)[this.ptr] = this;
};;
ActionInfo.prototype = Object.create(WrapperObject.prototype);
ActionInfo.prototype.constructor = ActionInfo;
ActionInfo.prototype.__class__ = ActionInfo;
ActionInfo.__cache__ = {};
Module['ActionInfo'] = ActionInfo;
/**
*
* @returns Obstacle (Wrapper)
*/
ActionInfo.prototype['obstacle'] = ActionInfo.prototype.obstacle = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_ActionInfo_obstacle_0(self), Obstacle);
};;
/**
*
* @returns ShapeRef (Wrapper)
*/
ActionInfo.prototype['shape'] = ActionInfo.prototype.shape = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_ActionInfo_shape_0(self), ShapeRef);
};;
/**
*
* @returns ConnRef (Wrapper)
*/
ActionInfo.prototype['conn'] = ActionInfo.prototype.conn = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_ActionInfo_conn_0(self), ConnRef);
};;
/**
*
* @returns JunctionRef (Wrapper)
*/
ActionInfo.prototype['junction'] = ActionInfo.prototype.junction = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_ActionInfo_junction_0(self), JunctionRef);
};;
/**
* @param {UnsignedLong} type
* @param {ConnEnd} connEnd
* @param {Boolean} isConnPinMoveUpdate
* @returns Void
*/
ActionInfo.prototype['addConnEndUpdate'] = ActionInfo.prototype.addConnEndUpdate = function(type, connEnd, isConnPinMoveUpdate) {
var self = this.ptr;
if (type && typeof type === 'object') type = type.ptr;
if (connEnd && typeof connEnd === 'object') connEnd = connEnd.ptr;
if (isConnPinMoveUpdate && typeof isConnPinMoveUpdate === 'object') isConnPinMoveUpdate = isConnPinMoveUpdate.ptr;
_emscripten_bind_ActionInfo_addConnEndUpdate_3(self, type, connEnd, isConnPinMoveUpdate);
};;
/* docss */
ActionInfo.prototype['get_type'] = ActionInfo.prototype.get_type = function() {
var self = this.ptr;
return _emscripten_bind_ActionInfo_get_type_0(self);
};
/* docsa */
ActionInfo.prototype['set_type'] = ActionInfo.prototype.set_type = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_ActionInfo_set_type_1(self, arg0);
};
Object.defineProperty(ActionInfo.prototype, 'type', { get: ActionInfo.prototype.get_type, set: ActionInfo.prototype.set_type });
/* docss */
ActionInfo.prototype['get_objPtr'] = ActionInfo.prototype.get_objPtr = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_ActionInfo_get_objPtr_0(self), VoidPtr);
};
/* docsa */
ActionInfo.prototype['set_objPtr'] = ActionInfo.prototype.set_objPtr = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_ActionInfo_set_objPtr_1(self, arg0);
};
Object.defineProperty(ActionInfo.prototype, 'objPtr', { get: ActionInfo.prototype.get_objPtr, set: ActionInfo.prototype.set_objPtr });
/* docss */
ActionInfo.prototype['get_newPoly'] = ActionInfo.prototype.get_newPoly = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_ActionInfo_get_newPoly_0(self), Polygon);
};
/* docsa */
ActionInfo.prototype['set_newPoly'] = ActionInfo.prototype.set_newPoly = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_ActionInfo_set_newPoly_1(self, arg0);
};
Object.defineProperty(ActionInfo.prototype, 'newPoly', { get: ActionInfo.prototype.get_newPoly, set: ActionInfo.prototype.set_newPoly });
/* docss */
ActionInfo.prototype['get_newPosition'] = ActionInfo.prototype.get_newPosition = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_ActionInfo_get_newPosition_0(self), Point);
};
/* docsa */
ActionInfo.prototype['set_newPosition'] = ActionInfo.prototype.set_newPosition = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_ActionInfo_set_newPosition_1(self, arg0);
};
Object.defineProperty(ActionInfo.prototype, 'newPosition', { get: ActionInfo.prototype.get_newPosition, set: ActionInfo.prototype.set_newPosition });
/* docss */
ActionInfo.prototype['get_firstMove'] = ActionInfo.prototype.get_firstMove = function() {
var self = this.ptr;
return !!(_emscripten_bind_ActionInfo_get_firstMove_0(self));
};
/* docsa */
ActionInfo.prototype['set_firstMove'] = ActionInfo.prototype.set_firstMove = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_ActionInfo_set_firstMove_1(self, arg0);
};
Object.defineProperty(ActionInfo.prototype, 'firstMove', { get: ActionInfo.prototype.get_firstMove, set: ActionInfo.prototype.set_firstMove });
ActionInfo.prototype['__destroy__'] = ActionInfo.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_ActionInfo___destroy___0(self);
};
// ShapeConnectionPin
/**
* @class
*/
function ShapeConnectionPin(shape, classId, xOffset, yOffset, proportional, insideOffset, visDirs) {
if (shape && typeof shape === 'object') shape = shape.ptr;
if (classId && typeof classId === 'object') classId = classId.ptr;
if (xOffset && typeof xOffset === 'object') xOffset = xOffset.ptr;
if (yOffset && typeof yOffset === 'object') yOffset = yOffset.ptr;
if (proportional && typeof proportional === 'object') proportional = proportional.ptr;
if (insideOffset && typeof insideOffset === 'object') insideOffset = insideOffset.ptr;
if (visDirs && typeof visDirs === 'object') visDirs = visDirs.ptr;
if (xOffset === undefined) { this.ptr = _emscripten_bind_ShapeConnectionPin_ShapeConnectionPin_2(shape, classId); getCache(ShapeConnectionPin)[this.ptr] = this;return }
if (yOffset === undefined) { this.ptr = _emscripten_bind_ShapeConnectionPin_ShapeConnectionPin_3(shape, classId, xOffset); getCache(ShapeConnectionPin)[this.ptr] = this;return }
if (proportional === undefined) { this.ptr = _emscripten_bind_ShapeConnectionPin_ShapeConnectionPin_4(shape, classId, xOffset, yOffset); getCache(ShapeConnectionPin)[this.ptr] = this;return }
if (insideOffset === undefined) { this.ptr = _emscripten_bind_ShapeConnectionPin_ShapeConnectionPin_5(shape, classId, xOffset, yOffset, proportional); getCache(ShapeConnectionPin)[this.ptr] = this;return }
if (visDirs === undefined) { this.ptr = _emscripten_bind_ShapeConnectionPin_ShapeConnectionPin_6(shape, classId, xOffset, yOffset, proportional, insideOffset); getCache(ShapeConnectionPin)[this.ptr] = this;return }
this.ptr = _emscripten_bind_ShapeConnectionPin_ShapeConnectionPin_7(shape, classId, xOffset, yOffset, proportional, insideOffset, visDirs);
getCache(ShapeConnectionPin)[this.ptr] = this;
};;
ShapeConnectionPin.prototype = Object.create(WrapperObject.prototype);
ShapeConnectionPin.prototype.constructor = ShapeConnectionPin;
ShapeConnectionPin.prototype.__class__ = ShapeConnectionPin;
ShapeConnectionPin.__cache__ = {};
Module['ShapeConnectionPin'] = ShapeConnectionPin;
/**
* @param {Double} cost
* @returns Void
*/
ShapeConnectionPin.prototype['setConnectionCost'] = ShapeConnectionPin.prototype.setConnectionCost = function(cost) {
var self = this.ptr;
if (cost && typeof cost === 'object') cost = cost.ptr;
_emscripten_bind_ShapeConnectionPin_setConnectionCost_1(self, cost);
};;
/**
* @param {Polygon} newPoly
* @returns Point (Wrapper)
*/
ShapeConnectionPin.prototype['position'] = ShapeConnectionPin.prototype.position = function(newPoly) {
var self = this.ptr;
if (newPoly && typeof newPoly === 'object') newPoly = newPoly.ptr;
if (newPoly === undefined) { return wrapPointer(_emscripten_bind_ShapeConnectionPin_position_0(self), Point) }
return wrapPointer(_emscripten_bind_ShapeConnectionPin_position_1(self, newPoly), Point);
};;
/**
*
* @returns UnsignedLong
*/
ShapeConnectionPin.prototype['directions'] = ShapeConnectionPin.prototype.directions = function() {
var self = this.ptr;
return _emscripten_bind_ShapeConnectionPin_directions_0(self);
};;
/**
* @param {Boolean} exclusive
* @returns Void
*/
ShapeConnectionPin.prototype['setExclusive'] = ShapeConnectionPin.prototype.setExclusive = function(exclusive) {
var self = this.ptr;
if (exclusive && typeof exclusive === 'object') exclusive = exclusive.ptr;
_emscripten_bind_ShapeConnectionPin_setExclusive_1(self, exclusive);
};;
/**
*
* @returns Boolean
*/
ShapeConnectionPin.prototype['isExclusive'] = ShapeConnectionPin.prototype.isExclusive = function() {
var self = this.ptr;
return !!(_emscripten_bind_ShapeConnectionPin_isExclusive_0(self));
};;
ShapeConnectionPin.prototype['__destroy__'] = ShapeConnectionPin.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_ShapeConnectionPin___destroy___0(self);
};
// Obstacle
/**
* @class
*/
function Obstacle() { throw "cannot construct a Obstacle, no constructor in IDL" }
Obstacle.prototype = Object.create(WrapperObject.prototype);
Obstacle.prototype.constructor = Obstacle;
Obstacle.prototype.__class__ = Obstacle;
Obstacle.__cache__ = {};
Module['Obstacle'] = Obstacle;
/**
*
* @returns UnsignedLong
*/
Obstacle.prototype['id'] = Obstacle.prototype.id = function() {
var self = this.ptr;
return _emscripten_bind_Obstacle_id_0(self);
};;
/**
*
* @returns Polygon (Wrapper)
*/
Obstacle.prototype['polygon'] = Obstacle.prototype.polygon = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_Obstacle_polygon_0(self), Polygon);
};;
/**
*
* @returns Router (Wrapper)
*/
Obstacle.prototype['router'] = Obstacle.prototype.router = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_Obstacle_router_0(self), Router);
};;
/**
*
* @returns Point (Wrapper)
*/
Obstacle.prototype['position'] = Obstacle.prototype.position = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_Obstacle_position_0(self), Point);
};;
Obstacle.prototype['__destroy__'] = Obstacle.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_Obstacle___destroy___0(self);
};
// JunctionRef
/**
* @class
*/
function JunctionRef(router, position, id) {
if (router && typeof router === 'object') router = router.ptr;
if (position && typeof position === 'object') position = position.ptr;
if (id && typeof id === 'object') id = id.ptr;
if (id === undefined) { this.ptr = _emscripten_bind_JunctionRef_JunctionRef_2(router, position); getCache(JunctionRef)[this.ptr] = this;return }
this.ptr = _emscripten_bind_JunctionRef_JunctionRef_3(router, position, id);
getCache(JunctionRef)[this.ptr] = this;
};;
JunctionRef.prototype = Object.create(WrapperObject.prototype);
JunctionRef.prototype.constructor = JunctionRef;
JunctionRef.prototype.__class__ = JunctionRef;
JunctionRef.__cache__ = {};
Module['JunctionRef'] = JunctionRef;
/**
*
* @returns Point (Wrapper)
*/
JunctionRef.prototype['position'] = JunctionRef.prototype.position = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_JunctionRef_position_0(self), Point);
};;
JunctionRef.prototype['__destroy__'] = JunctionRef.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_JunctionRef___destroy___0(self);
};
// ShapeRef
/**
* @class
*/
function ShapeRef(router, poly, id) {
if (router && typeof router === 'object') router = router.ptr;
if (poly && typeof poly === 'object') poly = poly.ptr;
if (id && typeof id === 'object') id = id.ptr;
if (id === undefined) { this.ptr = _emscripten_bind_ShapeRef_ShapeRef_2(router, poly); getCache(ShapeRef)[this.ptr] = this;return }
this.ptr = _emscripten_bind_ShapeRef_ShapeRef_3(router, poly, id);
getCache(ShapeRef)[this.ptr] = this;
};;
ShapeRef.prototype = Object.create(WrapperObject.prototype);
ShapeRef.prototype.constructor = ShapeRef;
ShapeRef.prototype.__class__ = ShapeRef;
ShapeRef.__cache__ = {};
Module['ShapeRef'] = ShapeRef;
/**
*
* @returns Polygon (Wrapper)
*/
ShapeRef.prototype['polygon'] = ShapeRef.prototype.polygon = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_ShapeRef_polygon_0(self), Polygon);
};;
/**
*
* @returns Point (Wrapper)
*/
ShapeRef.prototype['position'] = ShapeRef.prototype.position = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_ShapeRef_position_0(self), Point);
};;
ShapeRef.prototype['__destroy__'] = ShapeRef.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_ShapeRef___destroy___0(self);
};
// HyperedgeNewAndDeletedObjectLists
/**
* @class
*/
function HyperedgeNewAndDeletedObjectLists() { throw "cannot construct a HyperedgeNewAndDeletedObjectLists, no constructor in IDL" }
HyperedgeNewAndDeletedObjectLists.prototype = Object.create(WrapperObject.prototype);
HyperedgeNewAndDeletedObjectLists.prototype.constructor = HyperedgeNewAndDeletedObjectLists;
HyperedgeNewAndDeletedObjectLists.prototype.__class__ = HyperedgeNewAndDeletedObjectLists;
HyperedgeNewAndDeletedObjectLists.__cache__ = {};
Module['HyperedgeNewAndDeletedObjectLists'] = HyperedgeNewAndDeletedObjectLists;
HyperedgeNewAndDeletedObjectLists.prototype['__destroy__'] = HyperedgeNewAndDeletedObjectLists.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_HyperedgeNewAndDeletedObjectLists___destroy___0(self);
};
// HyperedgeRerouter
/**
* @class
*/
function HyperedgeRerouter() {
this.ptr = _emscripten_bind_HyperedgeRerouter_HyperedgeRerouter_0();
getCache(HyperedgeRerouter)[this.ptr] = this;
};;
HyperedgeRerouter.prototype = Object.create(WrapperObject.prototype);
HyperedgeRerouter.prototype.constructor = HyperedgeRerouter;
HyperedgeRerouter.prototype.__class__ = HyperedgeRerouter;
HyperedgeRerouter.__cache__ = {};
Module['HyperedgeRerouter'] = HyperedgeRerouter;
/**
* @param {JunctionRef} junction
* @returns UnsignedLong
*/
HyperedgeRerouter.prototype['registerHyperedgeForRerouting'] = HyperedgeRerouter.prototype.registerHyperedgeForRerouting = function(junction) {
var self = this.ptr;
if (junction && typeof junction === 'object') junction = junction.ptr;
return _emscripten_bind_HyperedgeRerouter_registerHyperedgeForRerouting_1(self, junction);
};;
HyperedgeRerouter.prototype['__destroy__'] = HyperedgeRerouter.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_HyperedgeRerouter___destroy___0(self);
};
// VertInf
/**
* @class
*/
function VertInf() { throw "cannot construct a VertInf, no constructor in IDL" }
VertInf.prototype = Object.create(WrapperObject.prototype);
VertInf.prototype.constructor = VertInf;
VertInf.prototype.__class__ = VertInf;
VertInf.__cache__ = {};
Module['VertInf'] = VertInf;
VertInf.prototype['__destroy__'] = VertInf.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_VertInf___destroy___0(self);
};
// VertID
/**
* @class
*/
function VertID(id, n, p) {
if (id && typeof id === 'object') id = id.ptr;
if (n && typeof n === 'object') n = n.ptr;
if (p && typeof p === 'object') p = p.ptr;
if (id === undefined) { this.ptr = _emscripten_bind_VertID_VertID_0(); getCache(VertID)[this.ptr] = this;return }
if (n === undefined) { this.ptr = _emscripten_bind_VertID_VertID_1(id); getCache(VertID)[this.ptr] = this;return }
if (p === undefined) { this.ptr = _emscripten_bind_VertID_VertID_2(id, n); getCache(VertID)[this.ptr] = this;return }
this.ptr = _emscripten_bind_VertID_VertID_3(id, n, p);
getCache(VertID)[this.ptr] = this;
};;
VertID.prototype = Object.create(WrapperObject.prototype);
VertID.prototype.constructor = VertID;
VertID.prototype.__class__ = VertID;
VertID.__cache__ = {};
Module['VertID'] = VertID;
/* docss */
VertID.prototype['get_objID'] = VertID.prototype.get_objID = function() {
var self = this.ptr;
return _emscripten_bind_VertID_get_objID_0(self);
};
/* docsa */
VertID.prototype['set_objID'] = VertID.prototype.set_objID = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_VertID_set_objID_1(self, arg0);
};
Object.defineProperty(VertID.prototype, 'objID', { get: VertID.prototype.get_objID, set: VertID.prototype.set_objID });
/* docss */
VertID.prototype['get_vn'] = VertID.prototype.get_vn = function() {
var self = this.ptr;
return _emscripten_bind_VertID_get_vn_0(self);
};
/* docsa */
VertID.prototype['set_vn'] = VertID.prototype.set_vn = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_VertID_set_vn_1(self, arg0);
};
Object.defineProperty(VertID.prototype, 'vn', { get: VertID.prototype.get_vn, set: VertID.prototype.set_vn });
/* docss */
VertID.prototype['get_props'] = VertID.prototype.get_props = function() {
var self = this.ptr;
return _emscripten_bind_VertID_get_props_0(self);
};
/* docsa */
VertID.prototype['set_props'] = VertID.prototype.set_props = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_VertID_set_props_1(self, arg0);
};
Object.defineProperty(VertID.prototype, 'props', { get: VertID.prototype.get_props, set: VertID.prototype.set_props });
/* docss */
VertID.prototype['get_src'] = VertID.prototype.get_src = function() {
var self = this.ptr;
return _emscripten_bind_VertID_get_src_0(self);
};
Object.defineProperty(VertID.prototype, 'src', { get: VertID.prototype.get_src });
/* docss */
VertID.prototype['get_tar'] = VertID.prototype.get_tar = function() {
var self = this.ptr;
return _emscripten_bind_VertID_get_tar_0(self);
};
Object.defineProperty(VertID.prototype, 'tar', { get: VertID.prototype.get_tar });
/* docss */
VertID.prototype['get_PROP_ConnPoint'] = VertID.prototype.get_PROP_ConnPoint = function() {
var self = this.ptr;
return _emscripten_bind_VertID_get_PROP_ConnPoint_0(self);
};
Object.defineProperty(VertID.prototype, 'PROP_ConnPoint', { get: VertID.prototype.get_PROP_ConnPoint });
/* docss */
VertID.prototype['get_PROP_OrthShapeEdge'] = VertID.prototype.get_PROP_OrthShapeEdge = function() {
var self = this.ptr;
return _emscripten_bind_VertID_get_PROP_OrthShapeEdge_0(self);
};
Object.defineProperty(VertID.prototype, 'PROP_OrthShapeEdge', { get: VertID.prototype.get_PROP_OrthShapeEdge });
/* docss */
VertID.prototype['get_PROP_ConnectionPin'] = VertID.prototype.get_PROP_ConnectionPin = function() {
var self = this.ptr;
return _emscripten_bind_VertID_get_PROP_ConnectionPin_0(self);
};
Object.defineProperty(VertID.prototype, 'PROP_ConnectionPin', { get: VertID.prototype.get_PROP_ConnectionPin });
/* docss */
VertID.prototype['get_PROP_ConnCheckpoint'] = VertID.prototype.get_PROP_ConnCheckpoint = function() {
var self = this.ptr;
return _emscripten_bind_VertID_get_PROP_ConnCheckpoint_0(self);
};
Object.defineProperty(VertID.prototype, 'PROP_ConnCheckpoint', { get: VertID.prototype.get_PROP_ConnCheckpoint });
/* docss */
VertID.prototype['get_PROP_DummyPinHelper'] = VertID.prototype.get_PROP_DummyPinHelper = function() {
var self = this.ptr;
return _emscripten_bind_VertID_get_PROP_DummyPinHelper_0(self);
};
Object.defineProperty(VertID.prototype, 'PROP_DummyPinHelper', { get: VertID.prototype.get_PROP_DummyPinHelper });
VertID.prototype['__destroy__'] = VertID.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_VertID___destroy___0(self);
};
// MinimumTerminalSpanningTree
/**
* @class
*/
function MinimumTerminalSpanningTree() { throw "cannot construct a MinimumTerminalSpanningTree, no constructor in IDL" }
MinimumTerminalSpanningTree.prototype = Object.create(WrapperObject.prototype);
MinimumTerminalSpanningTree.prototype.constructor = MinimumTerminalSpanningTree;
MinimumTerminalSpanningTree.prototype.__class__ = MinimumTerminalSpanningTree;
MinimumTerminalSpanningTree.__cache__ = {};
Module['MinimumTerminalSpanningTree'] = MinimumTerminalSpanningTree;
MinimumTerminalSpanningTree.prototype['__destroy__'] = MinimumTerminalSpanningTree.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_MinimumTerminalSpanningTree___destroy___0(self);
};
// Checkpoint
/**
* @class
*/
function Checkpoint(p) {
if (p && typeof p === 'object') p = p.ptr;
this.ptr = _emscripten_bind_Checkpoint_Checkpoint_1(p);
getCache(Checkpoint)[this.ptr] = this;
};;
Checkpoint.prototype = Object.create(WrapperObject.prototype);
Checkpoint.prototype.constructor = Checkpoint;
Checkpoint.prototype.__class__ = Checkpoint;
Checkpoint.__cache__ = {};
Module['Checkpoint'] = Checkpoint;
Checkpoint.prototype['__destroy__'] = Checkpoint.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_Checkpoint___destroy___0(self);
};
// ConnRef
/**
* @class
*/
function ConnRef(router, src, dst, id) {
if (router && typeof router === 'object') router = router.ptr;
if (src && typeof src === 'object') src = src.ptr;
if (dst && typeof dst === 'object') dst = dst.ptr;
if (id && typeof id === 'object') id = id.ptr;
if (id === undefined) { this.ptr = _emscripten_bind_ConnRef_ConnRef_3(router, src, dst); getCache(ConnRef)[this.ptr] = this;return }
this.ptr = _emscripten_bind_ConnRef_ConnRef_4(router, src, dst, id);
getCache(ConnRef)[this.ptr] = this;
};;
ConnRef.prototype = Object.create(WrapperObject.prototype);
ConnRef.prototype.constructor = ConnRef;
ConnRef.prototype.__class__ = ConnRef;
ConnRef.__cache__ = {};
Module['ConnRef'] = ConnRef;
/**
*
* @returns UnsignedLong
*/
ConnRef.prototype['id'] = ConnRef.prototype.id = function() {
var self = this.ptr;
return _emscripten_bind_ConnRef_id_0(self);
};;
/**
* @param {ConnRefCallback} cb
* @param {VoidPtr} ptr
* @returns Void
*/
ConnRef.prototype['setCallback'] = ConnRef.prototype.setCallback = function(cb, ptr) {
var self = this.ptr;
assert(cb instanceof Function, 'Expecting function');
var callback_val_0 = addFunction(cb, 'vi');
if (ptr && typeof ptr === 'object') ptr = ptr.ptr;
_emscripten_bind_ConnRef_setCallback_2(self, callback_val_0, ptr);
};;
/**
* @param {ConnEnd} dstPoint
* @returns Void
*/
ConnRef.prototype['setDestEndpoint'] = ConnRef.prototype.setDestEndpoint = function(dstPoint) {
var self = this.ptr;
if (dstPoint && typeof dstPoint === 'object') dstPoint = dstPoint.ptr;
_emscripten_bind_ConnRef_setDestEndpoint_1(self, dstPoint);
};;
/**
*
* @returns Polygon (Wrapper)
*/
ConnRef.prototype['displayRoute'] = ConnRef.prototype.displayRoute = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_ConnRef_displayRoute_0(self), Polygon);
};;
ConnRef.prototype['__destroy__'] = ConnRef.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_ConnRef___destroy___0(self);
};
// EdgeInf
/**
* @class
*/
function EdgeInf(v1, v2, orthogonal) {
if (v1 && typeof v1 === 'object') v1 = v1.ptr;
if (v2 && typeof v2 === 'object') v2 = v2.ptr;
if (orthogonal && typeof orthogonal === 'object') orthogonal = orthogonal.ptr;
if (orthogonal === undefined) { this.ptr = _emscripten_bind_EdgeInf_EdgeInf_2(v1, v2); getCache(EdgeInf)[this.ptr] = this;return }
this.ptr = _emscripten_bind_EdgeInf_EdgeInf_3(v1, v2, orthogonal);
getCache(EdgeInf)[this.ptr] = this;
};;
EdgeInf.prototype = Object.create(WrapperObject.prototype);
EdgeInf.prototype.constructor = EdgeInf;
EdgeInf.prototype.__class__ = EdgeInf;
EdgeInf.__cache__ = {};
Module['EdgeInf'] = EdgeInf;
EdgeInf.prototype['__destroy__'] = EdgeInf.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_EdgeInf___destroy___0(self);
};
// LineRep
/**
* @class
*/
function LineRep() { throw "cannot construct a LineRep, no constructor in IDL" }
LineRep.prototype = Object.create(WrapperObject.prototype);
LineRep.prototype.constructor = LineRep;
LineRep.prototype.__class__ = LineRep;
LineRep.__cache__ = {};
Module['LineRep'] = LineRep;
/* docss */
LineRep.prototype['get_begin'] = LineRep.prototype.get_begin = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_LineRep_get_begin_0(self), Point);
};
/* docsa */
LineRep.prototype['set_begin'] = LineRep.prototype.set_begin = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_LineRep_set_begin_1(self, arg0);
};
Object.defineProperty(LineRep.prototype, 'begin', { get: LineRep.prototype.get_begin, set: LineRep.prototype.set_begin });
/* docss */
LineRep.prototype['get_end'] = LineRep.prototype.get_end = function() {
var self = this.ptr;
return wrapPointer(_emscripten_bind_LineRep_get_end_0(self), Point);
};
/* docsa */
LineRep.prototype['set_end'] = LineRep.prototype.set_end = function(arg0) {
var self = this.ptr;
if (arg0 && typeof arg0 === 'object') arg0 = arg0.ptr;
_emscripten_bind_LineRep_set_end_1(self, arg0);
};
Object.defineProperty(LineRep.prototype, 'end', { get: LineRep.prototype.get_end, set: LineRep.prototype.set_end });
LineRep.prototype['__destroy__'] = LineRep.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_LineRep___destroy___0(self);
};
// Router
/**
* @class
*/
function Router(flags) {
if (flags && typeof flags === 'object') flags = flags.ptr;
this.ptr = _emscripten_bind_Router_Router_1(flags);
getCache(Router)[this.ptr] = this;
};;
Router.prototype = Object.create(WrapperObject.prototype);
Router.prototype.constructor = Router;
Router.prototype.__class__ = Router;
Router.__cache__ = {};
Module['Router'] = Router;
/**
*
* @returns Boolean
*/
Router.prototype['processTransaction'] = Router.prototype.processTransaction = function() {
var self = this.ptr;
return !!(_emscripten_bind_Router_processTransaction_0(self));
};;
/**
*
* @returns Void
*/
Router.prototype['printInfo'] = Router.prototype.printInfo = function() {
var self = this.ptr;
_emscripten_bind_Router_printInfo_0(self);
};;
/**
* @param {ShapeRef} shape
* @param {Double} xDiff
* @param {Double} yDiff
* @returns Void
*/
Router.prototype['moveShape'] = Router.prototype.moveShape = function(shape, xDiff, yDiff) {
var self = this.ptr;
if (shape && typeof shape === 'object') shape = shape.ptr;
if (xDiff && typeof xDiff === 'object') xDiff = xDiff.ptr;
if (yDiff && typeof yDiff === 'object') yDiff = yDiff.ptr;
_emscripten_bind_Router_moveShape_3(self, shape, xDiff, yDiff);
};;
Router.prototype['__destroy__'] = Router.prototype.__destroy__ = function() {
var self = this.ptr;
_emscripten_bind_Router___destroy___0(self);
};
(function() {
function setupEnums() {
// Avoid_ConnDirFlag
Module['ConnDirNone'] = _emscripten_enum_Avoid_ConnDirFlag_ConnDirNone();
Module['ConnDirUp'] = _emscripten_enum_Avoid_ConnDirFlag_ConnDirUp();
Module['ConnDirDown'] = _emscripten_enum_Avoid_ConnDirFlag_ConnDirDown();
Module['ConnDirLeft'] = _emscripten_enum_Avoid_ConnDirFlag_ConnDirLeft();
Module['ConnDirRight'] = _emscripten_enum_Avoid_ConnDirFlag_ConnDirRight();
Module['ConnDirAll'] = _emscripten_enum_Avoid_ConnDirFlag_ConnDirAll();
// Avoid_ConnEndType
Module['ConnEndPoint'] = _emscripten_enum_Avoid_ConnEndType_ConnEndPoint();
Module['ConnEndShapePin'] = _emscripten_enum_Avoid_ConnEndType_ConnEndShapePin();
Module['ConnEndJunction'] = _emscripten_enum_Avoid_ConnEndType_ConnEndJunction();
Module['ConnEndEmpty'] = _emscripten_enum_Avoid_ConnEndType_ConnEndEmpty();
// Avoid_ActionType
Module['ShapeMove'] = _emscripten_enum_Avoid_ActionType_ShapeMove();
Module['ShapeAdd'] = _emscripten_enum_Avoid_ActionType_ShapeAdd();
Module['ShapeRemove'] = _emscripten_enum_Avoid_ActionType_ShapeRemove();
Module['JunctionMove'] = _emscripten_enum_Avoid_ActionType_JunctionMove();
Module['JunctionAdd'] = _emscripten_enum_Avoid_ActionType_JunctionAdd();
Module['JunctionRemove'] = _emscripten_enum_Avoid_ActionType_JunctionRemove();
Module['ConnChange'] = _emscripten_enum_Avoid_ActionType_ConnChange();
Module['ConnectionPinChange'] = _emscripten_enum_Avoid_ActionType_ConnectionPinChange();
// Avoid_ShapeTransformationType
Module['TransformationType_CW90'] = _emscripten_enum_Avoid_ShapeTransformationType_TransformationType_CW90();
Module['TransformationType_CW180'] = _emscripten_enum_Avoid_ShapeTransformationType_TransformationType_CW180();
Module['TransformationType_CW270'] = _emscripten_enum_Avoid_ShapeTransformationType_TransformationType_CW270();
Module['TransformationType_FlipX'] = _emscripten_enum_Avoid_ShapeTransformationType_TransformationType_FlipX();
Module['TransformationType_FlipY'] = _emscripten_enum_Avoid_ShapeTransformationType_TransformationType_FlipY();
// Avoid_ConnType
Module['ConnType_None'] = _emscripten_enum_Avoid_ConnType_ConnType_None();
Module['ConnType_PolyLine'] = _emscripten_enum_Avoid_ConnType_ConnType_PolyLine();
Module['ConnType_Orthogonal'] = _emscripten_enum_Avoid_ConnType_ConnType_Orthogonal();
// Avoid_RouterFlag
Module['PolyLineRouting'] = _emscripten_enum_Avoid_RouterFlag_PolyLineRouting();
Module['OrthogonalRouting'] = _emscripten_enum_Avoid_RouterFlag_OrthogonalRouting();
}
if (runtimeInitialized) setupEnums();
else addOnPreMain(setupEnums);
})();