void
test_nodestore ()
{
gint i;
NodeStore *store;
Part *part;
Wire *wire;
Node *node;
Coords p_pos = {111.,22.};
Coords n_pos = {111.,33.};
Coords w_pos = {111.,7.};
Coords w_len = {0.,88.};
store = node_store_new ();
part = part_new ();
wire = wire_new ();
// add one Pin with a offset that is on the wire when rotation N*Pi times
Pin *pin = g_new (Pin, 1);
pin->offset.x = n_pos.x - p_pos.x;
pin->offset.y = n_pos.y - p_pos.y;
GSList *list = NULL;
list = g_slist_prepend (list, pin);
part_set_pins (part, list);
g_slist_free (list);
item_data_set_pos (ITEM_DATA (part), &p_pos);
item_data_set_pos (ITEM_DATA (wire), &w_pos);
wire_set_length (wire, &w_len);
node_store_add_part (store, part);
node_store_add_wire (store, wire);
{
for (i=0; i<11; i++)
item_data_rotate (ITEM_DATA (part), 90, NULL);
item_data_set_pos (ITEM_DATA (part), &w_len);
for (i=0; i<4; i++)
item_data_rotate (ITEM_DATA (part), 90, NULL);
item_data_set_pos (ITEM_DATA (part), &n_pos);
for (i=0; i<7; i++)
item_data_rotate (ITEM_DATA (part), -90, NULL);
item_data_set_pos (ITEM_DATA (part), &p_pos);
}
g_assert (node_store_is_wire_at_pos (store, n_pos));
g_assert (node_store_is_pin_at_pos (store, n_pos));
node = node_store_get_node (store, n_pos);
g_assert (!node_is_empty (node));
g_assert (node_needs_dot (node));
node_store_remove_part (store, part);
node_store_remove_wire (store, wire);
g_object_unref (store);
}
static GSList *
wire_intersect_parts (NodeStore *store, Wire *wire)
{
GList *list;
GSList *ip_list;
Node *node;
SheetPos lookup_pos;
SheetPos part_pos, wire_pos, wire_length;
Part *part;
double x, y, wire_x1, wire_y1, wire_x2, wire_y2;
int i, num_pins;
g_return_val_if_fail (store != NULL, FALSE);
g_return_val_if_fail (IS_NODE_STORE (store), FALSE);
g_return_val_if_fail (wire != NULL, FALSE);
g_return_val_if_fail (IS_WIRE (wire), FALSE);
ip_list = NULL;
wire_get_pos_and_length (wire, &wire_pos, &wire_length);
wire_x1 = wire_pos.x;
wire_x2 = wire_pos.x + wire_length.x;
wire_y1 = wire_pos.y;
wire_y2 = wire_pos.y + wire_length.y;
// Go through all the parts and see which of their
// pins that intersect the wire.
for (list = store->parts; list; list = list->next) {
part = list->data;
num_pins = part_get_num_pins (part);
item_data_get_pos (ITEM_DATA (part), &part_pos);
for (i = 0; i < num_pins; i++) {
Pin *pins;
pins = part_get_pins (part);
x = part_pos.x + pins[i].offset.x;
y = part_pos.y + pins[i].offset.y;
lookup_pos.x = x;
lookup_pos.y = y;
// If there is a wire at this pin's position,
// add it to the return list.
if (is_wire_at_pos (wire_x1, wire_y1, wire_x2, wire_y2, lookup_pos)) {
node = node_store_get_node (store, lookup_pos);
if (node != NULL)
ip_list = g_slist_prepend (ip_list, node);
}
}
}
g_list_free_full (list, g_object_unref);
return ip_list;
}
/**
* add/register the wire to the nodestore
*
* @param store
* @param wire
* @returns TRUE if the wire was added or merged, else FALSE
*/
gboolean node_store_add_wire (NodeStore *store, Wire *wire)
{
GList *list;
Node *node;
int i = 0;
g_return_val_if_fail (store, FALSE);
g_return_val_if_fail (IS_NODE_STORE (store), FALSE);
g_return_val_if_fail (wire, FALSE);
g_return_val_if_fail (IS_WIRE (wire), FALSE);
// Check for intersection with other wires.
for (list = store->wires; list; list = list->next) {
g_assert (list->data != NULL);
g_assert (IS_WIRE (list->data));
Coords where = {-77.77, -77.77};
Wire *other = list->data;
if (do_wires_intersect (wire, other, &where)) {
if (is_t_crossing (wire, other, &where) || is_t_crossing (other, wire, &where)) {
node = node_store_get_or_create_node (store, where);
node_add_wire (node, wire);
node_add_wire (node, other);
wire_add_node (wire, node);
wire_add_node (other, node);
NG_DEBUG ("Add wire %p to wire %p @ %lf,%lf.\n", wire, other, where.x, where.y);
} else {
// magic node removal if a x crossing is overlapped with another wire
node = node_store_get_node (store, where);
NG_DEBUG ("Nuke that node [ %p ] at coords inbetween", node);
if (node) {
Coords c[4];
wire_get_start_and_end_pos (other, c + 0, c + 1);
wire_get_start_and_end_pos (wire, c + 2, c + 3);
if (!coords_equal (&where, c + 0) && !coords_equal (&where, c + 1) &&
!coords_equal (&where, c + 2) && !coords_equal (&where, c + 3)) {
wire_remove_node (wire, node);
wire_remove_node (other, node);
node_remove_wire (node, wire);
node_remove_wire (node, other);
}
}
}
}
}
// Check for overlapping with other wires.
do {
for (list = store->wires; list; list = list->next) {
g_assert (list->data != NULL);
g_assert (IS_WIRE (list->data));
Wire *other = list->data;
Coords so, eo;
const gboolean overlap = do_wires_overlap (wire, other, &so, &eo);
NG_DEBUG ("overlap [ %p] and [ %p ] -- %s", wire, other,
overlap == TRUE ? "YES" : "NO");
if (overlap) {
Node *sn = node_store_get_node (store, eo);
Node *en = node_store_get_node (store, so);
#if 1
wire = vulcanize_wire (store, wire, other, &so, &eo);
node_store_remove_wire (store, g_object_ref (other)); // equiv
// wire_unregister
// XXX FIXME this
// modifies the list
// we iterate over!
// delay this until idle, so all handlers like adding view
// representation are completed so existing wire-items can be deleted
// properly
// this is not fancy nor nice but seems to work fairly nicly
g_idle_add (delayed_wire_delete, other);
break;
NG_DEBUG ("overlapping of %p with %p ", wire, other);
#else
if (!sn && !en) {
wire = vulcanize_wire (store, wire, other, &so, &eo);
} else if (!sn) {
NG_DEBUG ("do_something(TM) : %p sn==NULL ", other);
} else if (!en) {
NG_DEBUG ("do_something(TM) : %p en==NULL ", other);
} else {
NG_DEBUG ("do_something(TM) : %p else ", other);
}
#endif
} else {
NG_DEBUG ("not of %p with %p ", wire, other);
}
}
} while (list);
// Check for intersection with parts (pins).
for (list = store->parts; list; list = list->next) {
g_assert (list->data != NULL);
g_assert (IS_PART (list->data));
Coords part_pos;
gint num_pins = -1;
Part *part = list->data;
num_pins = part_get_num_pins (part);
item_data_get_pos (ITEM_DATA (part), &part_pos);
// Go through all the parts and see which of their
// pins that intersect the wire.
for (i = 0; i < num_pins; i++) {
Pin *pins;
Coords lookup_pos;
pins = part_get_pins (part);
lookup_pos.x = part_pos.x + pins[i].offset.x;
lookup_pos.y = part_pos.y + pins[i].offset.y;
// If there is a wire at this pin's position,
// add it to the return list.
if (is_point_on_wire (wire, &lookup_pos)) {
Node *node;
node = node_store_get_node (store, lookup_pos);
if (node != NULL) {
// Add the wire to the node (pin) that it intersected.
node_add_wire (node, wire);
wire_add_node (wire, node);
NG_DEBUG ("Add wire %p to pin (node) %p.\n", wire, node);
} else {
g_warning ("Bug: Found no node at pin at (%g %g).\n", lookup_pos.x,
lookup_pos.y);
}
}
}
}
g_object_set (G_OBJECT (wire), "store", store, NULL);
store->wires = g_list_prepend (store->wires, wire);
store->items = g_list_prepend (store->items, wire);
return TRUE;
}
