int
footprint_update(int argc, char **argv, int x, int y)
{
global_argc = argc;
global_argv = argv;
debug_log("footprint_update\n");
debug_log(" argc: %d\n", argc);
if (argc) {
int i;
for (i = 0; i < argc; i++) {
debug_log(" argv[%d]: %s\n", i, argv[i]);
}
}
if (argc >= 1) {
if (strcasecmp(argv[0], "auto") == 0) {
match_mode = MATCH_MODE_AUTO;
style = STYLE_ALL;
} else if (strcasecmp(argv[0], "manual") == 0) {
match_mode = MATCH_MODE_MANUAL;
style = STYLE_SELECTED;
} else {
base_log("Error: If given, the first argument must be "
"\"auto\" or \"manual\".\n");
return usage();
}
if (argc >= 2) {
if (strcasecmp(argv[1], "selected") == 0) {
style = STYLE_SELECTED;
} else if (strcasecmp(argv[1], "named") == 0) {
style = STYLE_NAMED;
} else {
base_log("Error: If given, the second argument must be "
"\"selected\", or \"named\".\n");
return usage();
}
}
}
debug_log("match_mode: %d\n", match_mode);
debug_log("style: %d\n", style);
if (PASTEBUFFER->Data->ElementN != 1) {
base_log("Error: Paste buffer should contain one element.\n");
return usage();
}
ELEMENT_LOOP(PASTEBUFFER->Data);
{
int replaced = replace_footprints(element);
if (replaced) {
base_log("Replaced %d elements.\n", replaced);
IncrementUndoSerialNumber();
}
}
END_LOOP;
return 0;
}
void
log_pin(PinType *p)
{
base_log("Pin\n");
base_log("Name: \"%s\"\n", p->Name);
base_log("Number: \"%s\"\n", p->Number);
base_log("Point: (%d, %d)\n", p->X, p->Y);
}
void
log_pad(PadType *p)
{
base_log("Pad\n");
base_log("Name: \"%s\"\n", p->Name);
base_log("Number: \"%s\"\n", p->Number);
base_log("Point 1: (%d, %d)\n", p->Point1.X, p->Point1.Y);
base_log("Point 2: (%d, %d)\n", p->Point2.X, p->Point2.Y);
}
static Boolean
replace_one_footprint_translate_only(ElementTypePtr old_element,
ElementTypePtr new_element)
{
/* Just requires one corresponding pad/pin. Does no rotations. */
if (! have_any_corresponding_pad_or_pin(old_element, new_element,
NULL, NULL)) {
return False;
}
/* Create copy of new element. */
ElementTypePtr copy_element =
CopyElementLowLevel(PCB->Data, NULL, new_element, False, 0, 0);
PadOrPinType old_pp = make_pad_or_pin(NULL, NULL);
PadOrPinType copy_pp = make_pad_or_pin(NULL, NULL);
if (! have_any_corresponding_pad_or_pin(old_element, copy_element,
&old_pp, ©_pp)) {
base_log("Error: Couldn't find any corresponding pads or pins.");
return False;
}
replace_one_footprint_aux(old_element, &old_pp, NULL,
copy_element, ©_pp, NULL);
debug_log("Used translation-only replacement.\n");
return True;
}
static Boolean
replace_one_footprint_quick(ElementTypePtr old_element,
ElementTypePtr new_element)
{
/* Requires that there be two non-coincident, uniquely numbered
pads/pins that correspond between the old and new element. */
if (! have_two_corresponding_unique_non_coincident(old_element,
new_element,
NULL, NULL,
NULL, NULL)) {
return False;
}
/* Create copy of new element. */
ElementTypePtr copy_element =
CopyElementLowLevel(PCB->Data, NULL, new_element, False, 0, 0);
PadOrPinType old1_pp;
PadOrPinType old2_pp;
PadOrPinType copy1_pp;
PadOrPinType copy2_pp;
if (! have_two_corresponding_unique_non_coincident(old_element,
copy_element,
&old1_pp, &old2_pp,
©1_pp, ©2_pp)) {
base_log("Error: Couldn't find two corresponding, unique, "
"non-coincident element pads/pins.");
return False;
}
replace_one_footprint_aux(old_element, &old1_pp, &old2_pp,
copy_element, ©1_pp, ©2_pp);
debug_log("Used quick replacement.\n");
return True;
}
static int
replace_footprints(ElementTypePtr new_element)
{
int replaced = 0;
int i = 0;
ELEMENT_LOOP (PCB->Data);
{
if (match_mode != MATCH_MODE_AUTO
|| strcmp(DESCRIPTION_NAME(new_element),
DESCRIPTION_NAME(element)) == 0) {
Boolean matched = False;
switch (style) {
case STYLE_ALL:
matched = True;
break;
case STYLE_SELECTED:
matched = TEST_FLAG(SELECTEDFLAG, element);
break;
case STYLE_NAMED:
for (i = 0; i < global_argc; i++) {
if (NAMEONPCB_NAME(element)
&& strcasecmp(NAMEONPCB_NAME(element), global_argv[i]) == 0) {
matched = True;
break;
}
}
break;
}
if (matched) {
if (TEST_FLAG (LOCKFLAG, element)) {
base_log("Skipping \"%s\". Element locked.\n",
NAMEONPCB_NAME(element));
} else {
debug_log("Considering \"%s\".\n", NAMEONPCB_NAME(element));
if (replace_one_footprint(element, new_element)) {
base_log("Replaced \"%s\".\n", NAMEONPCB_NAME(element));
replaced++;
}
}
}
}
}
END_LOOP;
return replaced;
}
CheapPointType
pad_or_pin_center(PadOrPinType* pp)
{
if (pp->pad) {
return pad_center(pp->pad);
} else if (pp->pin) {
return pin_center(pp->pin);
} else {
base_log("Error: pad_or_pin_center() got an empty PadOrPinType.\n");
return make_point(0, 0);
}
}
int
usage()
{
base_log("usage:\n");
base_log(" UpdateFootprintsFromBuffer()\n");
base_log(" UpdateFootprintsFromBuffer(auto|manual)\n");
base_log(" UpdateFootprintsFromBuffer(auto|manual, selected)\n");
base_log(" UpdateFootprintsFromBuffer(auto|manual, named, "
"<name1>[, <name2>...])\n");
base_log("version: %s\n", VERSION);
return 1;
}
BYTE
angle_to_rotation_steps(double rad)
{
double rad90 = multiple_of_90(rad);
if (ANGLE_NEAR(rad90, M_PI / 2)) {
return 3;
} else if (ANGLE_NEAR(fabs(rad90), M_PI)) {
return 2;
} else if (ANGLE_NEAR(rad90, -M_PI / 2)) {
return 1;
} else if (ANGLE_NEAR(rad90, 0)) {
return 0;
} else {
base_log("Error: angle_to_rotation_steps() got "
"an unhandled angle: %lf\n",
rad * RAD_TO_DEG);
return 0;
}
}
static Boolean
replace_one_footprint_expensive(ElementTypePtr old_element,
ElementTypePtr new_element)
{
/* Requires that there be two corresponding, non-coincident
pads/pins; non-unique pad/pin numbers okay.
It's expensive because it does an exhaustive comparison of the
resulting transformations for the four possible 90 degree
rotations plus combinations of same-numbered pads/pins. Should
only be necessary if the element *only* has pads and pins that
share the same pad/pin number. */
if (! have_two_corresponding_non_coincident(old_element, new_element,
NULL, NULL, NULL, NULL)) {
return False;
}
/* Create copy of new element. */
ElementTypePtr copy_element =
CopyElementLowLevel(PCB->Data, NULL, new_element, False, 0, 0);
int old_ppd_len = 0;
ElementPadPinData* old_ppd =
alloc_pad_pin_data_array(old_element, &old_ppd_len);
int copy_ppd_len = 0;
ElementPadPinData* copy_ppd =
alloc_pad_pin_data_array(copy_element, ©_ppd_len);
int copy_index1 = 0;
int copy_index2 = 0;
if (! find_non_coincident(copy_ppd, copy_ppd_len,
©_index1, ©_index2)) {
base_log("Error: Couldn't find non-coincident element pads/pins.");
MYFREE(old_ppd);
MYFREE(copy_ppd);
return False;
}
Boolean reflect = IS_REFLECTED(new_element, old_element);
int old_index1 = 0;
int old_index2 = 0;
if (! find_best_corresponding_pads_or_pins(copy_ppd, copy_ppd_len,
copy_index1, copy_index2,
reflect,
old_ppd, old_ppd_len,
&old_index1, &old_index2)) {
MYFREE(old_ppd);
MYFREE(copy_ppd);
return False;
}
replace_one_footprint_aux(old_element,
&old_ppd[old_index1].pp,
&old_ppd[old_index2].pp,
copy_element,
©_ppd[copy_index1].pp,
©_ppd[copy_index2].pp);
MYFREE(old_ppd);
MYFREE(copy_ppd);
debug_log("Used expensive replacement.\n");
return True;
}
void
log_element(ElementType *e)
{
base_log("Element\n");
base_log("Description: %s\n", DESCRIPTION_NAME(e));
base_log("Name on PCB: %s\n", NAMEONPCB_NAME(e));
base_log("Value: %s\n", VALUE_NAME(e));
base_log("Flags: %04x\n", FLAG_VALUE(e->Flags));
base_log("MarkX, MarkY: %d, %d\n", e->MarkX, e->MarkY);
base_log("PinN: %d\n", e->PinN);
base_log("PadN: %d\n", e->PadN);
base_log("LineN: %d\n", e->LineN);
base_log("ArcN: %d\n", e->ArcN);
base_log("Attributes number: %d\n", e->Attributes.Number);
int i = 0;
PAD_LOOP(e);
{
base_log("Pad %d\n", i++);
log_pad(pad);
}
END_LOOP;
i = 0;
PIN_LOOP(e);
{
base_log("Pin %d\n", i++);
log_pin(pin);
}
END_LOOP;
}
void
log_point(CheapPointType pt)
{
base_log("Point\n");
base_log("%8d %8d\n", pt.X, pt.Y);
}
