o_net_basic.c

Go to the documentation of this file.

/* gEDA - GPL Electronic Design Automation
 * libgeda - gEDA's library
 * Copyright (C) 1998-2010 Ales Hvezda
 * Copyright (C) 1998-2010 gEDA Contributors (see ChangeLog for details)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
#include <config.h>

#include <stdio.h>
#include <math.h>

#include "libgeda_priv.h"

#ifdef HAVE_LIBDMALLOC
#include <dmalloc.h>
#endif

gboolean o_net_get_position (TOPLEVEL *toplevel, gint *x, gint *y,
                              OBJECT *object)
{
  return o_line_get_position(toplevel, x, y, object);
}

void world_get_net_bounds(TOPLEVEL *toplevel, OBJECT *object, int *left,
                          int *top, int *right, int *bottom)
{
  world_get_line_bounds( toplevel, object, left, top, right, bottom );
}

OBJECT *o_net_new(TOPLEVEL *toplevel, char type,
          int color, int x1, int y1, int x2, int y2)
{
  OBJECT *new_node;

  new_node = s_basic_new_object(type, "net");
  new_node->color = color;

  new_node->line = (LINE *) g_malloc(sizeof(LINE));
  /* check for null */

  new_node->line->x[0] = x1;
  new_node->line->y[0] = y1;
  new_node->line->x[1] = x2;
  new_node->line->y[1] = y2;
  new_node->line_width = NET_WIDTH;

  o_net_recalc (toplevel, new_node);

  return new_node;
}

void o_net_recalc(TOPLEVEL *toplevel, OBJECT *o_current)
{
  int left, right, top, bottom;

  if (o_current == NULL) {
    return;
  }

  if (o_current->line == NULL) {
    return;
  }

  world_get_net_bounds(toplevel, o_current, &left, &top, &right,
                 &bottom);

  o_current->w_left = left;
  o_current->w_top = top;
  o_current->w_right = right;
  o_current->w_bottom = bottom;
  o_current->w_bounds_valid = TRUE;
}

OBJECT *o_net_read (TOPLEVEL *toplevel, const char buf[],
                    unsigned int release_ver, unsigned int fileformat_ver, GError **err)
{
  OBJECT *new_obj;
  char type;
  int x1, y1;
  int x2, y2;
  int color;

  if (sscanf (buf, "%c %d %d %d %d %d\n", &type, &x1, &y1, &x2, &y2, &color) != 6) {
        g_set_error(err, EDA_ERROR, EDA_ERROR_PARSE, _("Failed to parse net object"));
    return NULL;
  }

  if (x1 == x2 && y1 == y2) {
    s_log_message (_("Found a zero length net [ %c %d %d %d %d %d ]\n"),
                   type, x1, y1, x2, y2, color);
  }


  if (toplevel->override_net_color != -1) {
    color = toplevel->override_net_color;
  }

  if (color < 0 || color > MAX_COLORS) {
    s_log_message (_("Found an invalid color [ %s ]\n"), buf);
    s_log_message (_("Setting color to default color\n"));
    color = DEFAULT_COLOR;
  }

  new_obj = o_net_new (toplevel, type, color, x1, y1, x2, y2);

  return new_obj;
}

char *o_net_save(TOPLEVEL *toplevel, OBJECT *object)
{
  int x1, x2, y1, y2;
  char *buf;

  x1 = object->line->x[0];
  y1 = object->line->y[0];
  x2 = object->line->x[1];
  y2 = object->line->y[1];

  buf = g_strdup_printf("%c %d %d %d %d %d", object->type, x1, y1, x2, y2, object->color);
  return (buf);
}

void o_net_translate_world(TOPLEVEL *toplevel, int dx, int dy,
               OBJECT *object)
{
  /* Update world coords */
  object->line->x[0] = object->line->x[0] + dx;
  object->line->y[0] = object->line->y[0] + dy;
  object->line->x[1] = object->line->x[1] + dx;
  object->line->y[1] = object->line->y[1] + dy;

  /* Update bounding box */
  o_net_recalc (toplevel, object);

  s_tile_update_object(toplevel, object);
}

