smartdisperse.c

/* smartdisperse plug-in for PCB

   Improve the initial dispersion of elements by choosing an order based
   on the netlist, rather than the arbitrary element order.  This isn't
   the same as a global autoplace, it's more of a linear autoplace.  It
   might make some useful local groupings.  For example, you should not
   have to chase all over the board to find the resistor that goes with
   a given LED.

   Copyright (C) 2007 Ben Jackson <ben@ben.com> based on teardrops.c by
   Copyright (C) 2006 DJ Delorie <dj@delorie.com>
   as well as the original action.c, and autoplace.c

   Licensed under the terms of the GNU General Public License, version
   2 or later.
*/

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

#include "global.h"
#include "data.h"
#include "hid.h"
#include "misc.h"
#include "create.h"
#include "rtree.h"
#include "undo.h"
#include "rats.h"
#include "error.h"
#include "move.h"
#include "draw.h"
#include "set.h"

#define GAP 10000
static LocationType minx;
static LocationType miny;
static LocationType maxx;
static LocationType maxy;

/*
 * Place one element.  Must initialize statics above before calling for
 * the first time.
 *
 * This is taken almost entirely from ActionDisperseElements, with cleanup
 */
static void
place(ElementTypePtr element)
{
        LocationType dx, dy;

        /* figure out how much to move the element */
        dx = minx - element->BoundingBox.X1;
        dy = miny - element->BoundingBox.Y1;

        /* snap to the grid */
        dx -= (element->MarkX + dx) % (long) (PCB->Grid);
        dx += (long) (PCB->Grid);
        dy -= (element->MarkY + dy) % (long) (PCB->Grid);
        dy += (long) (PCB->Grid);

        /*
         * and add one grid size so we make sure we always space by GAP or
         * more
         */
        dx += (long) (PCB->Grid);

        /* Figure out if this row has room.  If not, start a new row */
        if (minx != GAP && GAP + element->BoundingBox.X2 + dx > PCB->MaxWidth) {
                miny = maxy + GAP;
                minx = GAP;
                place(element);         /* recurse can't loop, now minx==GAP */
                return;
        }

        /* move the element */
        MoveElementLowLevel (PCB->Data, element, dx, dy);

        /* and add to the undo list so we can undo this operation */
        AddObjectToMoveUndoList (ELEMENT_TYPE, NULL, NULL, element, dx, dy);

        /* keep track of how tall this row is */
        minx += element->BoundingBox.X2 - element->BoundingBox.X1 + GAP;
        if (maxy < element->BoundingBox.Y2) {
                maxy = element->BoundingBox.Y2;
        }
}

/*
 * Return the X location of a connection's pad or pin within its element
 */
static LocationType
padDX(ConnectionTypePtr conn)
{
        ElementTypePtr element = (ElementTypePtr) conn->ptr1;
        AnyLineObjectTypePtr line = (AnyLineObjectTypePtr) conn->ptr2;

        return line->BoundingBox.X1 -
                        (element->BoundingBox.X1 + element->BoundingBox.X2) / 2;
}

/* return true if ea,eb would be the best order, else eb,ea, based on pad loc */
static int
padorder(ConnectionTypePtr conna, ConnectionTypePtr connb)
{
        LocationType dxa, dxb;

        dxa = padDX(conna);
        dxb = padDX(connb);
        /* there are other cases that merit rotation, ignore them for now */
        if (dxa > 0 && dxb < 0)
                return 1;
        return 0;
}

/* ewww, these are actually arrays */
#define ELEMENT_N(DATA,ELT)     ((ELT) - (DATA)->Element)
#define VISITED(ELT)            (visited[ELEMENT_N(PCB->Data, (ELT))])
#define IS_ELEMENT(CONN)        ((CONN)->type == PAD_TYPE || (CONN)->type == PIN_TYPE)

#define ARG(n) (argc > (n) ? argv[n] : 0)

static const char smartdisperse_syntax[] = "SmartDisperse([All|Selected])";

static int
smartdisperse (int argc, char **argv, int x, int y)
{
        char *function = ARG(0);
        NetListTypePtr Nets;
        char *visited;
//      PointerListType stack = { 0, 0, NULL };
        int all;
//      int changed = 0;
//      int i;

        if (! function) {
                all = 1;
        } else if (strcmp(function, "All") == 0) {
                all = 1;
        } else if (strcmp(function, "Selected") == 0) {
                all = 0;
        } else {
                AFAIL(smartdisperse);
        }

        Nets = ProcNetlist (&PCB->NetlistLib);
        if (! Nets) {
                Message (_("Can't use SmartDisperse because no netlist is loaded.\n"));
                return 0;
        }

        /* remember which elements we finish with */
        visited = MyCalloc(PCB->Data->ElementN, sizeof(*visited),
                                "smartdisperse()");

        /* if we're not doing all, mark the unselected elements as "visited" */
        ELEMENT_LOOP(PCB->Data);
        {
                if (! (all || TEST_FLAG (SELECTEDFLAG, element))) {
                        visited[n] = 1;
                }
        }
        END_LOOP;

        /* initialize variables for place() */
        minx = GAP;
        miny = GAP;
        maxx = GAP;
        maxy = GAP;

        /*
         * Pick nets with two connections.  This is the start of a more
         * elaborate algorithm to walk serial nets, but the datastructures
         * are too gross so I'm going with the 80% solution.
         */
        NET_LOOP(Nets);
        {
                ConnectionTypePtr       conna, connb;
                ElementTypePtr          ea, eb;
//              ElementTypePtr          *epp;

                if (net->ConnectionN != 2)
                        continue;

                conna = &net->Connection[0];
                connb = &net->Connection[1];
                if (!IS_ELEMENT(conna) || !IS_ELEMENT(conna))
                        continue;

                ea = (ElementTypePtr) conna->ptr1;
                eb = (ElementTypePtr) connb->ptr1;

                /* place this pair if possible */
                if (VISITED(ea) || VISITED(eb))
                        continue;
                VISITED(ea) = 1;
                VISITED(eb) = 1;

                /* a weak attempt to get the linked pads side-by-side */
                if (padorder(conna, connb)) {
                        place(ea);
                        place(eb);
                } else {
                        place(eb);
                        place(ea);
                }
        }
        END_LOOP;

        /* Place larger nets, still grouping by net */
        NET_LOOP(Nets);
        {
                CONNECTION_LOOP(net);
                {
                        ElementTypePtr element;

                        if (! IS_ELEMENT(connection))
                                continue;

                        element = (ElementTypePtr) connection->ptr1;

                        /* place this one if needed */
                        if (VISITED(element))
                                continue;
                        VISITED(element) = 1;
                        place(element);
                }
                END_LOOP;
        }
        END_LOOP;

        /* Place up anything else */
        ELEMENT_LOOP(PCB->Data);
        {
                if (! visited[n]) {
                        place(element);
                }
        }
        END_LOOP;

        free(visited);

        IncrementUndoSerialNumber();
        ClearAndRedrawOutput();
        SetChangedFlag(1);

        return 0;
}

static HID_Action smartdisperse_action_list[] = {
        {"smartdisperse", NULL, smartdisperse, NULL, NULL}
};

REGISTER_ACTIONS (smartdisperse_action_list)

void
hid_smartdisperse_init()
{
        register_smartdisperse_action_list();
}

---