gint node_store_count_items (NodeStore *store, NodeRect *rect) { GList *list; SheetPos p1, p2; ItemData *data; gint n; g_return_val_if_fail (store != NULL, 0); g_return_val_if_fail (IS_NODE_STORE (store), 0); if (rect == NULL) return g_list_length (store->items); for (list = store->items, n = 0; list; list = list->next) { data = ITEM_DATA (list->data); item_data_get_absolute_bbox (data, &p1, &p2); if (p1.x <= rect->x1 && p1.y <= rect->y1 && p2.x >= rect->x0 && p2.y >= rect->y0) { n++; } } g_list_free_full (list, g_object_unref); return n; }
void node_store_get_bounds (NodeStore *store, NodeRect *rect) { GList *list; SheetPos p1, p2; g_return_if_fail (store != NULL); g_return_if_fail (IS_NODE_STORE (store)); g_return_if_fail (rect != NULL); rect->x0 = G_MAXDOUBLE; rect->y0 = G_MAXDOUBLE; rect->x1 = -G_MAXDOUBLE; rect->y1 = -G_MAXDOUBLE; for (list = store->items; list; list = list->next) { item_data_get_absolute_bbox (ITEM_DATA (list->data), &p1, &p2); rect->x0 = MIN (rect->x0, p1.x); rect->y0 = MIN (rect->y0, p1.y); rect->x1 = MAX (rect->x1, p2.x); rect->y1 = MAX (rect->y1, p2.y); } g_list_free_full (list, g_object_unref); }
Node * node_store_get_or_create_node (NodeStore *self, SheetPos pos) { Node *node; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (IS_NODE_STORE (self), NULL); node = g_hash_table_lookup (self->nodes, &pos); if (!node) { // Create a node at (x, y) and return it. node = node_new (pos); g_signal_connect_object (G_OBJECT (node), "node_dot_added", G_CALLBACK (node_dot_added_callback), G_OBJECT (self), 0); g_signal_connect_object (G_OBJECT (node), "node_dot_removed", G_CALLBACK (node_dot_removed_callback), G_OBJECT (self), 0); g_hash_table_insert (self->nodes, &node->key, node); } // If there was a previously stored node here, just // return that node. return node; }
/** * Call GHFunc for each node in the nodestore */ void node_store_node_foreach (NodeStore *store, GHFunc *func, gpointer user_data) { g_return_if_fail (store != NULL); g_return_if_fail (IS_NODE_STORE (store)); g_hash_table_foreach (store->nodes, (gpointer)func, user_data); }
/** * [transfer-none] */ GList *node_store_get_items (NodeStore *store) { g_return_val_if_fail (store != NULL, NULL); g_return_val_if_fail (IS_NODE_STORE (store), NULL); return store->items; }
int node_store_is_wire_at_pos (NodeStore *store, SheetPos pos) { GList *list; Wire *wire; SheetPos wire_pos, wire_length; double x1, y1, x2, y2; g_return_val_if_fail (store != NULL, FALSE); g_return_val_if_fail (IS_NODE_STORE (store), FALSE); for (list = store->wires; list; list = list->next) { wire = list->data; wire_get_pos_and_length (wire, &wire_pos, &wire_length); x1 = wire_pos.x; y1 = wire_pos.y; x2 = x1 + wire_length.x; y2 = y1 + wire_length.y; if (is_wire_at_pos (x1, y1, x2, y2, pos)) return TRUE; } g_list_free_full (list, g_object_unref); return FALSE; }
static void node_dot_removed_callback (Node *node, Coords *pos, NodeStore *store) { g_return_if_fail (store); g_return_if_fail (IS_NODE_STORE (store)); g_signal_emit_by_name (G_OBJECT (store), "node_dot_removed", pos); }
static void node_dot_added_callback (Node *node, SheetPos *pos, NodeStore *store) { g_return_if_fail (store != NULL); g_return_if_fail (IS_NODE_STORE (store)); g_signal_emit_by_name (G_OBJECT (store), "node_dot_added", pos); }
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; }
int node_store_add_part (NodeStore *self, Part *part) { GSList *wire_list, *list; Node *node; SheetPos lookup_key; SheetPos part_pos; gdouble x, y; int i, num_pins; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (IS_NODE_STORE (self), FALSE); g_return_val_if_fail (part != NULL, FALSE); g_return_val_if_fail (IS_PART (part), FALSE); 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; //Use the position of the pin as hash key. lookup_key.x = x; lookup_key.y = y; // Retrieve a node for this position. node = node_store_get_or_create_node (self, lookup_key); // Add all the wires that intersect this pin to the node store. wire_list = wires_at_pos (self, lookup_key); for (list = wire_list; list; list = list->next) { Wire *wire = list->data; NG_DEBUG ("Add pin to wire.\n"); node_add_wire (node, wire); wire_add_node (wire, node); } g_slist_free (wire_list); node_add_pin (node, &pins[i]); } g_object_set (G_OBJECT (part), "store", self, NULL); self->parts = g_list_prepend (self->parts, part); self->items = g_list_prepend (self->items, part); return TRUE; }
/** * the caller has to free the list himself, but not the actual data items! */ GList *node_store_get_nodes (NodeStore *store) { GList *result; g_return_val_if_fail (store != NULL, NULL); g_return_val_if_fail (IS_NODE_STORE (store), NULL); result = NULL; g_hash_table_foreach (store->nodes, (GHFunc)add_node, &result); return result; }
int node_store_remove_part (NodeStore *self, Part *part) { Node *node; SheetPos lookup_key; SheetPos pos; gdouble x, y; int i, num_pins; Pin *pins; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (IS_NODE_STORE (self), FALSE); g_return_val_if_fail (part != NULL, FALSE); g_return_val_if_fail (IS_PART (part), FALSE); self->parts = g_list_remove (self->parts, part); self->items = g_list_remove (self->items, part); num_pins = part_get_num_pins (part); item_data_get_pos (ITEM_DATA (part), &pos); pins = part_get_pins (part); for (i = 0; i < num_pins; i++) { x = pos.x + pins[i].offset.x; y = pos.y + pins[i].offset.y; // Use the position of the pin as lookup key. lookup_key.x = x; lookup_key.y = y; node = g_hash_table_lookup (self->nodes, &lookup_key); if (node) { if (!node_remove_pin (node, &pins[i])) { g_warning ("Couldn't remove pin."); return FALSE; } // If the node is empty after removing the pin, // remove the node as well. if (node_is_empty (node)) { g_hash_table_remove (self->nodes, &lookup_key); g_object_unref (G_OBJECT (node)); } } else { return FALSE; } } return TRUE; }
/** * check if there is at least one wire at the specified position * * @param store which NodeStore to check * @param pos the position * @returns TRUE or FALSE */ gboolean node_store_is_wire_at_pos (NodeStore *store, Coords pos) { GList *iter; g_return_val_if_fail (store, FALSE); g_return_val_if_fail (IS_NODE_STORE (store), FALSE); for (iter = store->wires; iter; iter = iter->next) { Wire *wire = iter->data; if (is_point_on_wire (wire, &pos)) return TRUE; } return FALSE; }
/** * register a part to the nodestore */ gboolean node_store_add_part (NodeStore *self, Part *part) { NG_DEBUG ("-0-"); g_return_val_if_fail (self, FALSE); g_return_val_if_fail (IS_NODE_STORE (self), FALSE); g_return_val_if_fail (part, FALSE); g_return_val_if_fail (IS_PART (part), FALSE); GSList *iter, *copy; Node *node; Coords pin_pos; Coords part_pos; int i, num_pins; Pin *pins; num_pins = part_get_num_pins (part); pins = part_get_pins (part); item_data_get_pos (ITEM_DATA (part), &part_pos); for (i = 0; i < num_pins; i++) { // Use the position of the pin as hash key. pin_pos.x = part_pos.x + pins[i].offset.x; pin_pos.y = part_pos.y + pins[i].offset.y; // Retrieve a node for this position. node = node_store_get_or_create_node (self, pin_pos); // Add all the wires that intersect this pin to the node store. copy = get_wires_at_pos (self, pin_pos); for (iter = copy; iter; iter = iter->next) { Wire *wire = copy->data; node_add_wire (node, wire); wire_add_node (wire, node); } g_slist_free (copy); node_add_pin (node, &pins[i]); } g_object_set (G_OBJECT (part), "store", self, NULL); self->parts = g_list_prepend (self->parts, part); self->items = g_list_prepend (self->items, part); return TRUE; }
void node_store_print_items (NodeStore *store, cairo_t *cr, SchematicPrintContext *ctx) { GList *list; ItemData *data; g_return_if_fail (store != NULL); g_return_if_fail (IS_NODE_STORE (store)); cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); for (list = store->items; list; list = list->next) { data = ITEM_DATA (list->data); item_data_print (data, cr, ctx); } g_hash_table_foreach (store->nodes, (GHFunc)draw_dot, cr); }
/** * lookup node at specified position * * @param store which store to check * @param pos where to check in that store * @returns the node pointer if there is a node, else NULL */ Node *node_store_get_node (NodeStore *store, Coords pos) { Node *node; g_return_val_if_fail (store != NULL, NULL); g_return_val_if_fail (IS_NODE_STORE (store), NULL); node = g_hash_table_lookup (store->nodes, &pos); if (!node) { NG_DEBUG ("No node at (%g, %g)", pos.x, pos.y); } else { NG_DEBUG ("Found node at (%g, %g)", pos.x, pos.y); } return node; }
int node_store_remove_wire (NodeStore *store, Wire *wire) { GSList *list; SheetPos lookup_key, pos, length; 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); if (item_data_get_store (ITEM_DATA (wire)) == NULL) { g_warning ("Trying to remove non-stored wire."); return FALSE; } wire_get_pos_and_length (wire, &pos, &length); store->wires = g_list_remove (store->wires, wire); store->items = g_list_remove (store->items, wire); // If the nodes that this wire passes through will be // empty when the wire is removed, remove the node as well. // We must work on a copy of the nodes list, since it // changes as we remove nodes. list = g_slist_copy (wire_get_nodes (wire)); for (; list; list = list->next) { Node *node = list->data; lookup_key = node->key; node_remove_wire (node, wire); wire_remove_node (wire, node); if (node_is_empty (node)) g_hash_table_remove (store->nodes, &lookup_key); } g_slist_free (list); return TRUE; }
/** * remove/unregister a part from the nodestore * this does _not_ free the part! */ gboolean node_store_remove_part (NodeStore *self, Part *part) { Node *node; Coords pin_pos; Coords part_pos; int i, num_pins; Pin *pins; g_return_val_if_fail (self, FALSE); g_return_val_if_fail (IS_NODE_STORE (self), FALSE); g_return_val_if_fail (part, FALSE); g_return_val_if_fail (IS_PART (part), FALSE); self->parts = g_list_remove (self->parts, part); self->items = g_list_remove (self->items, part); num_pins = part_get_num_pins (part); item_data_get_pos (ITEM_DATA (part), &part_pos); pins = part_get_pins (part); for (i = 0; i < num_pins; i++) { pin_pos.x = part_pos.x + pins[i].offset.x; pin_pos.y = part_pos.y + pins[i].offset.y; node = g_hash_table_lookup (self->nodes, &pin_pos); if (node) { if (!node_remove_pin (node, &pins[i])) { g_warning ("Could not remove pin[%i] from node %p.", i, node); return FALSE; } // If the node is empty after removing the pin, // remove the node as well. if (node_is_empty (node)) { g_hash_table_remove (self->nodes, &pin_pos); g_object_unref (G_OBJECT (node)); } } else { return FALSE; } } return TRUE; }
/** * removes/unregisters a wire from the nodestore * this does _not_ free the wire itself! */ gboolean node_store_remove_wire (NodeStore *store, Wire *wire) { GSList *copy, *iter; Coords lookup_key; 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); if (item_data_get_store (ITEM_DATA (wire)) == NULL) { g_warning ("Trying to remove not-stored wire %p.", wire); return FALSE; } store->wires = g_list_remove (store->wires, wire); store->items = g_list_remove (store->items, wire); // If the nodes that this wire passes through will be // empty when the wire is removed, remove the node as well. // FIXME if done properly, a list copy is _not_ necessary copy = g_slist_copy (wire_get_nodes (wire)); for (iter = copy; iter; iter = iter->next) { Node *node = iter->data; lookup_key = node->key; node_remove_wire (node, wire); wire_remove_node (wire, node); if (node_is_empty (node)) g_hash_table_remove (store->nodes, &lookup_key); } g_slist_free (copy); return TRUE; }
static GSList * wires_intersect (NodeStore *store, double x1, double y1, double x2, double y2) { GList *list; GSList *ip_list; Wire *wire; SheetPos pos, wire_pos, wire_length; double wire_x1, wire_y1, wire_x2, wire_y2; g_return_val_if_fail (store != NULL, FALSE); g_return_val_if_fail (IS_NODE_STORE (store), FALSE); // Search through all the wires. Is there a better way? ip_list = NULL; for (list = store->wires; list; list = list->next) { wire = list->data; wire_get_pos_and_length (wire, &wire_pos, &wire_length); wire_x1 = wire_pos.x; wire_y1 = wire_pos.y; wire_x2 = wire_x1 + wire_length.x; wire_y2 = wire_y1 + wire_length.y; if (do_wires_intersect (x1, y1, x2, y2, wire_x1, wire_y1, wire_x2, wire_y2, &pos)) { IntersectionPoint *ip; ip = g_new0 (IntersectionPoint, 1); ip->wire = wire; ip->pos = pos; ip_list = g_slist_prepend (ip_list, ip); } } g_list_free_full (list, g_object_unref); return ip_list; }
/** * lookup if a node at @pos exists, if so return it, otherwise * create one, add it to the nodestore and return it */ Node *node_store_get_or_create_node (NodeStore *self, Coords pos) { Node *node; g_return_val_if_fail (self, NULL); g_return_val_if_fail (IS_NODE_STORE (self), NULL); node = g_hash_table_lookup (self->nodes, &pos); if (!node) { // Create a node at (x, y) and return it. node = node_new (pos); g_signal_connect_object (G_OBJECT (node), "node_dot_added", G_CALLBACK (node_dot_added_callback), G_OBJECT (self), 0); g_signal_connect_object (G_OBJECT (node), "node_dot_removed", G_CALLBACK (node_dot_removed_callback), G_OBJECT (self), 0); g_hash_table_insert (self->nodes, &node->key, node); } return node; }
/** * 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; }
int node_store_add_wire (NodeStore *store, Wire *wire) { gdouble x1, y1, x2, y2; GSList *ip_list, *list; IntersectionPoint *ipoint; Node *node; SheetPos pos, length; 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); wire_get_pos_and_length (wire, &pos, &length); x1 = pos.x; y1 = pos.y; x2 = x1 + length.x; y2 = y1 + length.y; // Check for intersection with other wires. ip_list = wires_intersect (store, x1, y1, x2, y2); for (list = ip_list; list; list = list->next) { ipoint = list->data; if (IS_EQ (x1, x2) && ((ipoint->pos.y == y1) || (ipoint->pos.y == y2))) { SheetPos w_pos, w_length; gboolean can_join; GSList *nodes; wire_get_pos_and_length (ipoint->wire, &w_pos, &w_length); gdouble _x1, _x2, _y1, _y2; _x1 = w_pos.x; _y1 = w_pos.y; _x2 = _x1 + w_length.x; _y2 = _y1 + w_length.y; can_join = TRUE; nodes = wire_get_nodes (wire); for (; nodes; nodes = nodes->next) { SheetPos p1; Node *node = (Node *)nodes->data; p1.x = _x1; p1.y = _y1; if ((fabs (node->key.x - p1.x) < 1e-3) && (fabs (node->key.y - p1.y) < 1e-3)){ can_join = FALSE; break; } p1.x = _x2; p1.y = _y2; if ((fabs (node->key.x - p1.x) < 1e-3) && (fabs (node->key.y - p1.y) < 1e-3)){ can_join = FALSE; break; } } if (IS_EQ(_x1, _x2) && can_join) { if (w_pos.x < pos.x) pos.x = w_pos.x; if (w_pos.y < pos.y) pos.y = w_pos.y; length.x += w_length.x; length.y += w_length.y; // Update the new size and pos of the wire item_data_unregister (ITEM_DATA (ipoint->wire)); wire_set_length (ipoint->wire, &length); item_data_set_pos (ITEM_DATA (ipoint->wire), &pos); wire_update_bbox (ipoint->wire); item_data_register (ITEM_DATA (ipoint->wire)); // Done!, return -1 so wire is deleted return -1; } } else if (IS_EQ (y1, y2) && ((ipoint->pos.x == x1) || (ipoint->pos.x == x2))) { SheetPos w_pos, w_length; gboolean can_join; GSList *nodes; wire_get_pos_and_length (ipoint->wire, &w_pos, &w_length); gdouble _x1, _x2, _y1, _y2; _x1 = w_pos.x; _y1 = w_pos.y; _x2 = _x1 + w_length.x; _y2 = _y1 + w_length.y; can_join = TRUE; nodes = wire_get_nodes (wire); for (; nodes; nodes = nodes->next) { SheetPos p; Node *node = (Node *)nodes->data; p.x = _x1; p.y = _y1; if ((fabs (node->key.x - p.x) < 1e-3) && (fabs (node->key.y - p.y) < 1e-3)){ can_join = FALSE; break; } p.x = _x2; p.y = _y2; if ((fabs (node->key.x - p.x) < 1e-3) && (fabs (node->key.y - p.y) < 1e-3)){ can_join = FALSE; break; } } if (IS_EQ(_y1, _y2) && can_join) { if (w_pos.x < pos.x) pos.x = w_pos.x; if (w_pos.y < pos.y) pos.y = w_pos.y; length.x += w_length.x; length.y += w_length.y; // Update the new size and pos of the wire item_data_unregister (ITEM_DATA (ipoint->wire)); wire_set_length (ipoint->wire, &length); item_data_set_pos (ITEM_DATA (ipoint->wire), &pos); wire_update_bbox (ipoint->wire); item_data_register (ITEM_DATA (ipoint->wire)); // Done!, return -1 so wire si deleted return -1; } } node = node_store_get_or_create_node (store, ipoint->pos); // Add the wire, and also the wire that is intersected. node_add_wire (node, wire); node_add_wire (node, ipoint->wire); wire_add_node (wire, node); wire_add_node (ipoint->wire, node); NG_DEBUG ("Add wire to wire.\n"); g_free (ipoint); } g_slist_free (ip_list); // Check for intersection with parts (pins). ip_list = wire_intersect_parts (store, wire); for (list = ip_list; list; list = list->next) { node = list->data; // Add the wire to the node (pin) that it intersected. node_add_wire (node, wire); wire_add_node (wire, node); NG_DEBUG ("Add wire to pin.\n"); } g_slist_free (ip_list); 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; }