OBJECT *o_net_copy(TOPLEVEL *toplevel,  OBJECT *o_current)
{
  OBJECT *new_obj;

  /* make sure you fix this in pin and bus as well */
  /* still doesn't work... you need to pass in the new values */
  /* or don't update and update later */
  /* I think for now I'll disable the update and manually update */
  new_obj = o_net_new (toplevel, OBJ_NET, o_current->color,
                       o_current->line->x[0], o_current->line->y[0],
                       o_current->line->x[1], o_current->line->y[1]);

  return new_obj;
}

void o_net_print(TOPLEVEL *toplevel, FILE *fp, OBJECT *o_current,
         int origin_x, int origin_y)
{
  int net_width;
  int x1, y1;
  int x2, y2;

  if (o_current == NULL) {
    printf("got null in o_net_print\n");
    return;
  }

  f_print_set_color(toplevel, fp, o_current->color);

  net_width = 2;
  if (toplevel->net_style == THICK) {
    net_width = NET_WIDTH;
  }

  x1 = o_current->line->x[0] - origin_x,
  y1 = o_current->line->y[0] - origin_y;
  x2 = o_current->line->x[1] - origin_x,
  y2 = o_current->line->y[1] - origin_y;

  fprintf(fp, "%d %d %d %d %d line\n", x1,y1,x2,y2,net_width);
}


void o_net_rotate_world(TOPLEVEL *toplevel,
            int world_centerx, int world_centery, int angle,
            OBJECT *object)
{
  int newx, newy;

  if (angle == 0)
    return;

  /* translate object to origin */
  o_net_translate_world(toplevel, -world_centerx, -world_centery,
                        object);

  rotate_point_90(object->line->x[0], object->line->y[0], angle,
                  &newx, &newy);

  object->line->x[0] = newx;
  object->line->y[0] = newy;

  rotate_point_90(object->line->x[1], object->line->y[1], angle,
                  &newx, &newy);

  object->line->x[1] = newx;
  object->line->y[1] = newy;

  o_net_translate_world(toplevel, world_centerx, world_centery, object);
}

void o_net_mirror_world(TOPLEVEL *toplevel, int world_centerx,
            int world_centery, OBJECT *object)
{
  /* translate object to origin */
  o_net_translate_world(toplevel, -world_centerx, -world_centery,
                        object);

  object->line->x[0] = -object->line->x[0];

  object->line->x[1] = -object->line->x[1];

  o_net_translate_world(toplevel, world_centerx, world_centery, object);
}

int o_net_orientation(OBJECT *object)
{
    if (object->line->y[0] == object->line->y[1]) {
    return (HORIZONTAL);
    }

    if (object->line->x[0] == object->line->x[1]) {
    return (VERTICAL);
    }

    return (NEITHER);
}


static void o_net_consolidate_lowlevel (OBJECT *object,
                                        OBJECT *del_object, int orient)
{
  int temp1, temp2;
  int final1, final2;
  int changed = 0;
  GList *a_iter;
  OBJECT *a_current;

#if DEBUG
  printf("o %d %d %d %d\n", object->line->x[0], object->line->y[0],
         object->line->x[1], object->line->y[1]);
  printf("d %d %d %d %d\n", del_object->line->x[0],
         del_object->line->y[0], del_object->line->x[1],
         del_object->line->y[1]);
#endif


  if (orient == HORIZONTAL) {

    temp1 = min(object->line->x[0], del_object->line->x[0]);
    temp2 = min(object->line->x[1], del_object->line->x[1]);

    final1 = min(temp1, temp2);

    temp1 = max(object->line->x[0], del_object->line->x[0]);
    temp2 = max(object->line->x[1], del_object->line->x[1]);

    final2 = max(temp1, temp2);

    object->line->x[0] = final1;
    object->line->x[1] = final2;
    changed = 1;
  }

  if (orient == VERTICAL) {
    temp1 = min(object->line->y[0], del_object->line->y[0]);
    temp2 = min(object->line->y[1], del_object->line->y[1]);

    final1 = min(temp1, temp2);

    temp1 = max(object->line->y[0], del_object->line->y[0]);
    temp2 = max(object->line->y[1], del_object->line->y[1]);

    final2 = max(temp1, temp2);

    object->line->y[0] = final1;
    object->line->y[1] = final2;
    changed = 1;
  }
#if DEBUG
  printf("fo %d %d %d %d\n", object->line->x[0], object->line->y[0],
         object->line->x[1], object->line->y[1]);
#endif

  /* Move any attributes from the deleted object*/
  if (changed && del_object->attribs != NULL) {

    /* Reassign the attached_to pointer on attributes from the del object */
    a_iter = del_object->attribs;
    while (a_iter != NULL) {
      a_current = a_iter->data;
      a_current->attached_to = object;
      a_iter = g_list_next (a_iter);
    }

    object->attribs = g_list_concat (object->attribs, del_object->attribs);

    /* Don't free del_object->attribs as it's relinked into object's list */
    del_object->attribs = NULL;
  }
}

static int o_net_consolidate_nomidpoint (OBJECT *object, int x, int y)
{
  GList *c_current;
  CONN *conn;

  c_current = object->conn_list;
  while(c_current != NULL) {
    conn = (CONN *) c_current->data;
    if (conn->other_object) {
      if (conn->other_object->sid != object->sid &&
          conn->x == x && conn->y == y &&
          conn->type == CONN_MIDPOINT) {
#if DEBUG        
        printf("Found one! %s\n", conn->other_object->name); 
#endif         
        return(FALSE);
      }
    }
    
    c_current = g_list_next(c_current);
  }

  return(TRUE);
}

static int o_net_consolidate_segments (TOPLEVEL *toplevel, OBJECT *object)
{
  int object_orient;
  int other_orient;
  GList *c_current;
  CONN *conn;
  OBJECT *other_object;
  PAGE *page;
  int changed = 0;

  g_return_val_if_fail ((toplevel != NULL), 0);
  g_return_val_if_fail ((object != NULL), 0);
  g_return_val_if_fail ((object->type == OBJ_NET), 0);

  /* It's meaningless to do anything here if the object isn't in a page. */
  page = o_get_page (toplevel, object);
  g_return_val_if_fail ((page != NULL), 0);

  object_orient = o_net_orientation(object);

  c_current = object->conn_list;
  while(c_current != NULL) {
    conn = (CONN *) c_current->data;
    other_object = conn->other_object;

    /* only look at end points which have a valid end on the other side */
    if (other_object != NULL && conn->type == CONN_ENDPOINT &&
        conn->other_whichone != -1 && conn->whichone != -1 &&
        o_net_consolidate_nomidpoint(object, conn->x, conn->y) ) {

      if (other_object->type == OBJ_NET) {
        other_orient = o_net_orientation(other_object);

        /* - both objects have the same orientation (either vert or horiz) */
        /* - it's not the same object */
        if (object_orient == other_orient &&
            object->sid != other_object->sid &&
            other_orient != NEITHER) {

#if DEBUG
          printf("consolidating %s to %s\n", object->name, other_object->name);
#endif

          o_net_consolidate_lowlevel(object, other_object, other_orient);

          changed++;
          if (other_object->selected == TRUE ) {
            o_selection_remove (toplevel, page->selection_list, other_object);

            /* If we're consolidating with a selected object,
             * ensure we select the resulting object.
             */
            if (object->selected == FALSE) {
              o_selection_add (toplevel, page->selection_list, object);
            }
          }

          s_delete_object (toplevel, other_object);
          o_net_recalc(toplevel, object);
          s_tile_update_object(toplevel, object);
          s_conn_update_object (toplevel, object);
          return(-1);
        }
      }
      
    }

    c_current = g_list_next (c_current);
  }

  return(0);
}

void o_net_consolidate(TOPLEVEL *toplevel, PAGE *page)
{
  OBJECT *o_current;
  const GList *iter;
  int status = 0;

  g_return_if_fail (toplevel != NULL);
  g_return_if_fail (page != NULL);

  iter = s_page_objects (page);

  while (iter != NULL) {
    o_current = (OBJECT *)iter->data;

    if (o_current->type == OBJ_NET) {
      status = o_net_consolidate_segments(toplevel, o_current);
    }

    if (status == -1) {
      iter = s_page_objects (page);
      status = 0;
    } else {
      iter = g_list_next (iter);
    }
  }
}

void o_net_modify(TOPLEVEL *toplevel, OBJECT *object,
          int x, int y, int whichone)
{
  object->line->x[whichone] = x;
  object->line->y[whichone] = y;

  o_net_recalc (toplevel, object);

  s_tile_update_object(toplevel, object);
}

void o_net_refresh_conn_cache(TOPLEVEL *toplevel, OBJECT *o_current)
{
  gint            num_conns = 0;
  GHashTable     *visited;
  GHashTableIter  iter;
  GList          *stack = NULL;
  OBJECT         *obj;
  gpointer       key;

  g_return_if_fail (toplevel);
  g_return_if_fail (o_current);
  g_return_if_fail (o_current->type == OBJ_NET);

  /* Keep track of visited nets, pins and buses in the hash table.
   * This way we short-circuit the search and avoid loops.
   */
  visited = g_hash_table_new (NULL, NULL);

  /*
   * Add the starting net to the hash so:
   *   1. it is not traversed twice
   *   2. it is updated at the end if no connections are found
   */
  g_hash_table_insert (visited, o_current, o_current);

  /* Check if a netname= is attached to the starting net segment */
  if (NULL != o_attrib_search_object_attribs_by_name (o_current,
                                                      "netname",
                                                      0)) {
    num_conns += 1;
  }

  /* Keep track of connections to search at each net segment in a stack.
   * Each stack entry points to an entry in obj->conn_list.
   * Pop the stack when we have no more connections to check.
   * Push next entry on the stack if we encounter a net segment.
   */

  /* Initialise the stack for the starting net segment. */
  stack = g_list_prepend (stack, o_current->conn_list);

  while (stack != NULL) {
    /* At start of the loop, take a new connection from the stack. */
    GList *conn_list = (GList*) stack->data;
    CONN *conn;

    if (conn_list == NULL) {
      /* No more connections to check at this level. Pop the stack. */
      stack = g_list_delete_link (stack, stack);
      continue;
    }

    /* Extract the next connected object and advance the connection list. */
    conn = (CONN*) conn_list->data;
    stack->data = (gpointer) g_list_next (conn_list);

    if (conn == NULL)
        /* should not happen */
        continue;
    obj = conn->other_object;
    if (obj == NULL)
        /* should not happen */
        continue;

    /* Act upon the object that is connected to the segment. */
    switch (obj->type) {
      case OBJ_PIN:
      case OBJ_BUS:
        if (NULL == g_hash_table_lookup (visited, obj)) {
          g_hash_table_insert (visited, obj, obj);
          num_conns += 1;
        }
        break;
      case OBJ_NET:
        if (NULL == g_hash_table_lookup (visited, obj)) {
          g_hash_table_insert (visited, obj, obj);
          /* Check if a netname= is attached to this net segment */
          if (NULL != o_attrib_search_object_attribs_by_name (obj,
                                                              "netname",
                                                              0)) {
            num_conns += 1;
          }
          /* Push new list of connections to check onto the stack */
          stack = g_list_prepend (stack, obj->conn_list);
        }
        break;
      default:
        break;
    }
  }

  /* Cache value of num_conns in all visited objects */
  g_hash_table_iter_init (&iter, visited);

  while (g_hash_table_iter_next (&iter, &key, NULL)) {
    obj = (OBJECT*) key;
    if (obj->type == OBJ_NET) {
      obj->net_num_connected = num_conns;
      obj->valid_num_connected = TRUE;
    }
  }

  g_hash_table_destroy (visited);
  g_list_free (stack);
}

gboolean o_net_is_fully_connected (TOPLEVEL *toplevel,
                                   OBJECT   *o_current)
{
  g_return_val_if_fail (toplevel, FALSE);
  g_return_val_if_fail (o_current, FALSE);
  g_return_val_if_fail (o_current->type == OBJ_NET, FALSE);

  if (!o_current->valid_num_connected)
    o_net_refresh_conn_cache (toplevel, o_current);

  g_return_val_if_fail (o_current->valid_num_connected, FALSE);

  return o_current->net_num_connected > 1 ? TRUE : FALSE;
}