Index: trunk/src/action_helper.c =================================================================== --- trunk/src/action_helper.c (revision 2502) +++ trunk/src/action_helper.c (revision 2503) @@ -406,7 +406,7 @@ */ void NotifyLine(void) { - int type = NO_TYPE; + int type = PCB_TYPE_NONE; void *ptr1, *ptr2, *ptr3; if (!Marked.status || conf_core.editor.local_ref) @@ -413,19 +413,19 @@ SetLocalRef(Crosshair.X, Crosshair.Y, true); switch (Crosshair.AttachedLine.State) { case STATE_FIRST: /* first point */ - if (PCB->RatDraw && SearchScreen(Crosshair.X, Crosshair.Y, PAD_TYPE | PIN_TYPE, &ptr1, &ptr1, &ptr1) == NO_TYPE) { + if (PCB->RatDraw && SearchScreen(Crosshair.X, Crosshair.Y, PCB_TYPE_PAD | PCB_TYPE_PIN, &ptr1, &ptr1, &ptr1) == PCB_TYPE_NONE) { gui->beep(); break; } if (conf_core.editor.auto_drc && conf_core.editor.mode == LINE_MODE) { - type = SearchScreen(Crosshair.X, Crosshair.Y, PIN_TYPE | PAD_TYPE | VIA_TYPE, &ptr1, &ptr2, &ptr3); + type = SearchScreen(Crosshair.X, Crosshair.Y, PCB_TYPE_PIN | PCB_TYPE_PAD | PCB_TYPE_VIA, &ptr1, &ptr2, &ptr3); LookupConnection(Crosshair.X, Crosshair.Y, true, 1, FOUNDFLAG); } - if (type == PIN_TYPE || type == VIA_TYPE) { + if (type == PCB_TYPE_PIN || type == PCB_TYPE_VIA) { Crosshair.AttachedLine.Point1.X = Crosshair.AttachedLine.Point2.X = ((PinTypePtr) ptr2)->X; Crosshair.AttachedLine.Point1.Y = Crosshair.AttachedLine.Point2.Y = ((PinTypePtr) ptr2)->Y; } - else if (type == PAD_TYPE) { + else if (type == PCB_TYPE_PAD) { PadTypePtr pad = (PadTypePtr) ptr2; double d1 = Distance(Crosshair.X, Crosshair.Y, pad->Point1.X, pad->Point1.Y); double d2 = Distance(Crosshair.X, Crosshair.Y, pad->Point2.X, pad->Point2.Y); @@ -501,7 +501,7 @@ * (Note.Moving) or clicked on a MOVE_TYPE * (Note.Hit) */ - for (test = (SELECT_TYPES | MOVE_TYPES) & ~RATLINE_TYPE; test; test &= ~type) { + for (test = (SELECT_TYPES | MOVE_TYPES) & ~PCB_TYPE_RATLINE; test; test &= ~type) { type = SearchScreen(Note.X, Note.Y, test, &ptr1, &ptr2, &ptr3); if (!Note.Hit && (type & MOVE_TYPES) && !TEST_FLAG(LOCKFLAG, (PinTypePtr) ptr2)) { Note.Hit = type; @@ -511,7 +511,7 @@ } if (!Note.Moving && (type & SELECT_TYPES) && TEST_FLAG(SELECTEDFLAG, (PinTypePtr) ptr2)) Note.Moving = true; - if ((Note.Hit && Note.Moving) || type == NO_TYPE) + if ((Note.Hit && Note.Moving) || type == PCB_TYPE_NONE) break; } break; @@ -528,9 +528,9 @@ if ((via = CreateNewVia(PCB->Data, Note.X, Note.Y, conf_core.design.via_thickness, 2 * conf_core.design.clearance, 0, conf_core.design.via_drilling_hole, NULL, NoFlags())) != NULL) { - AddObjectToCreateUndoList(VIA_TYPE, via, via, via); + AddObjectToCreateUndoList(PCB_TYPE_VIA, via, via, via); if (gui->shift_is_pressed()) - ChangeObjectThermal(VIA_TYPE, via, via, via, PCB->ThermStyle); + ChangeObjectThermal(PCB_TYPE_VIA, via, via, via, PCB->ThermStyle); IncrementUndoSerialNumber(); DrawVia(via); Draw(); @@ -592,7 +592,7 @@ bx = GetArcEnds(arc); Crosshair.AttachedBox.Point1.X = Crosshair.AttachedBox.Point2.X = bx->X2; Crosshair.AttachedBox.Point1.Y = Crosshair.AttachedBox.Point2.Y = bx->Y2; - AddObjectToCreateUndoList(ARC_TYPE, CURRENT, arc, arc); + AddObjectToCreateUndoList(PCB_TYPE_ARC, CURRENT, arc, arc); IncrementUndoSerialNumber(); addedLines++; DrawArc(CURRENT, arc); @@ -606,8 +606,8 @@ } case LOCK_MODE: { - type = SearchScreen(Note.X, Note.Y, LOCK_TYPES, &ptr1, &ptr2, &ptr3); - if (type == ELEMENT_TYPE) { + type = SearchScreen(Note.X, Note.Y, PCB_TYPEMASK_LOCK, &ptr1, &ptr2, &ptr3); + if (type == PCB_TYPE_ELEMENT) { ElementTypePtr element = (ElementTypePtr) ptr2; TOGGLE_FLAG(LOCKFLAG, element); @@ -631,7 +631,7 @@ Draw(); hid_actionl("Report", "Object", NULL); } - else if (type != NO_TYPE) { + else if (type != PCB_TYPE_NONE) { TextTypePtr thing = (TextTypePtr) ptr3; TOGGLE_FLAG(LOCKFLAG, thing); if (TEST_FLAG(LOCKFLAG, thing) @@ -647,7 +647,7 @@ } case THERMAL_MODE: { - if (((type = SearchScreen(Note.X, Note.Y, PIN_TYPES, &ptr1, &ptr2, &ptr3)) != NO_TYPE) + if (((type = SearchScreen(Note.X, Note.Y, PCB_TYPEMASK_PIN, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) && !TEST_FLAG(HOLEFLAG, (PinTypePtr) ptr3)) { if (gui->shift_is_pressed()) { int tstyle = GET_THERM(INDEXOFCURRENT, (PinTypePtr) ptr3); @@ -685,7 +685,7 @@ RatTypePtr line; if ((line = AddNet())) { addedLines++; - AddObjectToCreateUndoList(RATLINE_TYPE, line, line, line); + AddObjectToCreateUndoList(PCB_TYPE_RATLINE, line, line, line); IncrementUndoSerialNumber(); DrawRat(line); Crosshair.AttachedLine.Point1.X = Crosshair.AttachedLine.Point2.X; @@ -734,7 +734,7 @@ PinTypePtr via; addedLines++; - AddObjectToCreateUndoList(LINE_TYPE, CURRENT, line, line); + AddObjectToCreateUndoList(PCB_TYPE_LINE, CURRENT, line, line); DrawLine(CURRENT, line); /* place a via if vias are visible, the layer is in a new group since the last line and there @@ -741,11 +741,11 @@ isn't a pin already here */ if (PCB->ViaOn && GetLayerGroupNumberByPointer(CURRENT) != GetLayerGroupNumberByPointer(lastLayer) && - SearchObjectByLocation(PIN_TYPES, &ptr1, &ptr2, &ptr3, + SearchObjectByLocation(PCB_TYPEMASK_PIN, &ptr1, &ptr2, &ptr3, Crosshair.AttachedLine.Point1.X, Crosshair.AttachedLine.Point1.Y, conf_core.design.via_thickness / 2) == - NO_TYPE + PCB_TYPE_NONE && (via = CreateNewVia(PCB->Data, Crosshair.AttachedLine.Point1.X, @@ -752,7 +752,7 @@ Crosshair.AttachedLine.Point1.Y, conf_core.design.via_thickness, 2 * conf_core.design.clearance, 0, conf_core.design.via_drilling_hole, NULL, NoFlags())) != NULL) { - AddObjectToCreateUndoList(VIA_TYPE, via, via, via); + AddObjectToCreateUndoList(PCB_TYPE_VIA, via, via, via); DrawVia(via); } /* copy the coordinates */ @@ -772,7 +772,7 @@ MakeFlags((conf_core.editor.auto_drc ? FOUNDFLAG : 0) | (conf_core.editor.clear_line ? CLEARLINEFLAG : 0)))) != NULL) { addedLines++; - AddObjectToCreateUndoList(LINE_TYPE, CURRENT, line, line); + AddObjectToCreateUndoList(PCB_TYPE_LINE, CURRENT, line, line); IncrementUndoSerialNumber(); DrawLine(CURRENT, line); /* move to new start point */ @@ -815,7 +815,7 @@ Crosshair.AttachedBox.Point1.Y, Crosshair.AttachedBox.Point2.X, Crosshair.AttachedBox.Point2.Y, MakeFlags(flags))) != NULL) { - AddObjectToCreateUndoList(POLYGON_TYPE, CURRENT, polygon, polygon); + AddObjectToCreateUndoList(PCB_TYPE_POLYGON, CURRENT, polygon, polygon); IncrementUndoSerialNumber(); DrawPolygon(CURRENT, polygon); Draw(); @@ -839,7 +839,7 @@ flag |= ONSOLDERFLAG; if ((text = CreateNewText(CURRENT, &PCB->Font, Note.X, Note.Y, 0, conf_core.design.text_scale, string, MakeFlags(flag))) != NULL) { - AddObjectToCreateUndoList(TEXT_TYPE, CURRENT, text, text); + AddObjectToCreateUndoList(PCB_TYPE_TEXT, CURRENT, text, text); IncrementUndoSerialNumber(); DrawText(CURRENT, text); Draw(); @@ -891,10 +891,10 @@ /* first notify, lookup object */ case STATE_FIRST: Crosshair.AttachedObject.Type = - SearchScreen(Note.X, Note.Y, POLYGON_TYPE, + SearchScreen(Note.X, Note.Y, PCB_TYPE_POLYGON, &Crosshair.AttachedObject.Ptr1, &Crosshair.AttachedObject.Ptr2, &Crosshair.AttachedObject.Ptr3); - if (Crosshair.AttachedObject.Type == NO_TYPE) { + if (Crosshair.AttachedObject.Type == PCB_TYPE_NONE) { Message("The first point of a polygon hole must be on a polygon.\n"); break; /* don't start doing anything if clicket out of polys */ } @@ -902,7 +902,7 @@ if (TEST_FLAG(LOCKFLAG, (PolygonTypePtr) Crosshair.AttachedObject.Ptr2)) { Message(_("Sorry, the object is locked\n")); - Crosshair.AttachedObject.Type = NO_TYPE; + Crosshair.AttachedObject.Type = PCB_TYPE_NONE; break; } else @@ -942,7 +942,7 @@ SaveUndoSerialNumber(); Flags = ((PolygonType *) Crosshair.AttachedObject.Ptr2)->Flags; PolyToPolygonsOnLayer(PCB->Data, (LayerType *) Crosshair.AttachedObject.Ptr1, result, Flags); - RemoveObject(POLYGON_TYPE, + RemoveObject(PCB_TYPE_POLYGON, Crosshair.AttachedObject.Ptr1, Crosshair.AttachedObject.Ptr2, Crosshair.AttachedObject.Ptr3); RestoreUndoSerialNumber(); IncrementUndoSerialNumber(); @@ -980,9 +980,9 @@ ElementTypePtr e = 0; if (gui->shift_is_pressed()) { - int type = SearchScreen(Note.X, Note.Y, ELEMENT_TYPE, &ptr1, &ptr2, + int type = SearchScreen(Note.X, Note.Y, PCB_TYPE_ELEMENT, &ptr1, &ptr2, &ptr3); - if (type == ELEMENT_TYPE) { + if (type == PCB_TYPE_ELEMENT) { e = (ElementTypePtr) ptr1; if (e) { int i; @@ -997,9 +997,9 @@ if (CopyPastebufferToLayout(Note.X, Note.Y)) SetChangedFlag(true); if (e) { - int type = SearchScreen(Note.X, Note.Y, ELEMENT_TYPE, &ptr1, &ptr2, + int type = SearchScreen(Note.X, Note.Y, PCB_TYPE_ELEMENT, &ptr1, &ptr2, &ptr3); - if (type == ELEMENT_TYPE && ptr1) { + if (type == PCB_TYPE_ELEMENT && ptr1) { int i, save_n; e = (ElementTypePtr) ptr1; @@ -1022,12 +1022,12 @@ } case REMOVE_MODE: - if ((type = SearchScreen(Note.X, Note.Y, REMOVE_TYPES, &ptr1, &ptr2, &ptr3)) != NO_TYPE) { + if ((type = SearchScreen(Note.X, Note.Y, REMOVE_TYPES, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) { if (TEST_FLAG(LOCKFLAG, (LineTypePtr) ptr2)) { Message(_("Sorry, the object is locked\n")); break; } - if (type == ELEMENT_TYPE) { + if (type == PCB_TYPE_ELEMENT) { RubberbandTypePtr ptr; int i; @@ -1038,7 +1038,7 @@ if (PCB->RatOn) EraseRat((RatTypePtr) ptr->Line); if (TEST_FLAG(RUBBERENDFLAG, ptr->Line)) - MoveObjectToRemoveUndoList(RATLINE_TYPE, ptr->Line, ptr->Line, ptr->Line); + MoveObjectToRemoveUndoList(PCB_TYPE_RATLINE, ptr->Line, ptr->Line, ptr->Line); else TOGGLE_FLAG(RUBBERENDFLAG, ptr->Line); /* only remove line once */ ptr++; @@ -1068,11 +1068,11 @@ Crosshair.AttachedObject.Type = SearchScreen(Note.X, Note.Y, types, &Crosshair.AttachedObject.Ptr1, &Crosshair.AttachedObject.Ptr2, &Crosshair.AttachedObject.Ptr3); - if (Crosshair.AttachedObject.Type != NO_TYPE) { + if (Crosshair.AttachedObject.Type != PCB_TYPE_NONE) { if (conf_core.editor.mode == MOVE_MODE && TEST_FLAG(LOCKFLAG, (PinTypePtr) Crosshair.AttachedObject.Ptr2)) { Message(_("Sorry, the object is locked\n")); - Crosshair.AttachedObject.Type = NO_TYPE; + Crosshair.AttachedObject.Type = PCB_TYPE_NONE; } else AttachForCopy(Note.X, Note.Y); @@ -1098,7 +1098,7 @@ SetChangedFlag(true); /* reset identifiers */ - Crosshair.AttachedObject.Type = NO_TYPE; + Crosshair.AttachedObject.Type = PCB_TYPE_NONE; Crosshair.AttachedObject.State = STATE_FIRST; break; } @@ -1114,16 +1114,16 @@ SearchScreen(Note.X, Note.Y, INSERT_TYPES, &Crosshair.AttachedObject.Ptr1, &Crosshair.AttachedObject.Ptr2, &Crosshair.AttachedObject.Ptr3); - if (Crosshair.AttachedObject.Type != NO_TYPE) { + if (Crosshair.AttachedObject.Type != PCB_TYPE_NONE) { if (TEST_FLAG(LOCKFLAG, (PolygonTypePtr) Crosshair.AttachedObject.Ptr2)) { Message(_("Sorry, the object is locked\n")); - Crosshair.AttachedObject.Type = NO_TYPE; + Crosshair.AttachedObject.Type = PCB_TYPE_NONE; break; } else { /* get starting point of nearest segment */ - if (Crosshair.AttachedObject.Type == POLYGON_TYPE) { + if (Crosshair.AttachedObject.Type == PCB_TYPE_POLYGON) { fake.poly = (PolygonTypePtr) Crosshair.AttachedObject.Ptr2; polyIndex = GetLowestDistancePolygonPoint(fake.poly, Note.X, Note.Y); fake.line.Point1 = fake.poly->Points[polyIndex]; @@ -1139,8 +1139,8 @@ /* second notify, insert new point into object */ case STATE_SECOND: - if (Crosshair.AttachedObject.Type == POLYGON_TYPE) - InsertPointIntoObject(POLYGON_TYPE, + if (Crosshair.AttachedObject.Type == PCB_TYPE_POLYGON) + InsertPointIntoObject(PCB_TYPE_POLYGON, Crosshair.AttachedObject.Ptr1, fake.poly, &polyIndex, InsertedPoint.X, InsertedPoint.Y, false, false); else @@ -1150,7 +1150,7 @@ SetChangedFlag(true); /* reset identifiers */ - Crosshair.AttachedObject.Type = NO_TYPE; + Crosshair.AttachedObject.Type = PCB_TYPE_NONE; Crosshair.AttachedObject.State = STATE_FIRST; break; } @@ -1183,15 +1183,15 @@ switch (funcid) { case F_Object: switch (type) { - case ELEMENT_TYPE: /* we'd set pin/pad properties, so fall thru */ - case VIA_TYPE: - case PIN_TYPE: + case PCB_TYPE_ELEMENT: /* we'd set pin/pad properties, so fall thru */ + case PCB_TYPE_VIA: + case PCB_TYPE_PIN: return get_style_size(F_SelectedVias, out, 0, size_id); - case PAD_TYPE: + case PCB_TYPE_PAD: return get_style_size(F_SelectedPads, out, 0, size_id); - case LINE_TYPE: + case PCB_TYPE_LINE: return get_style_size(F_SelectedLines, out, 0, size_id); - case ARC_TYPE: + case PCB_TYPE_ARC: return get_style_size(F_SelectedArcs, out, 0, size_id); } Message(_("Sorry, can't fetch the style of that object tpye (%x)\n"), type); Index: trunk/src/action_helper.h =================================================================== --- trunk/src/action_helper.h (revision 2502) +++ trunk/src/action_helper.h (revision 2503) @@ -31,7 +31,7 @@ #include "global.h" -#define CLONE_TYPES LINE_TYPE | ARC_TYPE | VIA_TYPE | POLYGON_TYPE +#define CLONE_TYPES PCB_TYPE_LINE | PCB_TYPE_ARC | PCB_TYPE_VIA | PCB_TYPE_POLYGON void ActionAdjustStyle(char *); void EventMoveCrosshair(int, int); Index: trunk/src/buffer.c =================================================================== --- trunk/src/buffer.c (revision 2502) +++ trunk/src/buffer.c (revision 2503) @@ -212,7 +212,7 @@ */ static void *MoveViaToBuffer(PinType * via) { - RestoreToPolygon(Source, VIA_TYPE, via, via); + RestoreToPolygon(Source, PCB_TYPE_VIA, via, via); r_delete_entry(Source->via_tree, (BoxType *) via); pinlist_remove(via); @@ -223,7 +223,7 @@ if (!Dest->via_tree) Dest->via_tree = r_create_tree(NULL, 0, 0); r_insert_entry(Dest->via_tree, (BoxType *) via, 0); - ClearFromPolygon(Dest, VIA_TYPE, via, via); + ClearFromPolygon(Dest, PCB_TYPE_VIA, via, via); return via; } @@ -252,7 +252,7 @@ { LayerTypePtr lay = &Dest->Layer[GetLayerNumber(Source, layer)]; - RestoreToPolygon(Source, LINE_TYPE, layer, line); + RestoreToPolygon(Source, PCB_TYPE_LINE, layer, line); r_delete_entry(layer->line_tree, (BoxType *) line); linelist_remove(line); @@ -263,7 +263,7 @@ if (!lay->line_tree) lay->line_tree = r_create_tree(NULL, 0, 0); r_insert_entry(lay->line_tree, (BoxType *) line, 0); - ClearFromPolygon(Dest, LINE_TYPE, lay, line); + ClearFromPolygon(Dest, PCB_TYPE_LINE, lay, line); return (line); } @@ -274,7 +274,7 @@ { LayerType *lay = &Dest->Layer[GetLayerNumber(Source, layer)]; - RestoreToPolygon(Source, ARC_TYPE, layer, arc); + RestoreToPolygon(Source, PCB_TYPE_ARC, layer, arc); r_delete_entry(layer->arc_tree, (BoxType *) arc); arclist_remove(arc); @@ -285,7 +285,7 @@ if (!lay->arc_tree) lay->arc_tree = r_create_tree(NULL, 0, 0); r_insert_entry(lay->arc_tree, (BoxType *) arc, 0); - ClearFromPolygon(Dest, ARC_TYPE, lay, arc); + ClearFromPolygon(Dest, PCB_TYPE_ARC, lay, arc); return (arc); } @@ -297,7 +297,7 @@ LayerType *lay = &Dest->Layer[GetLayerNumber(Source, layer)]; r_delete_entry(layer->text_tree, (BoxType *) text); - RestoreToPolygon(Source, TEXT_TYPE, layer, text); + RestoreToPolygon(Source, PCB_TYPE_TEXT, layer, text); textlist_remove(text); textlist_append(&lay->Text, text); @@ -305,7 +305,7 @@ if (!lay->text_tree) lay->text_tree = r_create_tree(NULL, 0, 0); r_insert_entry(lay->text_tree, (BoxType *) text, 0); - ClearFromPolygon(Dest, TEXT_TYPE, lay, text); + ClearFromPolygon(Dest, PCB_TYPE_TEXT, lay, text); return (text); } @@ -345,13 +345,13 @@ PIN_LOOP(element); { - RestoreToPolygon(Source, PIN_TYPE, element, pin); + RestoreToPolygon(Source, PCB_TYPE_PIN, element, pin); CLEAR_FLAG(WARNFLAG | FOUNDFLAG, pin); } END_LOOP; PAD_LOOP(element); { - RestoreToPolygon(Source, PAD_TYPE, element, pad); + RestoreToPolygon(Source, PCB_TYPE_PAD, element, pad); CLEAR_FLAG(WARNFLAG | FOUNDFLAG, pad); } END_LOOP; @@ -361,12 +361,12 @@ */ PIN_LOOP(element); { - ClearFromPolygon(Dest, PIN_TYPE, element, pin); + ClearFromPolygon(Dest, PCB_TYPE_PIN, element, pin); } END_LOOP; PAD_LOOP(element); { - ClearFromPolygon(Dest, PAD_TYPE, element, pad); + ClearFromPolygon(Dest, PCB_TYPE_PAD, element, pad); } END_LOOP; @@ -409,7 +409,7 @@ notify_crosshair_change(false); Source = PCB->Data; Dest = Buffer->Data; - SelectedOperation(&AddBufferFunctions, false, ALL_TYPES); + SelectedOperation(&AddBufferFunctions, false, PCB_TYPEMASK_ALL); /* set origin to passed or current position */ if (X || Y) { @@ -747,7 +747,7 @@ } END_LOOP; if (!hasParts) { - DestroyObject(PCB->Data, ELEMENT_TYPE, Element, Element, Element); + DestroyObject(PCB->Data, PCB_TYPE_ELEMENT, Element, Element, Element); Message(_("There was nothing to convert!\n" "Elements must have some silk, pads or pins.\n")); return (false); } @@ -759,7 +759,7 @@ SET_FLAG(ONSOLDERFLAG, Element); SetElementBoundingBox(PCB->Data, Element, &PCB->Font); ClearBuffer(Buffer); - MoveObjectToBuffer(Buffer->Data, PCB->Data, ELEMENT_TYPE, Element, Element, Element); + MoveObjectToBuffer(Buffer->Data, PCB->Data, PCB_TYPE_ELEMENT, Element, Element, Element); SetBufferBoundingBox(Buffer); return (true); } @@ -892,7 +892,7 @@ /* pre-delete the pins from the pin-tree before their coordinates change */ if (Data) r_delete_entry(Data->pin_tree, (BoxType *) pin); - RestoreToPolygon(Data, PIN_TYPE, Element, pin); + RestoreToPolygon(Data, PCB_TYPE_PIN, Element, pin); free_rotate(&pin->X, &pin->Y, X, Y, cosa, sina); SetPinBoundingBox(pin); } @@ -902,7 +902,7 @@ /* pre-delete the pads before their coordinates change */ if (Data) r_delete_entry(Data->pad_tree, (BoxType *) pad); - RestoreToPolygon(Data, PAD_TYPE, Element, pad); + RestoreToPolygon(Data, PCB_TYPE_PAD, Element, pad); free_rotate(&pad->Point1.X, &pad->Point1.Y, X, Y, cosa, sina); free_rotate(&pad->Point2.X, &pad->Point2.Y, X, Y, cosa, sina); SetLineBoundingBox((LineType *) pad); @@ -917,7 +917,7 @@ free_rotate(&Element->MarkX, &Element->MarkY, X, Y, cosa, sina); SetElementBoundingBox(Data, Element, &PCB->Font); - ClearFromPolygon(Data, ELEMENT_TYPE, Element, Element); + ClearFromPolygon(Data, PCB_TYPE_ELEMENT, Element, Element); } void FreeRotateBuffer(BufferTypePtr Buffer, Angle angle) Index: trunk/src/change.c =================================================================== --- trunk/src/change.c (revision 2502) +++ trunk/src/change.c (revision 2503) @@ -400,15 +400,15 @@ */ static void *ChangeViaThermal(PinTypePtr Via) { - AddObjectToClearPolyUndoList(VIA_TYPE, Via, Via, Via, false); - RestoreToPolygon(PCB->Data, VIA_TYPE, CURRENT, Via); - AddObjectToFlagUndoList(VIA_TYPE, Via, Via, Via); + AddObjectToClearPolyUndoList(PCB_TYPE_VIA, Via, Via, Via, false); + RestoreToPolygon(PCB->Data, PCB_TYPE_VIA, CURRENT, Via); + AddObjectToFlagUndoList(PCB_TYPE_VIA, Via, Via, Via); if (!Delta) /* remove the thermals */ CLEAR_THERM(INDEXOFCURRENT, Via); else ASSIGN_THERM(INDEXOFCURRENT, Delta, Via); - AddObjectToClearPolyUndoList(VIA_TYPE, Via, Via, Via, true); - ClearFromPolygon(PCB->Data, VIA_TYPE, CURRENT, Via); + AddObjectToClearPolyUndoList(PCB_TYPE_VIA, Via, Via, Via, true); + ClearFromPolygon(PCB->Data, PCB_TYPE_VIA, CURRENT, Via); DrawVia(Via); return Via; } @@ -419,15 +419,15 @@ */ static void *ChangePinThermal(ElementTypePtr element, PinTypePtr Pin) { - AddObjectToClearPolyUndoList(PIN_TYPE, element, Pin, Pin, false); - RestoreToPolygon(PCB->Data, VIA_TYPE, CURRENT, Pin); - AddObjectToFlagUndoList(PIN_TYPE, element, Pin, Pin); + AddObjectToClearPolyUndoList(PCB_TYPE_PIN, element, Pin, Pin, false); + RestoreToPolygon(PCB->Data, PCB_TYPE_VIA, CURRENT, Pin); + AddObjectToFlagUndoList(PCB_TYPE_PIN, element, Pin, Pin); if (!Delta) /* remove the thermals */ CLEAR_THERM(INDEXOFCURRENT, Pin); else ASSIGN_THERM(INDEXOFCURRENT, Delta, Pin); - AddObjectToClearPolyUndoList(PIN_TYPE, element, Pin, Pin, true); - ClearFromPolygon(PCB->Data, VIA_TYPE, CURRENT, Pin); + AddObjectToClearPolyUndoList(PCB_TYPE_PIN, element, Pin, Pin, true); + ClearFromPolygon(PCB->Data, PCB_TYPE_VIA, CURRENT, Pin); DrawPin(Pin); return Pin; } @@ -444,18 +444,18 @@ return (NULL); if (!TEST_FLAG(HOLEFLAG, Via) && value <= MAX_PINORVIASIZE && value >= MIN_PINORVIASIZE && value >= Via->DrillingHole + MIN_PINORVIACOPPER && value != Via->Thickness) { - AddObjectToSizeUndoList(VIA_TYPE, Via, Via, Via); + AddObjectToSizeUndoList(PCB_TYPE_VIA, Via, Via, Via); EraseVia(Via); r_delete_entry(PCB->Data->via_tree, (BoxType *) Via); - RestoreToPolygon(PCB->Data, PIN_TYPE, Via, Via); + RestoreToPolygon(PCB->Data, PCB_TYPE_PIN, Via, Via); if (Via->Mask) { - AddObjectToMaskSizeUndoList(VIA_TYPE, Via, Via, Via); + AddObjectToMaskSizeUndoList(PCB_TYPE_VIA, Via, Via, Via); Via->Mask += value - Via->Thickness; } Via->Thickness = value; SetPinBoundingBox(Via); r_insert_entry(PCB->Data->via_tree, (BoxType *) Via, 0); - ClearFromPolygon(PCB->Data, VIA_TYPE, Via, Via); + ClearFromPolygon(PCB->Data, PCB_TYPE_VIA, Via, Via); DrawVia(Via); return (Via); } @@ -475,15 +475,15 @@ if (value <= MAX_PINORVIASIZE && value >= MIN_PINORVIAHOLE && (TEST_FLAG(HOLEFLAG, Via) || value <= Via->Thickness - MIN_PINORVIACOPPER) && value != Via->DrillingHole) { - AddObjectTo2ndSizeUndoList(VIA_TYPE, Via, Via, Via); + AddObjectTo2ndSizeUndoList(PCB_TYPE_VIA, Via, Via, Via); EraseVia(Via); - RestoreToPolygon(PCB->Data, VIA_TYPE, Via, Via); + RestoreToPolygon(PCB->Data, PCB_TYPE_VIA, Via, Via); Via->DrillingHole = value; if (TEST_FLAG(HOLEFLAG, Via)) { - AddObjectToSizeUndoList(VIA_TYPE, Via, Via, Via); + AddObjectToSizeUndoList(PCB_TYPE_VIA, Via, Via, Via); Via->Thickness = value; } - ClearFromPolygon(PCB->Data, VIA_TYPE, Via, Via); + ClearFromPolygon(PCB->Data, PCB_TYPE_VIA, Via, Via); DrawVia(Via); return (Via); } @@ -509,14 +509,14 @@ value = PCB->Bloat * 2 + 2; if (Via->Clearance == value) return NULL; - RestoreToPolygon(PCB->Data, VIA_TYPE, Via, Via); - AddObjectToClearSizeUndoList(VIA_TYPE, Via, Via, Via); + RestoreToPolygon(PCB->Data, PCB_TYPE_VIA, Via, Via); + AddObjectToClearSizeUndoList(PCB_TYPE_VIA, Via, Via, Via); EraseVia(Via); r_delete_entry(PCB->Data->via_tree, (BoxType *) Via); Via->Clearance = value; SetPinBoundingBox(Via); r_insert_entry(PCB->Data->via_tree, (BoxType *) Via, 0); - ClearFromPolygon(PCB->Data, VIA_TYPE, Via, Via); + ClearFromPolygon(PCB->Data, PCB_TYPE_VIA, Via, Via); DrawVia(Via); Via->Element = NULL; return (Via); @@ -535,16 +535,16 @@ return (NULL); if (!TEST_FLAG(HOLEFLAG, Pin) && value <= MAX_PINORVIASIZE && value >= MIN_PINORVIASIZE && value >= Pin->DrillingHole + MIN_PINORVIACOPPER && value != Pin->Thickness) { - AddObjectToSizeUndoList(PIN_TYPE, Element, Pin, Pin); - AddObjectToMaskSizeUndoList(PIN_TYPE, Element, Pin, Pin); + AddObjectToSizeUndoList(PCB_TYPE_PIN, Element, Pin, Pin); + AddObjectToMaskSizeUndoList(PCB_TYPE_PIN, Element, Pin, Pin); ErasePin(Pin); r_delete_entry(PCB->Data->pin_tree, &Pin->BoundingBox); - RestoreToPolygon(PCB->Data, PIN_TYPE, Element, Pin); + RestoreToPolygon(PCB->Data, PCB_TYPE_PIN, Element, Pin); Pin->Mask += value - Pin->Thickness; Pin->Thickness = value; /* SetElementBB updates all associated rtrees */ SetElementBoundingBox(PCB->Data, Element, &PCB->Font); - ClearFromPolygon(PCB->Data, PIN_TYPE, Element, Pin); + ClearFromPolygon(PCB->Data, PCB_TYPE_PIN, Element, Pin); DrawPin(Pin); return (Pin); } @@ -570,14 +570,14 @@ value = PCB->Bloat * 2 + 2; if (Pin->Clearance == value) return NULL; - RestoreToPolygon(PCB->Data, PIN_TYPE, Element, Pin); - AddObjectToClearSizeUndoList(PIN_TYPE, Element, Pin, Pin); + RestoreToPolygon(PCB->Data, PCB_TYPE_PIN, Element, Pin); + AddObjectToClearSizeUndoList(PCB_TYPE_PIN, Element, Pin, Pin); ErasePin(Pin); r_delete_entry(PCB->Data->pin_tree, &Pin->BoundingBox); Pin->Clearance = value; /* SetElementBB updates all associated rtrees */ SetElementBoundingBox(PCB->Data, Element, &PCB->Font); - ClearFromPolygon(PCB->Data, PIN_TYPE, Element, Pin); + ClearFromPolygon(PCB->Data, PCB_TYPE_PIN, Element, Pin); DrawPin(Pin); return (Pin); } @@ -593,9 +593,9 @@ if (TEST_FLAG(LOCKFLAG, Pad)) return (NULL); if (value <= MAX_PADSIZE && value >= MIN_PADSIZE && value != Pad->Thickness) { - AddObjectToSizeUndoList(PAD_TYPE, Element, Pad, Pad); - AddObjectToMaskSizeUndoList(PAD_TYPE, Element, Pad, Pad); - RestoreToPolygon(PCB->Data, PAD_TYPE, Element, Pad); + AddObjectToSizeUndoList(PCB_TYPE_PAD, Element, Pad, Pad); + AddObjectToMaskSizeUndoList(PCB_TYPE_PAD, Element, Pad, Pad); + RestoreToPolygon(PCB->Data, PCB_TYPE_PAD, Element, Pad); ErasePad(Pad); r_delete_entry(PCB->Data->pad_tree, &Pad->BoundingBox); Pad->Mask += value - Pad->Thickness; @@ -602,7 +602,7 @@ Pad->Thickness = value; /* SetElementBB updates all associated rtrees */ SetElementBoundingBox(PCB->Data, Element, &PCB->Font); - ClearFromPolygon(PCB->Data, PAD_TYPE, Element, Pad); + ClearFromPolygon(PCB->Data, PCB_TYPE_PAD, Element, Pad); DrawPad(Pad); return (Pad); } @@ -628,14 +628,14 @@ value = PCB->Bloat * 2 + 2; if (value == Pad->Clearance) return NULL; - AddObjectToClearSizeUndoList(PAD_TYPE, Element, Pad, Pad); - RestoreToPolygon(PCB->Data, PAD_TYPE, Element, Pad); + AddObjectToClearSizeUndoList(PCB_TYPE_PAD, Element, Pad, Pad); + RestoreToPolygon(PCB->Data, PCB_TYPE_PAD, Element, Pad); ErasePad(Pad); r_delete_entry(PCB->Data->pad_tree, &Pad->BoundingBox); Pad->Clearance = value; /* SetElementBB updates all associated rtrees */ SetElementBoundingBox(PCB->Data, Element, &PCB->Font); - ClearFromPolygon(PCB->Data, PAD_TYPE, Element, Pad); + ClearFromPolygon(PCB->Data, PCB_TYPE_PAD, Element, Pad); DrawPad(Pad); return Pad; } @@ -658,15 +658,15 @@ value >= MIN_PINORVIAHOLE && (TEST_FLAG(HOLEFLAG, pin) || value <= pin->Thickness - MIN_PINORVIACOPPER) && value != pin->DrillingHole) { changed = true; - AddObjectTo2ndSizeUndoList(PIN_TYPE, Element, pin, pin); + AddObjectTo2ndSizeUndoList(PCB_TYPE_PIN, Element, pin, pin); ErasePin(pin); - RestoreToPolygon(PCB->Data, PIN_TYPE, Element, pin); + RestoreToPolygon(PCB->Data, PCB_TYPE_PIN, Element, pin); pin->DrillingHole = value; if (TEST_FLAG(HOLEFLAG, pin)) { - AddObjectToSizeUndoList(PIN_TYPE, Element, pin, pin); + AddObjectToSizeUndoList(PCB_TYPE_PIN, Element, pin, pin); pin->Thickness = value; } - ClearFromPolygon(PCB->Data, PIN_TYPE, Element, pin); + ClearFromPolygon(PCB->Data, PCB_TYPE_PIN, Element, pin); DrawPin(pin); } } @@ -693,15 +693,15 @@ value = (Absolute) ? Absolute : pin->DrillingHole + Delta; if (value <= MAX_PINORVIASIZE && value >= pin->DrillingHole + MIN_PINORVIACOPPER && value != pin->Thickness) { changed = true; - AddObjectToSizeUndoList(PIN_TYPE, Element, pin, pin); + AddObjectToSizeUndoList(PCB_TYPE_PIN, Element, pin, pin); ErasePin(pin); - RestoreToPolygon(PCB->Data, PIN_TYPE, Element, pin); + RestoreToPolygon(PCB->Data, PCB_TYPE_PIN, Element, pin); pin->Thickness = value; if (TEST_FLAG(HOLEFLAG, pin)) { - AddObjectToSizeUndoList(PIN_TYPE, Element, pin, pin); + AddObjectToSizeUndoList(PCB_TYPE_PIN, Element, pin, pin); pin->Thickness = value; } - ClearFromPolygon(PCB->Data, PIN_TYPE, Element, pin); + ClearFromPolygon(PCB->Data, PCB_TYPE_PIN, Element, pin); DrawPin(pin); } } @@ -730,15 +730,15 @@ value >= MIN_PINORVIAHOLE && (TEST_FLAG(HOLEFLAG, pin) || value <= pin->Thickness - MIN_PINORVIACOPPER) && value != pin->Clearance) { changed = true; - AddObjectToClearSizeUndoList(PIN_TYPE, Element, pin, pin); + AddObjectToClearSizeUndoList(PCB_TYPE_PIN, Element, pin, pin); ErasePin(pin); - RestoreToPolygon(PCB->Data, PIN_TYPE, Element, pin); + RestoreToPolygon(PCB->Data, PCB_TYPE_PIN, Element, pin); pin->Clearance = value; if (TEST_FLAG(HOLEFLAG, pin)) { - AddObjectToSizeUndoList(PIN_TYPE, Element, pin, pin); + AddObjectToSizeUndoList(PCB_TYPE_PIN, Element, pin, pin); pin->Thickness = value; } - ClearFromPolygon(PCB->Data, PIN_TYPE, Element, pin); + ClearFromPolygon(PCB->Data, PCB_TYPE_PIN, Element, pin); DrawPin(pin); } } @@ -749,19 +749,19 @@ value = (Absolute) ? Absolute : pad->Clearance + Delta; if (value <= MAX_PINORVIASIZE && value >= MIN_PINORVIAHOLE && value != pad->Clearance) { changed = true; - AddObjectToClearSizeUndoList(PAD_TYPE, Element, pad, pad); + AddObjectToClearSizeUndoList(PCB_TYPE_PAD, Element, pad, pad); ErasePad(pad); - RestoreToPolygon(PCB->Data, PAD_TYPE, Element, pad); + RestoreToPolygon(PCB->Data, PCB_TYPE_PAD, Element, pad); r_delete_entry(PCB->Data->pad_tree, &pad->BoundingBox); pad->Clearance = value; if (TEST_FLAG(HOLEFLAG, pad)) { - AddObjectToSizeUndoList(PAD_TYPE, Element, pad, pad); + AddObjectToSizeUndoList(PCB_TYPE_PAD, Element, pad, pad); pad->Thickness = value; } /* SetElementBB updates all associated rtrees */ SetElementBoundingBox(PCB->Data, Element, &PCB->Font); - ClearFromPolygon(PCB->Data, PAD_TYPE, Element, pad); + ClearFromPolygon(PCB->Data, PCB_TYPE_PAD, Element, pad); DrawPad(pad); } } @@ -786,15 +786,15 @@ if (value <= MAX_PINORVIASIZE && value >= MIN_PINORVIAHOLE && (TEST_FLAG(HOLEFLAG, Pin) || value <= Pin->Thickness - MIN_PINORVIACOPPER) && value != Pin->DrillingHole) { - AddObjectTo2ndSizeUndoList(PIN_TYPE, Element, Pin, Pin); + AddObjectTo2ndSizeUndoList(PCB_TYPE_PIN, Element, Pin, Pin); ErasePin(Pin); - RestoreToPolygon(PCB->Data, PIN_TYPE, Element, Pin); + RestoreToPolygon(PCB->Data, PCB_TYPE_PIN, Element, Pin); Pin->DrillingHole = value; if (TEST_FLAG(HOLEFLAG, Pin)) { - AddObjectToSizeUndoList(PIN_TYPE, Element, Pin, Pin); + AddObjectToSizeUndoList(PCB_TYPE_PIN, Element, Pin, Pin); Pin->Thickness = value; } - ClearFromPolygon(PCB->Data, PIN_TYPE, Element, Pin); + ClearFromPolygon(PCB->Data, PCB_TYPE_PIN, Element, Pin); DrawPin(Pin); return (Pin); } @@ -812,14 +812,14 @@ if (TEST_FLAG(LOCKFLAG, Line)) return (NULL); if (value <= MAX_LINESIZE && value >= MIN_LINESIZE && value != Line->Thickness) { - AddObjectToSizeUndoList(LINE_TYPE, Layer, Line, Line); + AddObjectToSizeUndoList(PCB_TYPE_LINE, Layer, Line, Line); EraseLine(Line); r_delete_entry(Layer->line_tree, (BoxTypePtr) Line); - RestoreToPolygon(PCB->Data, LINE_TYPE, Layer, Line); + RestoreToPolygon(PCB->Data, PCB_TYPE_LINE, Layer, Line); Line->Thickness = value; SetLineBoundingBox(Line); r_insert_entry(Layer->line_tree, (BoxTypePtr) Line, 0); - ClearFromPolygon(PCB->Data, LINE_TYPE, Layer, Line); + ClearFromPolygon(PCB->Data, PCB_TYPE_LINE, Layer, Line); DrawLine(Layer, Line); return (Line); } @@ -838,8 +838,8 @@ return (NULL); value = MIN(MAX_LINESIZE, MAX(value, PCB->Bloat * 2 + 2)); if (value != Line->Clearance) { - AddObjectToClearSizeUndoList(LINE_TYPE, Layer, Line, Line); - RestoreToPolygon(PCB->Data, LINE_TYPE, Layer, Line); + AddObjectToClearSizeUndoList(PCB_TYPE_LINE, Layer, Line, Line); + RestoreToPolygon(PCB->Data, PCB_TYPE_LINE, Layer, Line); EraseLine(Line); r_delete_entry(Layer->line_tree, (BoxTypePtr) Line); Line->Clearance = value; @@ -849,7 +849,7 @@ } SetLineBoundingBox(Line); r_insert_entry(Layer->line_tree, (BoxTypePtr) Line, 0); - ClearFromPolygon(PCB->Data, LINE_TYPE, Layer, Line); + ClearFromPolygon(PCB->Data, PCB_TYPE_LINE, Layer, Line); DrawLine(Layer, Line); return (Line); } @@ -884,14 +884,14 @@ if (TEST_FLAG(LOCKFLAG, Arc)) return (NULL); if (value <= MAX_LINESIZE && value >= MIN_LINESIZE && value != Arc->Thickness) { - AddObjectToSizeUndoList(ARC_TYPE, Layer, Arc, Arc); + AddObjectToSizeUndoList(PCB_TYPE_ARC, Layer, Arc, Arc); EraseArc(Arc); r_delete_entry(Layer->arc_tree, (BoxTypePtr) Arc); - RestoreToPolygon(PCB->Data, ARC_TYPE, Layer, Arc); + RestoreToPolygon(PCB->Data, PCB_TYPE_ARC, Layer, Arc); Arc->Thickness = value; SetArcBoundingBox(Arc); r_insert_entry(Layer->arc_tree, (BoxTypePtr) Arc, 0); - ClearFromPolygon(PCB->Data, ARC_TYPE, Layer, Arc); + ClearFromPolygon(PCB->Data, PCB_TYPE_ARC, Layer, Arc); DrawArc(Layer, Arc); return (Arc); } @@ -910,10 +910,10 @@ return (NULL); value = MIN(MAX_LINESIZE, MAX(value, PCB->Bloat * 2 + 2)); if (value != Arc->Clearance) { - AddObjectToClearSizeUndoList(ARC_TYPE, Layer, Arc, Arc); + AddObjectToClearSizeUndoList(PCB_TYPE_ARC, Layer, Arc, Arc); EraseArc(Arc); r_delete_entry(Layer->arc_tree, (BoxTypePtr) Arc); - RestoreToPolygon(PCB->Data, ARC_TYPE, Layer, Arc); + RestoreToPolygon(PCB->Data, PCB_TYPE_ARC, Layer, Arc); Arc->Clearance = value; if (Arc->Clearance == 0) { CLEAR_FLAG(CLEARLINEFLAG, Arc); @@ -921,7 +921,7 @@ } SetArcBoundingBox(Arc); r_insert_entry(Layer->arc_tree, (BoxTypePtr) Arc, 0); - ClearFromPolygon(PCB->Data, ARC_TYPE, Layer, Arc); + ClearFromPolygon(PCB->Data, PCB_TYPE_ARC, Layer, Arc); DrawArc(Layer, Arc); return (Arc); } @@ -940,14 +940,14 @@ if (TEST_FLAG(LOCKFLAG, Text)) return (NULL); if (value <= MAX_TEXTSCALE && value >= MIN_TEXTSCALE && value != Text->Scale) { - AddObjectToSizeUndoList(TEXT_TYPE, Layer, Text, Text); + AddObjectToSizeUndoList(PCB_TYPE_TEXT, Layer, Text, Text); EraseText(Layer, Text); r_delete_entry(Layer->text_tree, (BoxTypePtr) Text); - RestoreToPolygon(PCB->Data, TEXT_TYPE, Layer, Text); + RestoreToPolygon(PCB->Data, PCB_TYPE_TEXT, Layer, Text); Text->Scale = value; SetTextBoundingBox(&PCB->Font, Text); r_insert_entry(Layer->text_tree, (BoxTypePtr) Text, 0); - ClearFromPolygon(PCB->Data, TEXT_TYPE, Layer, Text); + ClearFromPolygon(PCB->Data, PCB_TYPE_TEXT, Layer, Text); DrawText(Layer, Text); return (Text); } @@ -971,7 +971,7 @@ { value = (Absolute) ? Absolute : line->Thickness + Delta; if (value <= MAX_LINESIZE && value >= MIN_LINESIZE && value != line->Thickness) { - AddObjectToSizeUndoList(ELEMENTLINE_TYPE, Element, line, line); + AddObjectToSizeUndoList(PCB_TYPE_ELEMENT_LINE, Element, line, line); line->Thickness = value; changed = true; } @@ -981,7 +981,7 @@ { value = (Absolute) ? Absolute : arc->Thickness + Delta; if (value <= MAX_LINESIZE && value >= MIN_LINESIZE && value != arc->Thickness) { - AddObjectToSizeUndoList(ELEMENTARC_TYPE, Element, arc, arc); + AddObjectToSizeUndoList(PCB_TYPE_ELEMENT_ARC, Element, arc, arc); arc->Thickness = value; changed = true; } @@ -1010,7 +1010,7 @@ EraseElementName(Element); ELEMENTTEXT_LOOP(Element); { - AddObjectToSizeUndoList(ELEMENTNAME_TYPE, Element, text, text); + AddObjectToSizeUndoList(PCB_TYPE_ELEMENT_NAME, Element, text, text); r_delete_entry(PCB->Data->name_tree[n], (BoxType *) text); text->Scale = value; SetTextBoundingBox(&PCB->Font, text); @@ -1187,13 +1187,13 @@ if (TEST_FLAG(LOCKFLAG, Text)) return (NULL); EraseText(Layer, Text); - RestoreToPolygon(PCB->Data, TEXT_TYPE, Layer, Text); + RestoreToPolygon(PCB->Data, PCB_TYPE_TEXT, Layer, Text); Text->TextString = NewName; /* calculate size of the bounding box */ SetTextBoundingBox(&PCB->Font, Text); r_insert_entry(Layer->text_tree, (BoxTypePtr) Text, 0); - ClearFromPolygon(PCB->Data, TEXT_TYPE, Layer, Text); + ClearFromPolygon(PCB->Data, PCB_TYPE_TEXT, Layer, Text); DrawText(Layer, Text); return (old); } @@ -1218,7 +1218,7 @@ if (TEST_FLAG(LOCKFLAG, Element)) return (false); EraseElement(Element); - AddObjectToMirrorUndoList(ELEMENT_TYPE, Element, Element, Element, yoff); + AddObjectToMirrorUndoList(PCB_TYPE_ELEMENT, Element, Element, Element, yoff); MirrorElementCoordinates(PCB->Data, Element, yoff); DrawElement(Element); return (true); @@ -1244,14 +1244,14 @@ return (NULL); EraseLine(Line); if (TEST_FLAG(CLEARLINEFLAG, Line)) { - AddObjectToClearPolyUndoList(LINE_TYPE, Layer, Line, Line, false); - RestoreToPolygon(PCB->Data, LINE_TYPE, Layer, Line); + AddObjectToClearPolyUndoList(PCB_TYPE_LINE, Layer, Line, Line, false); + RestoreToPolygon(PCB->Data, PCB_TYPE_LINE, Layer, Line); } - AddObjectToFlagUndoList(LINE_TYPE, Layer, Line, Line); + AddObjectToFlagUndoList(PCB_TYPE_LINE, Layer, Line, Line); TOGGLE_FLAG(CLEARLINEFLAG, Line); if (TEST_FLAG(CLEARLINEFLAG, Line)) { - AddObjectToClearPolyUndoList(LINE_TYPE, Layer, Line, Line, true); - ClearFromPolygon(PCB->Data, LINE_TYPE, Layer, Line); + AddObjectToClearPolyUndoList(PCB_TYPE_LINE, Layer, Line, Line, true); + ClearFromPolygon(PCB->Data, PCB_TYPE_LINE, Layer, Line); } DrawLine(Layer, Line); return (Line); @@ -1286,14 +1286,14 @@ return (NULL); EraseArc(Arc); if (TEST_FLAG(CLEARLINEFLAG, Arc)) { - RestoreToPolygon(PCB->Data, ARC_TYPE, Layer, Arc); - AddObjectToClearPolyUndoList(ARC_TYPE, Layer, Arc, Arc, false); + RestoreToPolygon(PCB->Data, PCB_TYPE_ARC, Layer, Arc); + AddObjectToClearPolyUndoList(PCB_TYPE_ARC, Layer, Arc, Arc, false); } - AddObjectToFlagUndoList(ARC_TYPE, Layer, Arc, Arc); + AddObjectToFlagUndoList(PCB_TYPE_ARC, Layer, Arc, Arc); TOGGLE_FLAG(CLEARLINEFLAG, Arc); if (TEST_FLAG(CLEARLINEFLAG, Arc)) { - ClearFromPolygon(PCB->Data, ARC_TYPE, Layer, Arc); - AddObjectToClearPolyUndoList(ARC_TYPE, Layer, Arc, Arc, true); + ClearFromPolygon(PCB->Data, PCB_TYPE_ARC, Layer, Arc); + AddObjectToClearPolyUndoList(PCB_TYPE_ARC, Layer, Arc, Arc, true); } DrawArc(Layer, Arc); return (Arc); @@ -1328,14 +1328,14 @@ return (NULL); EraseText(Layer, Text); if (TEST_FLAG(CLEARLINEFLAG, Text)) { - AddObjectToClearPolyUndoList(TEXT_TYPE, Layer, Text, Text, false); - RestoreToPolygon(PCB->Data, TEXT_TYPE, Layer, Text); + AddObjectToClearPolyUndoList(PCB_TYPE_TEXT, Layer, Text, Text, false); + RestoreToPolygon(PCB->Data, PCB_TYPE_TEXT, Layer, Text); } - AddObjectToFlagUndoList(LINE_TYPE, Layer, Text, Text); + AddObjectToFlagUndoList(PCB_TYPE_LINE, Layer, Text, Text); TOGGLE_FLAG(CLEARLINEFLAG, Text); if (TEST_FLAG(CLEARLINEFLAG, Text)) { - AddObjectToClearPolyUndoList(TEXT_TYPE, Layer, Text, Text, true); - ClearFromPolygon(PCB->Data, TEXT_TYPE, Layer, Text); + AddObjectToClearPolyUndoList(PCB_TYPE_TEXT, Layer, Text, Text, true); + ClearFromPolygon(PCB->Data, PCB_TYPE_TEXT, Layer, Text); } DrawText(Layer, Text); return (Text); @@ -1489,12 +1489,12 @@ if (TEST_FLAG(LOCKFLAG, Pad)) return (NULL); ErasePad(Pad); - AddObjectToClearPolyUndoList(PAD_TYPE, Element, Pad, Pad, false); - RestoreToPolygon(PCB->Data, PAD_TYPE, Element, Pad); - AddObjectToFlagUndoList(PAD_TYPE, Element, Pad, Pad); + AddObjectToClearPolyUndoList(PCB_TYPE_PAD, Element, Pad, Pad, false); + RestoreToPolygon(PCB->Data, PCB_TYPE_PAD, Element, Pad); + AddObjectToFlagUndoList(PCB_TYPE_PAD, Element, Pad, Pad); TOGGLE_FLAG(SQUAREFLAG, Pad); - AddObjectToClearPolyUndoList(PAD_TYPE, Element, Pad, Pad, true); - ClearFromPolygon(PCB->Data, PAD_TYPE, Element, Pad); + AddObjectToClearPolyUndoList(PCB_TYPE_PAD, Element, Pad, Pad, true); + ClearFromPolygon(PCB->Data, PCB_TYPE_PAD, Element, Pad); DrawPad(Pad); return (Pad); } @@ -1533,9 +1533,9 @@ if (TEST_FLAG(LOCKFLAG, Via)) return (NULL); EraseVia(Via); - AddObjectToClearPolyUndoList(VIA_TYPE, NULL, Via, Via, false); - RestoreToPolygon(PCB->Data, VIA_TYPE, NULL, Via); - AddObjectToFlagUndoList(VIA_TYPE, NULL, Via, Via); + AddObjectToClearPolyUndoList(PCB_TYPE_VIA, NULL, Via, Via, false); + RestoreToPolygon(PCB->Data, PCB_TYPE_VIA, NULL, Via); + AddObjectToFlagUndoList(PCB_TYPE_VIA, NULL, Via, Via); ASSIGN_SQUARE(Absolute, Via); if (Absolute == 0) CLEAR_FLAG(SQUAREFLAG, Via); @@ -1542,8 +1542,8 @@ else SET_FLAG(SQUAREFLAG, Via); SetPinBoundingBox(Via); - AddObjectToClearPolyUndoList(VIA_TYPE, NULL, Via, Via, true); - ClearFromPolygon(PCB->Data, VIA_TYPE, NULL, Via); + AddObjectToClearPolyUndoList(PCB_TYPE_VIA, NULL, Via, Via, true); + ClearFromPolygon(PCB->Data, PCB_TYPE_VIA, NULL, Via); DrawVia(Via); return (Via); } @@ -1556,9 +1556,9 @@ if (TEST_FLAG(LOCKFLAG, Pin)) return (NULL); ErasePin(Pin); - AddObjectToClearPolyUndoList(PIN_TYPE, Element, Pin, Pin, false); - RestoreToPolygon(PCB->Data, PIN_TYPE, Element, Pin); - AddObjectToFlagUndoList(PIN_TYPE, Element, Pin, Pin); + AddObjectToClearPolyUndoList(PCB_TYPE_PIN, Element, Pin, Pin, false); + RestoreToPolygon(PCB->Data, PCB_TYPE_PIN, Element, Pin); + AddObjectToFlagUndoList(PCB_TYPE_PIN, Element, Pin, Pin); ASSIGN_SQUARE(Absolute, Pin); if (Absolute == 0) CLEAR_FLAG(SQUAREFLAG, Pin); @@ -1565,8 +1565,8 @@ else SET_FLAG(SQUAREFLAG, Pin); SetPinBoundingBox(Pin); - AddObjectToClearPolyUndoList(PIN_TYPE, Element, Pin, Pin, true); - ClearFromPolygon(PCB->Data, PIN_TYPE, Element, Pin); + AddObjectToClearPolyUndoList(PCB_TYPE_PIN, Element, Pin, Pin, true); + ClearFromPolygon(PCB->Data, PCB_TYPE_PIN, Element, Pin); DrawPin(Pin); return (Pin); } @@ -1601,12 +1601,12 @@ if (TEST_FLAG(LOCKFLAG, Via)) return (NULL); EraseVia(Via); - AddObjectToClearPolyUndoList(VIA_TYPE, Via, Via, Via, false); - RestoreToPolygon(PCB->Data, VIA_TYPE, Via, Via); - AddObjectToFlagUndoList(VIA_TYPE, Via, Via, Via); + AddObjectToClearPolyUndoList(PCB_TYPE_VIA, Via, Via, Via, false); + RestoreToPolygon(PCB->Data, PCB_TYPE_VIA, Via, Via); + AddObjectToFlagUndoList(PCB_TYPE_VIA, Via, Via, Via); TOGGLE_FLAG(OCTAGONFLAG, Via); - AddObjectToClearPolyUndoList(VIA_TYPE, Via, Via, Via, true); - ClearFromPolygon(PCB->Data, VIA_TYPE, Via, Via); + AddObjectToClearPolyUndoList(PCB_TYPE_VIA, Via, Via, Via, true); + ClearFromPolygon(PCB->Data, PCB_TYPE_VIA, Via, Via); DrawVia(Via); return (Via); } @@ -1641,12 +1641,12 @@ if (TEST_FLAG(LOCKFLAG, Pin)) return (NULL); ErasePin(Pin); - AddObjectToClearPolyUndoList(PIN_TYPE, Element, Pin, Pin, false); - RestoreToPolygon(PCB->Data, PIN_TYPE, Element, Pin); - AddObjectToFlagUndoList(PIN_TYPE, Element, Pin, Pin); + AddObjectToClearPolyUndoList(PCB_TYPE_PIN, Element, Pin, Pin, false); + RestoreToPolygon(PCB->Data, PCB_TYPE_PIN, Element, Pin); + AddObjectToFlagUndoList(PCB_TYPE_PIN, Element, Pin, Pin); TOGGLE_FLAG(OCTAGONFLAG, Pin); - AddObjectToClearPolyUndoList(PIN_TYPE, Element, Pin, Pin, true); - ClearFromPolygon(PCB->Data, PIN_TYPE, Element, Pin); + AddObjectToClearPolyUndoList(PCB_TYPE_PIN, Element, Pin, Pin, true); + ClearFromPolygon(PCB->Data, PCB_TYPE_PIN, Element, Pin); DrawPin(Pin); return (Pin); } @@ -1681,10 +1681,10 @@ if (TEST_FLAG(LOCKFLAG, Via)) return (false); EraseVia(Via); - AddObjectToFlagUndoList(VIA_TYPE, Via, Via, Via); - AddObjectToMaskSizeUndoList(VIA_TYPE, Via, Via, Via); + AddObjectToFlagUndoList(PCB_TYPE_VIA, Via, Via, Via); + AddObjectToMaskSizeUndoList(PCB_TYPE_VIA, Via, Via, Via); r_delete_entry(PCB->Data->via_tree, (BoxType *) Via); - RestoreToPolygon(PCB->Data, VIA_TYPE, Via, Via); + RestoreToPolygon(PCB->Data, PCB_TYPE_VIA, Via, Via); TOGGLE_FLAG(HOLEFLAG, Via); if (TEST_FLAG(HOLEFLAG, Via)) { @@ -1703,7 +1703,7 @@ SetPinBoundingBox(Via); r_insert_entry(PCB->Data->via_tree, (BoxType *) Via, 0); - ClearFromPolygon(PCB->Data, VIA_TYPE, Via, Via); + ClearFromPolygon(PCB->Data, PCB_TYPE_VIA, Via, Via); DrawVia(Via); Draw(); return (true); @@ -1717,7 +1717,7 @@ if (TEST_FLAG(LOCKFLAG, Pad)) return (false); ErasePad(Pad); - AddObjectToFlagUndoList(PAD_TYPE, Pad, Pad, Pad); + AddObjectToFlagUndoList(PCB_TYPE_PAD, Pad, Pad, Pad); TOGGLE_FLAG(NOPASTEFLAG, Pad); DrawPad(Pad); Draw(); @@ -1731,8 +1731,8 @@ { if (TEST_FLAG(LOCKFLAG, Polygon)) return (NULL); - AddObjectToClearPolyUndoList(POLYGON_TYPE, Layer, Polygon, Polygon, true); - AddObjectToFlagUndoList(POLYGON_TYPE, Layer, Polygon, Polygon); + AddObjectToClearPolyUndoList(PCB_TYPE_POLYGON, Layer, Polygon, Polygon, true); + AddObjectToFlagUndoList(PCB_TYPE_POLYGON, Layer, Polygon, Polygon); TOGGLE_FLAG(CLEARPOLYFLAG, Polygon); InitClip(PCB->Data, Layer, Polygon); DrawPolygon(Layer, Polygon); @@ -2383,21 +2383,21 @@ char msg[513]; /* if passed an element name, make it an element reference instead */ - if (Type == ELEMENTNAME_TYPE) { - Type = ELEMENT_TYPE; + if (Type == PCB_TYPE_ELEMENT_NAME) { + Type = PCB_TYPE_ELEMENT; Ptr2 = Ptr1; Ptr3 = Ptr1; } switch (Type) { - case LINE_TYPE: + case PCB_TYPE_LINE: name = gui->prompt_for(_("Linename:"), EMPTY(((LineTypePtr) Ptr2)->Number)); break; - case VIA_TYPE: + case PCB_TYPE_VIA: name = gui->prompt_for(_("Vianame:"), EMPTY(((PinTypePtr) Ptr2)->Name)); break; - case PIN_TYPE: + case PCB_TYPE_PIN: if (pinnum) sprintf(msg, _("%s Pin Number:"), EMPTY(((PinTypePtr) Ptr2)->Number)); else @@ -2405,7 +2405,7 @@ name = gui->prompt_for(msg, EMPTY(((PinTypePtr) Ptr2)->Name)); break; - case PAD_TYPE: + case PCB_TYPE_PAD: if (pinnum) sprintf(msg, _("%s Pad Number:"), EMPTY(((PadTypePtr) Ptr2)->Number)); else @@ -2413,11 +2413,11 @@ name = gui->prompt_for(msg, EMPTY(((PadTypePtr) Ptr2)->Name)); break; - case TEXT_TYPE: + case PCB_TYPE_TEXT: name = gui->prompt_for(_("Enter text:"), EMPTY(((TextTypePtr) Ptr2)->TextString)); break; - case ELEMENT_TYPE: + case PCB_TYPE_ELEMENT: name = gui->prompt_for(_("Elementname:"), EMPTY(ELEMENT_NAME(PCB, (ElementTypePtr) Ptr2))); break; } @@ -2479,7 +2479,7 @@ if (value == Pad->Mask && Absolute == 0) value = Pad->Thickness; if (value != Pad->Mask) { - AddObjectToMaskSizeUndoList(PAD_TYPE, Element, Pad, Pad); + AddObjectToMaskSizeUndoList(PCB_TYPE_PAD, Element, Pad, Pad); ErasePad(Pad); r_delete_entry(PCB->Data->pad_tree, &Pad->BoundingBox); Pad->Mask = value; @@ -2502,7 +2502,7 @@ if (value == Pin->Mask && Absolute == 0) value = Pin->Thickness; if (value != Pin->Mask) { - AddObjectToMaskSizeUndoList(PIN_TYPE, Element, Pin, Pin); + AddObjectToMaskSizeUndoList(PCB_TYPE_PIN, Element, Pin, Pin); ErasePin(Pin); r_delete_entry(PCB->Data->pin_tree, &Pin->BoundingBox); Pin->Mask = value; @@ -2524,7 +2524,7 @@ value = (Absolute) ? Absolute : Via->Mask + Delta; value = MAX(value, 0); if (value != Via->Mask) { - AddObjectToMaskSizeUndoList(VIA_TYPE, Via, Via, Via); + AddObjectToMaskSizeUndoList(PCB_TYPE_VIA, Via, Via, Via); EraseVia(Via); r_delete_entry(PCB->Data->via_tree, &Via->BoundingBox); Via->Mask = value; Index: trunk/src/change.h =================================================================== --- trunk/src/change.h (revision 2502) +++ trunk/src/change.h (revision 2503) @@ -35,36 +35,36 @@ * some defines */ #define CHANGENAME_TYPES \ - (VIA_TYPE | PIN_TYPE | PAD_TYPE | TEXT_TYPE | ELEMENT_TYPE | ELEMENTNAME_TYPE | LINE_TYPE) + (PCB_TYPE_VIA | PCB_TYPE_PIN | PCB_TYPE_PAD | PCB_TYPE_TEXT | PCB_TYPE_ELEMENT | PCB_TYPE_ELEMENT_NAME | PCB_TYPE_LINE) #define CHANGESIZE_TYPES \ - (POLYGON_TYPE | VIA_TYPE | PIN_TYPE | PAD_TYPE | LINE_TYPE | \ - ARC_TYPE | TEXT_TYPE | ELEMENTNAME_TYPE | ELEMENT_TYPE) + (PCB_TYPE_POLYGON | PCB_TYPE_VIA | PCB_TYPE_PIN | PCB_TYPE_PAD | PCB_TYPE_LINE | \ + PCB_TYPE_ARC | PCB_TYPE_TEXT | PCB_TYPE_ELEMENT_NAME | PCB_TYPE_ELEMENT) #define CHANGE2NDSIZE_TYPES \ - (VIA_TYPE | PIN_TYPE | ELEMENT_TYPE) + (PCB_TYPE_VIA | PCB_TYPE_PIN | PCB_TYPE_ELEMENT) /* We include polygons here only to inform the user not to do it that way. */ #define CHANGECLEARSIZE_TYPES \ - (PIN_TYPE | PAD_TYPE | VIA_TYPE | LINE_TYPE | ARC_TYPE | POLYGON_TYPE) + (PCB_TYPE_PIN | PCB_TYPE_PAD | PCB_TYPE_VIA | PCB_TYPE_LINE | PCB_TYPE_ARC | PCB_TYPE_POLYGON) #define CHANGENONETLIST_TYPES \ - (ELEMENT_TYPE) + (PCB_TYPE_ELEMENT) #define CHANGESQUARE_TYPES \ - (ELEMENT_TYPE | PIN_TYPE | PAD_TYPE | VIA_TYPE) + (PCB_TYPE_ELEMENT | PCB_TYPE_PIN | PCB_TYPE_PAD | PCB_TYPE_VIA) #define CHANGEOCTAGON_TYPES \ - (ELEMENT_TYPE | PIN_TYPE | VIA_TYPE) + (PCB_TYPE_ELEMENT | PCB_TYPE_PIN | PCB_TYPE_VIA) #define CHANGEJOIN_TYPES \ - (ARC_TYPE | LINE_TYPE | TEXT_TYPE) + (PCB_TYPE_ARC | PCB_TYPE_LINE | PCB_TYPE_TEXT) #define CHANGETHERMAL_TYPES \ - (PIN_TYPE | VIA_TYPE) + (PCB_TYPE_PIN | PCB_TYPE_VIA) #define CHANGEMASKSIZE_TYPES \ - (PIN_TYPE | VIA_TYPE | PAD_TYPE) + (PCB_TYPE_PIN | PCB_TYPE_VIA | PCB_TYPE_PAD) bool ChangeLayoutName(char *); bool ChangeLayerName(LayerTypePtr, char *); Index: trunk/src/change_act.c =================================================================== --- trunk/src/change_act.c (revision 2502) +++ trunk/src/change_act.c (revision 2503) @@ -88,7 +88,7 @@ } if (strcmp(argv[1], "style") == 0) { - if ((type == NO_TYPE) || (type == POLYGON_TYPE)) /* workaround: SearchScreen(CHANGECLEARSIZE_TYPES) wouldn't return elements */ + if ((type == PCB_TYPE_NONE) || (type == PCB_TYPE_POLYGON)) /* workaround: SearchScreen(CHANGECLEARSIZE_TYPES) wouldn't return elements */ type = SearchScreen(x, y, CHANGE2NDSIZE_TYPES, &ptr1, &ptr2, &ptr3); if (get_style_size(funcid, &value, type, 2) != 0) return 1; @@ -100,29 +100,29 @@ switch (funchash_get(function, NULL)) { case F_Object: { - if (type != NO_TYPE) + if (type != PCB_TYPE_NONE) if (ChangeObjectClearSize(type, ptr1, ptr2, ptr3, value, absolute)) SetChangedFlag(true); break; } case F_SelectedVias: - if (ChangeSelectedClearSize(VIA_TYPE, value, absolute)) + if (ChangeSelectedClearSize(PCB_TYPE_VIA, value, absolute)) SetChangedFlag(true); break; case F_SelectedPads: - if (ChangeSelectedClearSize(PAD_TYPE, value, absolute)) + if (ChangeSelectedClearSize(PCB_TYPE_PAD, value, absolute)) SetChangedFlag(true); break; case F_SelectedPins: - if (ChangeSelectedClearSize(PIN_TYPE, value, absolute)) + if (ChangeSelectedClearSize(PCB_TYPE_PIN, value, absolute)) SetChangedFlag(true); break; case F_SelectedLines: - if (ChangeSelectedClearSize(LINE_TYPE, value, absolute)) + if (ChangeSelectedClearSize(PCB_TYPE_LINE, value, absolute)) SetChangedFlag(true); break; case F_SelectedArcs: - if (ChangeSelectedClearSize(ARC_TYPE, value, absolute)) + if (ChangeSelectedClearSize(PCB_TYPE_ARC, value, absolute)) SetChangedFlag(true); break; case F_Selected: @@ -197,7 +197,7 @@ int type; void *ptr1, *ptr2, *ptr3; - if ((type = SearchScreen(Crosshair.X, Crosshair.Y, CHANGESIZE_TYPES, &ptr1, &ptr2, &ptr3)) != NO_TYPE) + if ((type = SearchScreen(Crosshair.X, Crosshair.Y, CHANGESIZE_TYPES, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) if (TEST_FLAG(LOCKFLAG, (PinTypePtr) ptr2)) Message(_("Sorry, the object is locked\n")); if (set_object(type, ptr1, ptr2, ptr3)) @@ -206,37 +206,37 @@ } case F_SelectedVias: - if (set_selected(VIA_TYPE)) + if (set_selected(PCB_TYPE_VIA)) SetChangedFlag(true); break; case F_SelectedPins: - if (set_selected(PIN_TYPE)) + if (set_selected(PCB_TYPE_PIN)) SetChangedFlag(true); break; case F_SelectedPads: - if (set_selected(PAD_TYPE)) + if (set_selected(PCB_TYPE_PAD)) SetChangedFlag(true); break; case F_SelectedLines: - if (set_selected(LINE_TYPE)) + if (set_selected(PCB_TYPE_LINE)) SetChangedFlag(true); break; case F_SelectedTexts: - if (set_selected(TEXT_TYPE)) + if (set_selected(PCB_TYPE_TEXT)) SetChangedFlag(true); break; case F_SelectedNames: - if (set_selected(ELEMENTNAME_TYPE)) + if (set_selected(PCB_TYPE_ELEMENT_NAME)) SetChangedFlag(true); break; case F_SelectedElements: - if (set_selected(ELEMENT_TYPE)) + if (set_selected(PCB_TYPE_ELEMENT)) SetChangedFlag(true); break; @@ -273,7 +273,7 @@ void *ptr1, *ptr2, *ptr3; gui->get_coords(_("Select an Object"), &x, &y); - if ((type = SearchScreen(x, y, VIA_TYPE, &ptr1, &ptr2, &ptr3)) != NO_TYPE && ChangeHole((PinTypePtr) ptr3)) + if ((type = SearchScreen(x, y, PCB_TYPE_VIA, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE && ChangeHole((PinTypePtr) ptr3)) IncrementUndoSerialNumber(); break; } @@ -315,7 +315,7 @@ void *ptr1, *ptr2, *ptr3; gui->get_coords(_("Select an Object"), &x, &y); - if ((type = SearchScreen(x, y, PAD_TYPE, &ptr1, &ptr2, &ptr3)) != NO_TYPE && ChangePaste((PadTypePtr) ptr3)) + if ((type = SearchScreen(x, y, PCB_TYPE_PAD, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE && ChangePaste((PadTypePtr) ptr3)) IncrementUndoSerialNumber(); break; } @@ -409,7 +409,7 @@ switch (funcid) { case F_Object: { - if (type != NO_TYPE) + if (type != PCB_TYPE_NONE) if (TEST_FLAG(LOCKFLAG, (PinTypePtr) ptr2)) Message(_("Sorry, the object is locked\n")); if (tostyle) { @@ -423,42 +423,42 @@ break; } case F_SelectedVias: - if (ChangeSelectedSize(VIA_TYPE, value, absolute)) + if (ChangeSelectedSize(PCB_TYPE_VIA, value, absolute)) SetChangedFlag(true); break; case F_SelectedPins: - if (ChangeSelectedSize(PIN_TYPE, value, absolute)) + if (ChangeSelectedSize(PCB_TYPE_PIN, value, absolute)) SetChangedFlag(true); break; case F_SelectedPads: - if (ChangeSelectedSize(PAD_TYPE, value, absolute)) + if (ChangeSelectedSize(PCB_TYPE_PAD, value, absolute)) SetChangedFlag(true); break; case F_SelectedArcs: - if (ChangeSelectedSize(ARC_TYPE, value, absolute)) + if (ChangeSelectedSize(PCB_TYPE_ARC, value, absolute)) SetChangedFlag(true); break; case F_SelectedLines: - if (ChangeSelectedSize(LINE_TYPE, value, absolute)) + if (ChangeSelectedSize(PCB_TYPE_LINE, value, absolute)) SetChangedFlag(true); break; case F_SelectedTexts: - if (ChangeSelectedSize(TEXT_TYPE, value, absolute)) + if (ChangeSelectedSize(PCB_TYPE_TEXT, value, absolute)) SetChangedFlag(true); break; case F_SelectedNames: - if (ChangeSelectedSize(ELEMENTNAME_TYPE, value, absolute)) + if (ChangeSelectedSize(PCB_TYPE_ELEMENT_NAME, value, absolute)) SetChangedFlag(true); break; case F_SelectedElements: - if (ChangeSelectedSize(ELEMENT_TYPE, value, absolute)) + if (ChangeSelectedSize(PCB_TYPE_ELEMENT, value, absolute)) SetChangedFlag(true); break; @@ -514,7 +514,7 @@ case F_Object: { - if (type != NO_TYPE) + if (type != PCB_TYPE_NONE) if (ChangeObject2ndSize(type, ptr1, ptr2, ptr3, value, absolute, true)) SetChangedFlag(true); break; @@ -521,17 +521,17 @@ } case F_SelectedVias: - if (ChangeSelected2ndSize(VIA_TYPE, value, absolute)) + if (ChangeSelected2ndSize(PCB_TYPE_VIA, value, absolute)) SetChangedFlag(true); break; case F_SelectedPins: - if (ChangeSelected2ndSize(PIN_TYPE, value, absolute)) + if (ChangeSelected2ndSize(PCB_TYPE_PIN, value, absolute)) SetChangedFlag(true); break; case F_Selected: case F_SelectedObjects: - if (ChangeSelected2ndSize(PIN_TYPES, value, absolute)) + if (ChangeSelected2ndSize(PCB_TYPEMASK_PIN, value, absolute)) SetChangedFlag(true); break; } @@ -576,7 +576,7 @@ PIN_LOOP(element); { if (NSTRCMP(pinnum, pin->Number) == 0) { - AddObjectToChangeNameUndoList(PIN_TYPE, NULL, NULL, pin, pin->Name); + AddObjectToChangeNameUndoList(PCB_TYPE_PIN, NULL, NULL, pin, pin->Name); /* * Note: we can't free() pin->Name first because * it is used in the undo list @@ -591,7 +591,7 @@ PAD_LOOP(element); { if (NSTRCMP(pinnum, pad->Number) == 0) { - AddObjectToChangeNameUndoList(PAD_TYPE, NULL, NULL, pad, pad->Name); + AddObjectToChangeNameUndoList(PCB_TYPE_PAD, NULL, NULL, pad, pad->Name); /* * Note: we can't free() pad->Name first because * it is used in the undo list @@ -660,7 +660,7 @@ void *ptr1, *ptr2, *ptr3; gui->get_coords(_("Select an Object"), &x, &y); - if ((type = SearchScreen(x, y, CHANGENAME_TYPES, &ptr1, &ptr2, &ptr3)) != NO_TYPE) { + if ((type = SearchScreen(x, y, CHANGENAME_TYPES, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) { SaveUndoSerialNumber(); if ((pinnums != NULL) && (strcasecmp(pinnums, "Number") == 0)) pinnum = 1; @@ -668,7 +668,7 @@ pinnum = 0; if (QueryInputAndChangeObjectName(type, ptr1, ptr2, ptr3, pinnum)) { SetChangedFlag(true); - if (type == ELEMENT_TYPE) { + if (type == PCB_TYPE_ELEMENT) { RubberbandTypePtr ptr; int i; @@ -679,7 +679,7 @@ for (i = 0; i < Crosshair.AttachedObject.RubberbandN; i++, ptr++) { if (PCB->RatOn) EraseRat((RatTypePtr) ptr->Line); - MoveObjectToRemoveUndoList(RATLINE_TYPE, ptr->Line, ptr->Line, ptr->Line); + MoveObjectToRemoveUndoList(PCB_TYPE_RATLINE, ptr->Line, ptr->Line, ptr->Line); } IncrementUndoSerialNumber(); Draw(); @@ -737,7 +737,7 @@ void *ptr1, *ptr2, *ptr3; gui->get_coords(_("Select an Object"), &x, &y); - if ((type = SearchScreen(x, y, CHANGEJOIN_TYPES, &ptr1, &ptr2, &ptr3)) != NO_TYPE) + if ((type = SearchScreen(x, y, CHANGEJOIN_TYPES, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) if (ChangeObjectJoin(type, ptr1, ptr2, ptr3)) SetChangedFlag(true); break; @@ -744,12 +744,12 @@ } case F_SelectedLines: - if (ChangeSelectedJoin(LINE_TYPE)) + if (ChangeSelectedJoin(PCB_TYPE_LINE)) SetChangedFlag(true); break; case F_SelectedArcs: - if (ChangeSelectedJoin(ARC_TYPE)) + if (ChangeSelectedJoin(PCB_TYPE_ARC)) SetChangedFlag(true); break; @@ -800,7 +800,7 @@ case F_SelectedElements: case F_Selected: case F_SelectedObjects: - if (ChangeSelectedNonetlist(ELEMENT_TYPE)) + if (ChangeSelectedNonetlist(PCB_TYPE_ELEMENT)) SetChangedFlag(true); break; } @@ -845,7 +845,7 @@ qstyle++; if (qstyle > 17) qstyle = 0; - if (type != NO_TYPE) + if (type != PCB_TYPE_NONE) if (ChangeObjectSquare(type, ptr1, ptr2, ptr3, qstyle)) SetChangedFlag(true); } @@ -853,18 +853,18 @@ } case F_SelectedElements: - if (ChangeSelectedSquare(ELEMENT_TYPE)) + if (ChangeSelectedSquare(PCB_TYPE_ELEMENT)) SetChangedFlag(true); break; case F_SelectedPins: - if (ChangeSelectedSquare(PIN_TYPE | PAD_TYPE)) + if (ChangeSelectedSquare(PCB_TYPE_PIN | PCB_TYPE_PAD)) SetChangedFlag(true); break; case F_Selected: case F_SelectedObjects: - if (ChangeSelectedSquare(PIN_TYPE | PAD_TYPE)) + if (ChangeSelectedSquare(PCB_TYPE_PIN | PCB_TYPE_PAD)) SetChangedFlag(true); break; } @@ -898,7 +898,7 @@ void *ptr1, *ptr2, *ptr3; gui->get_coords(_("Select an Object"), &x, &y); - if ((type = SearchScreen(x, y, CHANGESQUARE_TYPES, &ptr1, &ptr2, &ptr3)) != NO_TYPE) + if ((type = SearchScreen(x, y, CHANGESQUARE_TYPES, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) if (SetObjectSquare(type, ptr1, ptr2, ptr3)) SetChangedFlag(true); break; @@ -905,18 +905,18 @@ } case F_SelectedElements: - if (SetSelectedSquare(ELEMENT_TYPE)) + if (SetSelectedSquare(PCB_TYPE_ELEMENT)) SetChangedFlag(true); break; case F_SelectedPins: - if (SetSelectedSquare(PIN_TYPE | PAD_TYPE)) + if (SetSelectedSquare(PCB_TYPE_PIN | PCB_TYPE_PAD)) SetChangedFlag(true); break; case F_Selected: case F_SelectedObjects: - if (SetSelectedSquare(PIN_TYPE | PAD_TYPE)) + if (SetSelectedSquare(PCB_TYPE_PIN | PCB_TYPE_PAD)) SetChangedFlag(true); break; } @@ -950,7 +950,7 @@ void *ptr1, *ptr2, *ptr3; gui->get_coords(_("Select an Object"), &x, &y); - if ((type = SearchScreen(x, y, CHANGESQUARE_TYPES, &ptr1, &ptr2, &ptr3)) != NO_TYPE) + if ((type = SearchScreen(x, y, CHANGESQUARE_TYPES, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) if (ClrObjectSquare(type, ptr1, ptr2, ptr3)) SetChangedFlag(true); break; @@ -957,18 +957,18 @@ } case F_SelectedElements: - if (ClrSelectedSquare(ELEMENT_TYPE)) + if (ClrSelectedSquare(PCB_TYPE_ELEMENT)) SetChangedFlag(true); break; case F_SelectedPins: - if (ClrSelectedSquare(PIN_TYPE | PAD_TYPE)) + if (ClrSelectedSquare(PCB_TYPE_PIN | PCB_TYPE_PAD)) SetChangedFlag(true); break; case F_Selected: case F_SelectedObjects: - if (ClrSelectedSquare(PIN_TYPE | PAD_TYPE)) + if (ClrSelectedSquare(PCB_TYPE_PIN | PCB_TYPE_PAD)) SetChangedFlag(true); break; } @@ -1001,7 +1001,7 @@ void *ptr1, *ptr2, *ptr3; gui->get_coords(_("Select an Object"), &x, &y); - if ((type = SearchScreen(x, y, CHANGEOCTAGON_TYPES, &ptr1, &ptr2, &ptr3)) != NO_TYPE) + if ((type = SearchScreen(x, y, CHANGEOCTAGON_TYPES, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) if (ChangeObjectOctagon(type, ptr1, ptr2, ptr3)) SetChangedFlag(true); break; @@ -1008,23 +1008,23 @@ } case F_SelectedElements: - if (ChangeSelectedOctagon(ELEMENT_TYPE)) + if (ChangeSelectedOctagon(PCB_TYPE_ELEMENT)) SetChangedFlag(true); break; case F_SelectedPins: - if (ChangeSelectedOctagon(PIN_TYPE)) + if (ChangeSelectedOctagon(PCB_TYPE_PIN)) SetChangedFlag(true); break; case F_SelectedVias: - if (ChangeSelectedOctagon(VIA_TYPE)) + if (ChangeSelectedOctagon(PCB_TYPE_VIA)) SetChangedFlag(true); break; case F_Selected: case F_SelectedObjects: - if (ChangeSelectedOctagon(PIN_TYPES)) + if (ChangeSelectedOctagon(PCB_TYPEMASK_PIN)) SetChangedFlag(true); break; } @@ -1056,7 +1056,7 @@ void *ptr1, *ptr2, *ptr3; gui->get_coords(_("Select an Object"), &x, &y); - if ((type = SearchScreen(x, y, CHANGEOCTAGON_TYPES, &ptr1, &ptr2, &ptr3)) != NO_TYPE) + if ((type = SearchScreen(x, y, CHANGEOCTAGON_TYPES, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) if (SetObjectOctagon(type, ptr1, ptr2, ptr3)) SetChangedFlag(true); break; @@ -1063,23 +1063,23 @@ } case F_SelectedElements: - if (SetSelectedOctagon(ELEMENT_TYPE)) + if (SetSelectedOctagon(PCB_TYPE_ELEMENT)) SetChangedFlag(true); break; case F_SelectedPins: - if (SetSelectedOctagon(PIN_TYPE)) + if (SetSelectedOctagon(PCB_TYPE_PIN)) SetChangedFlag(true); break; case F_SelectedVias: - if (SetSelectedOctagon(VIA_TYPE)) + if (SetSelectedOctagon(PCB_TYPE_VIA)) SetChangedFlag(true); break; case F_Selected: case F_SelectedObjects: - if (SetSelectedOctagon(PIN_TYPES)) + if (SetSelectedOctagon(PCB_TYPEMASK_PIN)) SetChangedFlag(true); break; } @@ -1112,7 +1112,7 @@ void *ptr1, *ptr2, *ptr3; gui->get_coords(_("Select an Object"), &x, &y); - if ((type = SearchScreen(Crosshair.X, Crosshair.Y, CHANGEOCTAGON_TYPES, &ptr1, &ptr2, &ptr3)) != NO_TYPE) + if ((type = SearchScreen(Crosshair.X, Crosshair.Y, CHANGEOCTAGON_TYPES, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) if (ClrObjectOctagon(type, ptr1, ptr2, ptr3)) SetChangedFlag(true); break; @@ -1119,23 +1119,23 @@ } case F_SelectedElements: - if (ClrSelectedOctagon(ELEMENT_TYPE)) + if (ClrSelectedOctagon(PCB_TYPE_ELEMENT)) SetChangedFlag(true); break; case F_SelectedPins: - if (ClrSelectedOctagon(PIN_TYPE)) + if (ClrSelectedOctagon(PCB_TYPE_PIN)) SetChangedFlag(true); break; case F_SelectedVias: - if (ClrSelectedOctagon(VIA_TYPE)) + if (ClrSelectedOctagon(PCB_TYPE_VIA)) SetChangedFlag(true); break; case F_Selected: case F_SelectedObjects: - if (ClrSelectedOctagon(PIN_TYPES)) + if (ClrSelectedOctagon(PCB_TYPEMASK_PIN)) SetChangedFlag(true); break; } @@ -1188,7 +1188,7 @@ if (absolute) switch (funchash_get(function, NULL)) { case F_Object: - if ((type = SearchScreen(Crosshair.X, Crosshair.Y, CHANGETHERMAL_TYPES, &ptr1, &ptr2, &ptr3)) != NO_TYPE) { + if ((type = SearchScreen(Crosshair.X, Crosshair.Y, CHANGETHERMAL_TYPES, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) { ChangeObjectThermal(type, ptr1, ptr2, ptr3, kind); IncrementUndoSerialNumber(); Draw(); @@ -1195,10 +1195,10 @@ } break; case F_SelectedPins: - ChangeSelectedThermals(PIN_TYPE, kind); + ChangeSelectedThermals(PCB_TYPE_PIN, kind); break; case F_SelectedVias: - ChangeSelectedThermals(VIA_TYPE, kind); + ChangeSelectedThermals(PCB_TYPE_VIA, kind); break; case F_Selected: case F_SelectedElements: Index: trunk/src/const.h =================================================================== --- trunk/src/const.h (revision 2502) +++ trunk/src/const.h (revision 2503) @@ -214,31 +214,31 @@ * object types (bitfield) */ typedef enum { - NO_TYPE = 0x00000, /* special: no object */ - VIA_TYPE = 0x00001, - ELEMENT_TYPE = 0x00002, - LINE_TYPE = 0x00004, - POLYGON_TYPE = 0x00008, - TEXT_TYPE = 0x00010, - RATLINE_TYPE = 0x00020, + PCB_TYPE_NONE = 0x00000, /* special: no object */ + PCB_TYPE_VIA = 0x00001, + PCB_TYPE_ELEMENT = 0x00002, + PCB_TYPE_LINE = 0x00004, + PCB_TYPE_POLYGON = 0x00008, + PCB_TYPE_TEXT = 0x00010, + PCB_TYPE_RATLINE = 0x00020, - PIN_TYPE = 0x00100, /* objects that are part */ - PAD_TYPE = 0x00200, /* 'pin' of SMD element */ - ELEMENTNAME_TYPE = 0x00400, /* of others */ - POLYGONPOINT_TYPE = 0x00800, - LINEPOINT_TYPE = 0x01000, - ELEMENTLINE_TYPE = 0x02000, - ARC_TYPE = 0x04000, - ELEMENTARC_TYPE = 0x08000, + PCB_TYPE_PIN = 0x00100, /* objects that are part */ + PCB_TYPE_PAD = 0x00200, /* 'pin' of SMD element */ + PCB_TYPE_ELEMENT_NAME = 0x00400, /* of others */ + PCB_TYPE_POLYGON_POINT = 0x00800, + PCB_TYPE_LINE_POINT = 0x01000, + PCB_TYPE_ELEMENT_LINE = 0x02000, + PCB_TYPE_ARC = 0x04000, + PCB_TYPE_ELEMENT_ARC = 0x08000, - LOCKED_TYPE = 0x10000, /* used to tell search to include locked items. */ - NET_TYPE = 0x20000, /* used to select whole net. */ + PCB_TYPE_LOCKED = 0x10000, /* used to tell search to include locked items. */ + PCB_TYPE_NET = 0x20000, /* used to select whole net. */ /* groups/properties */ - PIN_TYPES = (VIA_TYPE | PIN_TYPE), - LOCK_TYPES = (VIA_TYPE | LINE_TYPE | ARC_TYPE | POLYGON_TYPE | ELEMENT_TYPE | TEXT_TYPE | ELEMENTNAME_TYPE | LOCKED_TYPE), + PCB_TYPEMASK_PIN = (PCB_TYPE_VIA | PCB_TYPE_PIN), + PCB_TYPEMASK_LOCK = (PCB_TYPE_VIA | PCB_TYPE_LINE | PCB_TYPE_ARC | PCB_TYPE_POLYGON | PCB_TYPE_ELEMENT | PCB_TYPE_TEXT | PCB_TYPE_ELEMENT_NAME | PCB_TYPE_LOCKED), - ALL_TYPES = (~0) /* all bits set */ + PCB_TYPEMASK_ALL = (~0) /* all bits set */ } pcb_obj_type_t; #endif Index: trunk/src/copy.c =================================================================== --- trunk/src/copy.c (revision 2502) +++ trunk/src/copy.c (revision 2503) @@ -168,7 +168,7 @@ if (!via) return (via); DrawVia(via); - AddObjectToCreateUndoList(VIA_TYPE, via, via, via); + AddObjectToCreateUndoList(PCB_TYPE_VIA, via, via, via); return (via); } @@ -188,7 +188,7 @@ if (Line->Number) line->Number = strdup(Line->Number); DrawLine(Layer, line); - AddObjectToCreateUndoList(LINE_TYPE, Layer, line, line); + AddObjectToCreateUndoList(PCB_TYPE_LINE, Layer, line, line); return (line); } @@ -205,7 +205,7 @@ if (!arc) return (arc); DrawArc(Layer, arc); - AddObjectToCreateUndoList(ARC_TYPE, Layer, arc, arc); + AddObjectToCreateUndoList(PCB_TYPE_ARC, Layer, arc, arc); return (arc); } @@ -219,7 +219,7 @@ text = CreateNewText(Layer, &PCB->Font, Text->X + DeltaX, Text->Y + DeltaY, Text->Direction, Text->Scale, Text->TextString, MaskFlags(Text->Flags, FOUNDFLAG)); DrawText(Layer, text); - AddObjectToCreateUndoList(TEXT_TYPE, Layer, text, text); + AddObjectToCreateUndoList(PCB_TYPE_TEXT, Layer, text, text); return (text); } @@ -238,7 +238,7 @@ r_insert_entry(Layer->polygon_tree, (BoxTypePtr) polygon, 0); InitClip(PCB->Data, Layer, polygon); DrawPolygon(Layer, polygon); - AddObjectToCreateUndoList(POLYGON_TYPE, Layer, polygon, polygon); + AddObjectToCreateUndoList(PCB_TYPE_POLYGON, Layer, polygon, polygon); return (polygon); } @@ -258,7 +258,7 @@ DeltaY); /* this call clears the polygons */ - AddObjectToCreateUndoList(ELEMENT_TYPE, element, element, element); + AddObjectToCreateUndoList(PCB_TYPE_ELEMENT, element, element, element); if (PCB->ElementOn && (FRONT(element) || PCB->InvisibleObjectsOn)) { DrawElementName(element); DrawElementPackage(element); Index: trunk/src/copy.h =================================================================== --- trunk/src/copy.h (revision 2502) +++ trunk/src/copy.h (revision 2503) @@ -35,8 +35,8 @@ * some defines */ #define COPY_TYPES \ - (VIA_TYPE | LINE_TYPE | TEXT_TYPE | \ - ELEMENT_TYPE | ELEMENTNAME_TYPE | POLYGON_TYPE | ARC_TYPE) + (PCB_TYPE_VIA | PCB_TYPE_LINE | PCB_TYPE_TEXT | \ + PCB_TYPE_ELEMENT | PCB_TYPE_ELEMENT_NAME | PCB_TYPE_POLYGON | PCB_TYPE_ARC) PolygonTypePtr CopyPolygonLowLevel(PolygonTypePtr, PolygonTypePtr); Index: trunk/src/create.c =================================================================== --- trunk/src/create.c (revision 2502) +++ trunk/src/create.c (revision 2503) @@ -377,7 +377,7 @@ /* remove unnecessary points */ if (info.ans) { /* must do this BEFORE getting new line memory */ - MoveObjectToRemoveUndoList(LINE_TYPE, Layer, info.ans, info.ans); + MoveObjectToRemoveUndoList(PCB_TYPE_LINE, Layer, info.ans, info.ans); X1 = info.test.Point1.X; X2 = info.test.Point2.X; Y1 = info.test.Point1.Y; Index: trunk/src/crosshair.c =================================================================== --- trunk/src/crosshair.c (revision 2502) +++ trunk/src/crosshair.c (revision 2503) @@ -346,7 +346,7 @@ LineTypePtr line = (LineTypePtr) Crosshair.AttachedObject.Ptr2; PointTypePtr point = (PointTypePtr) Crosshair.AttachedObject.Ptr3; - if (Crosshair.AttachedObject.Type != NO_TYPE) { + if (Crosshair.AttachedObject.Type != PCB_TYPE_NONE) { gui->draw_line(Crosshair.GC, point->X, point->Y, line->Point1.X, line->Point1.Y); gui->draw_line(Crosshair.GC, point->X, point->Y, line->Point2.X, line->Point2.Y); } @@ -362,7 +362,7 @@ Coord dx = Crosshair.X - Crosshair.AttachedObject.X, dy = Crosshair.Y - Crosshair.AttachedObject.Y; switch (Crosshair.AttachedObject.Type) { - case VIA_TYPE: + case PCB_TYPE_VIA: { PinTypePtr via = (PinTypePtr) Crosshair.AttachedObject.Ptr1; thindraw_moved_pv(via, dx, dy); @@ -369,7 +369,7 @@ break; } - case LINE_TYPE: + case PCB_TYPE_LINE: { LineTypePtr line = (LineTypePtr) Crosshair.AttachedObject.Ptr2; @@ -377,7 +377,7 @@ break; } - case ARC_TYPE: + case PCB_TYPE_ARC: { ArcTypePtr Arc = (ArcTypePtr) Crosshair.AttachedObject.Ptr2; @@ -385,7 +385,7 @@ break; } - case POLYGON_TYPE: + case PCB_TYPE_POLYGON: { PolygonTypePtr polygon = (PolygonTypePtr) Crosshair.AttachedObject.Ptr2; @@ -396,7 +396,7 @@ break; } - case LINEPOINT_TYPE: + case PCB_TYPE_LINE_POINT: { LineTypePtr line; PointTypePtr point; @@ -410,7 +410,7 @@ break; } - case POLYGONPOINT_TYPE: + case PCB_TYPE_POLYGON_POINT: { PolygonTypePtr polygon; PointTypePtr point; @@ -430,7 +430,7 @@ break; } - case ELEMENTNAME_TYPE: + case PCB_TYPE_ELEMENT_NAME: { /* locate the element "mark" and draw an association line from crosshair to it */ ElementTypePtr element = (ElementTypePtr) Crosshair.AttachedObject.Ptr1; @@ -438,7 +438,7 @@ gui->draw_line(Crosshair.GC, element->MarkX, element->MarkY, Crosshair.X, Crosshair.Y); /* fall through to move the text as a box outline */ } - case TEXT_TYPE: + case PCB_TYPE_TEXT: { TextTypePtr text = (TextTypePtr) Crosshair.AttachedObject.Ptr2; BoxTypePtr box = &text->BoundingBox; @@ -447,9 +447,9 @@ } /* pin/pad movements result in moving an element */ - case PAD_TYPE: - case PIN_TYPE: - case ELEMENT_TYPE: + case PCB_TYPE_PAD: + case PCB_TYPE_PIN: + case PCB_TYPE_ELEMENT: XORDrawElement((ElementTypePtr) Crosshair.AttachedObject.Ptr2, dx, dy); break; } @@ -724,7 +724,7 @@ #endif if ((line->Point1.X == info->X && line->Point1.Y == info->Y) || (line->Point2.X == info->X && line->Point2.Y == info->Y)) { OnpointType op; - op.type = LINE_TYPE; + op.type = PCB_TYPE_LINE; op.obj.line = line; vtop_append(&crosshair->onpoint_objs, op); SET_FLAG(ONPOINTFLAG, (AnyObjectType *) line); @@ -754,7 +754,7 @@ if ((close_enough(p1x, info->X) && close_enough(p1y, info->Y)) || (close_enough(p2x, info->X) && close_enough(p2y, info->Y))) { OnpointType op; - op.type = ARC_TYPE; + op.type = PCB_TYPE_ARC; op.obj.arc = arc; vtop_append(&crosshair->onpoint_objs, op); SET_FLAG(ONPOINTFLAG, (AnyObjectType *) arc); @@ -769,7 +769,7 @@ void DrawLineOrArc(int type, void *obj) { switch (type) { - case LINEPOINT_TYPE: + case PCB_TYPE_LINE_POINT: /* Attention: We can use a NULL pointer here for the layer, * because it is not used in the DrawLine() function anyways. * ATM DrawLine() only alls AddPart() internally, which invalidates @@ -922,9 +922,9 @@ /* Pick the nearest grid-point in the x or y direction * to align with, then adjust until we hit the line */ - ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, LINE_TYPE, &ptr1, &ptr2, &ptr3); + ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, PCB_TYPE_LINE, &ptr1, &ptr2, &ptr3); - if (ans == NO_TYPE) + if (ans == PCB_TYPE_NONE) return; line = (LineType *) ptr2; @@ -936,7 +936,7 @@ if ((conf_core.editor.mode != LINE_MODE || CURRENT != ptr1) && (conf_core.editor.mode != MOVE_MODE || Crosshair.AttachedObject.Ptr1 != ptr1 || - Crosshair.AttachedObject.Type != LINEPOINT_TYPE || Crosshair.AttachedObject.Ptr2 == line)) + Crosshair.AttachedObject.Type != PCB_TYPE_LINE_POINT || Crosshair.AttachedObject.Ptr2 == line)) return; dx = line->Point2.X - line->Point1.X; @@ -1024,26 +1024,26 @@ snap_data.x = nearest_grid_x; snap_data.y = nearest_grid_y; - ans = NO_TYPE; + ans = PCB_TYPE_NONE; if (!PCB->RatDraw) - ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, ELEMENT_TYPE, &ptr1, &ptr2, &ptr3); + ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, PCB_TYPE_ELEMENT, &ptr1, &ptr2, &ptr3); - if (ans & ELEMENT_TYPE) { + if (ans & PCB_TYPE_ELEMENT) { ElementType *el = (ElementType *) ptr1; check_snap_object(&snap_data, el->MarkX, el->MarkY, false); } - ans = NO_TYPE; + ans = PCB_TYPE_NONE; if (PCB->RatDraw || conf_core.editor.snap_pin) - ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, PAD_TYPE, &ptr1, &ptr2, &ptr3); + ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, PCB_TYPE_PAD, &ptr1, &ptr2, &ptr3); /* Avoid self-snapping when moving */ - if (ans != NO_TYPE && - conf_core.editor.mode == MOVE_MODE && Crosshair.AttachedObject.Type == ELEMENT_TYPE && ptr1 == Crosshair.AttachedObject.Ptr1) - ans = NO_TYPE; + if (ans != PCB_TYPE_NONE && + conf_core.editor.mode == MOVE_MODE && Crosshair.AttachedObject.Type == PCB_TYPE_ELEMENT && ptr1 == Crosshair.AttachedObject.Ptr1) + ans = PCB_TYPE_NONE; - if (ans != NO_TYPE && - (conf_core.editor.mode == LINE_MODE || (conf_core.editor.mode == MOVE_MODE && Crosshair.AttachedObject.Type == LINEPOINT_TYPE))) { + if (ans != PCB_TYPE_NONE && + (conf_core.editor.mode == LINE_MODE || (conf_core.editor.mode == MOVE_MODE && Crosshair.AttachedObject.Type == PCB_TYPE_LINE_POINT))) { PadTypePtr pad = (PadTypePtr) ptr2; LayerType *desired_layer; Cardinal desired_group; @@ -1051,7 +1051,7 @@ int found_our_layer = false; desired_layer = CURRENT; - if (conf_core.editor.mode == MOVE_MODE && Crosshair.AttachedObject.Type == LINEPOINT_TYPE) { + if (conf_core.editor.mode == MOVE_MODE && Crosshair.AttachedObject.Type == PCB_TYPE_LINE_POINT) { desired_layer = (LayerType *) Crosshair.AttachedObject.Ptr1; } @@ -1070,46 +1070,46 @@ END_LOOP; if (found_our_layer == false) - ans = NO_TYPE; + ans = PCB_TYPE_NONE; } - if (ans != NO_TYPE) { + if (ans != PCB_TYPE_NONE) { PadType *pad = (PadType *) ptr2; check_snap_object(&snap_data, (pad->Point1.X + pad->Point2.X) / 2, (pad->Point1.Y + pad->Point2.Y) / 2, true); } - ans = NO_TYPE; + ans = PCB_TYPE_NONE; if (PCB->RatDraw || conf_core.editor.snap_pin) - ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, PIN_TYPE, &ptr1, &ptr2, &ptr3); + ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, PCB_TYPE_PIN, &ptr1, &ptr2, &ptr3); /* Avoid self-snapping when moving */ - if (ans != NO_TYPE && - conf_core.editor.mode == MOVE_MODE && Crosshair.AttachedObject.Type == ELEMENT_TYPE && ptr1 == Crosshair.AttachedObject.Ptr1) - ans = NO_TYPE; + if (ans != PCB_TYPE_NONE && + conf_core.editor.mode == MOVE_MODE && Crosshair.AttachedObject.Type == PCB_TYPE_ELEMENT && ptr1 == Crosshair.AttachedObject.Ptr1) + ans = PCB_TYPE_NONE; - if (ans != NO_TYPE) { + if (ans != PCB_TYPE_NONE) { PinType *pin = (PinType *) ptr2; check_snap_object(&snap_data, pin->X, pin->Y, true); } - ans = NO_TYPE; + ans = PCB_TYPE_NONE; if (conf_core.editor.snap_pin) - ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, VIA_TYPE, &ptr1, &ptr2, &ptr3); + ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, PCB_TYPE_VIA, &ptr1, &ptr2, &ptr3); /* Avoid snapping vias to any other vias */ - if (conf_core.editor.mode == MOVE_MODE && Crosshair.AttachedObject.Type == VIA_TYPE && (ans & PIN_TYPES)) - ans = NO_TYPE; + if (conf_core.editor.mode == MOVE_MODE && Crosshair.AttachedObject.Type == PCB_TYPE_VIA && (ans & PCB_TYPEMASK_PIN)) + ans = PCB_TYPE_NONE; - if (ans != NO_TYPE) { + if (ans != PCB_TYPE_NONE) { PinType *pin = (PinType *) ptr2; check_snap_object(&snap_data, pin->X, pin->Y, true); } - ans = NO_TYPE; + ans = PCB_TYPE_NONE; if (conf_core.editor.snap_pin) - ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, LINEPOINT_TYPE, &ptr1, &ptr2, &ptr3); + ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, PCB_TYPE_LINE_POINT, &ptr1, &ptr2, &ptr3); - if (ans != NO_TYPE) { + if (ans != PCB_TYPE_NONE) { PointType *pnt = (PointType *) ptr3; check_snap_object(&snap_data, pnt->X, pnt->Y, true); } @@ -1120,11 +1120,11 @@ if (conf_core.editor.snap_offgrid_line) check_snap_offgrid_line(&snap_data, nearest_grid_x, nearest_grid_y); - ans = NO_TYPE; + ans = PCB_TYPE_NONE; if (conf_core.editor.snap_pin) - ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, POLYGONPOINT_TYPE, &ptr1, &ptr2, &ptr3); + ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, PCB_TYPE_POLYGON_POINT, &ptr1, &ptr2, &ptr3); - if (ans != NO_TYPE) { + if (ans != PCB_TYPE_NONE) { PointType *pnt = (PointType *) ptr3; check_snap_object(&snap_data, pnt->X, pnt->Y, true); } @@ -1138,8 +1138,8 @@ onpoint_work(&Crosshair, Crosshair.X, Crosshair.Y); if (conf_core.editor.mode == ARROW_MODE) { - ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, LINEPOINT_TYPE, &ptr1, &ptr2, &ptr3); - if (ans == NO_TYPE) + ans = SearchScreenGridSlop(Crosshair.X, Crosshair.Y, PCB_TYPE_LINE_POINT, &ptr1, &ptr2, &ptr3); + if (ans == PCB_TYPE_NONE) hid_action("PointCursor"); else if (!TEST_FLAG(SELECTEDFLAG, (LineType *) ptr2)) hid_actionl("PointCursor", "True", NULL); Index: trunk/src/draw.c =================================================================== --- trunk/src/draw.c (revision 2502) +++ trunk/src/draw.c (revision 2503) @@ -102,7 +102,7 @@ char *color; char buf[sizeof("#XXXXXX")]; - if (Type == VIA_TYPE) { + if (Type == PCB_TYPE_VIA) { if (!doing_pinout && TEST_FLAG(WARNFLAG | SELECTEDFLAG | FOUNDFLAG, Pin)) { if (TEST_FLAG(WARNFLAG, Pin)) color = PCB->WarnColor; @@ -234,7 +234,7 @@ static void draw_pin(PinTypePtr pin, bool draw_hole) { - SetPVColor(pin, PIN_TYPE); + SetPVColor(pin, PCB_TYPE_PIN); _draw_pv(pin, draw_hole); } @@ -246,7 +246,7 @@ static void draw_via(PinTypePtr via, bool draw_hole) { - SetPVColor(via, VIA_TYPE); + SetPVColor(via, PCB_TYPE_VIA); _draw_pv(via, draw_hole); } @@ -1589,30 +1589,30 @@ void EraseObject(int type, void *lptr, void *ptr) { switch (type) { - case VIA_TYPE: - case PIN_TYPE: + case PCB_TYPE_VIA: + case PCB_TYPE_PIN: ErasePin((PinTypePtr) ptr); break; - case TEXT_TYPE: - case ELEMENTNAME_TYPE: + case PCB_TYPE_TEXT: + case PCB_TYPE_ELEMENT_NAME: EraseText((LayerTypePtr) lptr, (TextTypePtr) ptr); break; - case POLYGON_TYPE: + case PCB_TYPE_POLYGON: ErasePolygon((PolygonTypePtr) ptr); break; - case ELEMENT_TYPE: + case PCB_TYPE_ELEMENT: EraseElement((ElementTypePtr) ptr); break; - case LINE_TYPE: - case ELEMENTLINE_TYPE: - case RATLINE_TYPE: + case PCB_TYPE_LINE: + case PCB_TYPE_ELEMENT_LINE: + case PCB_TYPE_RATLINE: EraseLine((LineTypePtr) ptr); break; - case PAD_TYPE: + case PCB_TYPE_PAD: ErasePad((PadTypePtr) ptr); break; - case ARC_TYPE: - case ELEMENTARC_TYPE: + case PCB_TYPE_ARC: + case PCB_TYPE_ELEMENT_ARC: EraseArc((ArcTypePtr) ptr); break; default: @@ -1624,43 +1624,43 @@ void DrawObject(int type, void *ptr1, void *ptr2) { switch (type) { - case VIA_TYPE: + case PCB_TYPE_VIA: if (PCB->ViaOn) DrawVia((PinTypePtr) ptr2); break; - case LINE_TYPE: + case PCB_TYPE_LINE: if (((LayerTypePtr) ptr1)->On) DrawLine((LayerTypePtr) ptr1, (LineTypePtr) ptr2); break; - case ARC_TYPE: + case PCB_TYPE_ARC: if (((LayerTypePtr) ptr1)->On) DrawArc((LayerTypePtr) ptr1, (ArcTypePtr) ptr2); break; - case TEXT_TYPE: + case PCB_TYPE_TEXT: if (((LayerTypePtr) ptr1)->On) DrawText((LayerTypePtr) ptr1, (TextTypePtr) ptr2); break; - case POLYGON_TYPE: + case PCB_TYPE_POLYGON: if (((LayerTypePtr) ptr1)->On) DrawPolygon((LayerTypePtr) ptr1, (PolygonTypePtr) ptr2); break; - case ELEMENT_TYPE: + case PCB_TYPE_ELEMENT: if (PCB->ElementOn && (FRONT((ElementTypePtr) ptr2) || PCB->InvisibleObjectsOn)) DrawElement((ElementTypePtr) ptr2); break; - case RATLINE_TYPE: + case PCB_TYPE_RATLINE: if (PCB->RatOn) DrawRat((RatTypePtr) ptr2); break; - case PIN_TYPE: + case PCB_TYPE_PIN: if (PCB->PinOn) DrawPin((PinTypePtr) ptr2); break; - case PAD_TYPE: + case PCB_TYPE_PAD: if (PCB->PinOn) DrawPad((PadTypePtr) ptr2); break; - case ELEMENTNAME_TYPE: + case PCB_TYPE_ELEMENT_NAME: if (PCB->ElementOn && (FRONT((ElementTypePtr) ptr2) || PCB->InvisibleObjectsOn)) DrawElementName((ElementTypePtr) ptr1); break; Index: trunk/src/file_act.c =================================================================== --- trunk/src/file_act.c (revision 2502) +++ trunk/src/file_act.c (revision 2503) @@ -302,7 +302,7 @@ FILE *fp; bool result; - if ((SearchScreen(Crosshair.X, Crosshair.Y, ELEMENT_TYPE, &ptrtmp, &ptrtmp, &ptrtmp)) != NO_TYPE) { + if ((SearchScreen(Crosshair.X, Crosshair.Y, PCB_TYPE_ELEMENT, &ptrtmp, &ptrtmp, &ptrtmp)) != PCB_TYPE_NONE) { element = (ElementTypePtr) ptrtmp; if ((fp = CheckAndOpenFile(name, true, false, &result, NULL)) != NULL) { LookupElementConnections(element, fp); Index: trunk/src/find.h =================================================================== --- trunk/src/find.h (revision 2502) +++ trunk/src/find.h (revision 2503) @@ -54,11 +54,11 @@ * some local defines */ #define LOOKUP_FIRST \ - (PIN_TYPE | PAD_TYPE) + (PCB_TYPE_PIN | PCB_TYPE_PAD) #define LOOKUP_MORE \ - (VIA_TYPE | LINE_TYPE | RATLINE_TYPE | POLYGON_TYPE | ARC_TYPE) + (PCB_TYPE_VIA | PCB_TYPE_LINE | PCB_TYPE_RATLINE | PCB_TYPE_POLYGON | PCB_TYPE_ARC) #define SILK_TYPE \ - (LINE_TYPE | ARC_TYPE | POLYGON_TYPE) + (PCB_TYPE_LINE | PCB_TYPE_ARC | PCB_TYPE_POLYGON) bool LineLineIntersect(LineTypePtr, LineTypePtr); bool LineArcIntersect(LineTypePtr, ArcTypePtr); Index: trunk/src/find_drc.c =================================================================== --- trunk/src/find_drc.c (revision 2502) +++ trunk/src/find_drc.c (revision 2503) @@ -91,14 +91,14 @@ *object_type_list = NULL; switch (thing_type) { - case LINE_TYPE: - case ARC_TYPE: - case POLYGON_TYPE: - case PIN_TYPE: - case VIA_TYPE: - case PAD_TYPE: - case ELEMENT_TYPE: - case RATLINE_TYPE: + case PCB_TYPE_LINE: + case PCB_TYPE_ARC: + case PCB_TYPE_POLYGON: + case PCB_TYPE_PIN: + case PCB_TYPE_VIA: + case PCB_TYPE_PAD: + case PCB_TYPE_ELEMENT: + case PCB_TYPE_RATLINE: *object_count = 1; *object_id_list = (long int *) malloc(sizeof(long int)); *object_type_list = (int *) malloc(sizeof(int)); @@ -119,7 +119,7 @@ static void LocateError(Coord * x, Coord * y) { switch (thing_type) { - case LINE_TYPE: + case PCB_TYPE_LINE: { LineTypePtr line = (LineTypePtr) thing_ptr3; *x = (line->Point1.X + line->Point2.X) / 2; @@ -126,7 +126,7 @@ *y = (line->Point1.Y + line->Point2.Y) / 2; break; } - case ARC_TYPE: + case PCB_TYPE_ARC: { ArcTypePtr arc = (ArcTypePtr) thing_ptr3; *x = arc->X; @@ -133,7 +133,7 @@ *y = arc->Y; break; } - case POLYGON_TYPE: + case PCB_TYPE_POLYGON: { PolygonTypePtr polygon = (PolygonTypePtr) thing_ptr3; *x = (polygon->Clipped->contours->xmin + polygon->Clipped->contours->xmax) / 2; @@ -140,8 +140,8 @@ *y = (polygon->Clipped->contours->ymin + polygon->Clipped->contours->ymax) / 2; break; } - case PIN_TYPE: - case VIA_TYPE: + case PCB_TYPE_PIN: + case PCB_TYPE_VIA: { PinTypePtr pin = (PinTypePtr) thing_ptr3; *x = pin->X; @@ -148,7 +148,7 @@ *y = pin->Y; break; } - case PAD_TYPE: + case PCB_TYPE_PAD: { PadTypePtr pad = (PadTypePtr) thing_ptr3; *x = (pad->Point1.X + pad->Point2.X) / 2; @@ -155,7 +155,7 @@ *y = (pad->Point1.Y + pad->Point2.Y) / 2; break; } - case ELEMENT_TYPE: + case PCB_TYPE_ELEMENT: { ElementTypePtr element = (ElementTypePtr) thing_ptr3; *x = element->MarkX; @@ -231,7 +231,7 @@ thing_ptr2 = ptr2; thing_ptr3 = ptr2; switch (type) { - case LINE_TYPE: + case PCB_TYPE_LINE: if (line->Clearance < 2 * PCB->Bloat) { AddObjectToFlagUndoList(type, ptr1, ptr2, ptr2); SET_FLAG(TheFlag, line); @@ -239,7 +239,7 @@ goto doIsBad; } break; - case ARC_TYPE: + case PCB_TYPE_ARC: if (arc->Clearance < 2 * PCB->Bloat) { AddObjectToFlagUndoList(type, ptr1, ptr2, ptr2); SET_FLAG(TheFlag, arc); @@ -247,7 +247,7 @@ goto doIsBad; } break; - case PAD_TYPE: + case PCB_TYPE_PAD: if (pad->Clearance && pad->Clearance < 2 * PCB->Bloat) if (IsPadInPolygon(pad, polygon)) { AddObjectToFlagUndoList(type, ptr1, ptr2, ptr2); @@ -256,7 +256,7 @@ goto doIsBad; } break; - case PIN_TYPE: + case PCB_TYPE_PIN: if (pin->Clearance && pin->Clearance < 2 * PCB->Bloat) { AddObjectToFlagUndoList(type, ptr1, ptr2, ptr2); SET_FLAG(TheFlag, pin); @@ -264,7 +264,7 @@ goto doIsBad; } break; - case VIA_TYPE: + case PCB_TYPE_VIA: if (pin->Clearance && pin->Clearance < 2 * PCB->Bloat) { AddObjectToFlagUndoList(type, ptr1, ptr2, ptr2); SET_FLAG(TheFlag, pin); @@ -278,7 +278,7 @@ return R_DIR_NOT_FOUND; doIsBad: - AddObjectToFlagUndoList(POLYGON_TYPE, layer, polygon, polygon); + AddObjectToFlagUndoList(PCB_TYPE_POLYGON, layer, polygon, polygon); SET_FLAG(FOUNDFLAG, polygon); DrawPolygon(layer, polygon); DrawObject(type, ptr1, ptr2); @@ -341,7 +341,7 @@ PIN_LOOP(element); { if (!TEST_FLAG(DRCFLAG, pin) - && DRCFind(PIN_TYPE, (void *) element, (void *) pin, (void *) pin)) { + && DRCFind(PCB_TYPE_PIN, (void *) element, (void *) pin, (void *) pin)) { IsBad = true; break; } @@ -357,7 +357,7 @@ nopastecnt++; if (!TEST_FLAG(DRCFLAG, pad) - && DRCFind(PAD_TYPE, (void *) element, (void *) pad, (void *) pad)) { + && DRCFind(PCB_TYPE_PAD, (void *) element, (void *) pad, (void *) pad)) { IsBad = true; break; } @@ -371,7 +371,7 @@ VIA_LOOP(PCB->Data); { if (!TEST_FLAG(DRCFLAG, via) - && DRCFind(VIA_TYPE, (void *) via, (void *) via, (void *) via)) { + && DRCFind(PCB_TYPE_VIA, (void *) via, (void *) via, (void *) via)) { IsBad = true; break; } @@ -386,15 +386,15 @@ COPPERLINE_LOOP(PCB->Data); { /* check line clearances in polygons */ - PlowsPolygon(PCB->Data, LINE_TYPE, layer, line, drc_callback); + PlowsPolygon(PCB->Data, PCB_TYPE_LINE, layer, line, drc_callback); if (IsBad) break; if (line->Thickness < PCB->minWid) { - AddObjectToFlagUndoList(LINE_TYPE, layer, line, line); + AddObjectToFlagUndoList(PCB_TYPE_LINE, layer, line, line); SET_FLAG(TheFlag, line); DrawLine(layer, line); drcerr_count++; - SetThing(LINE_TYPE, layer, line, line); + SetThing(PCB_TYPE_LINE, layer, line, line); LocateError(&x, &y); BuildObjectList(&object_count, &object_id_list, &object_type_list); violation = pcb_drc_violation_new(_("Line width is too thin"), _("Process specifications dictate a minimum feature-width\n" "that can reliably be reproduced"), x, y, 0, /* ANGLE OF ERROR UNKNOWN */ @@ -417,15 +417,15 @@ if (!IsBad) { COPPERARC_LOOP(PCB->Data); { - PlowsPolygon(PCB->Data, ARC_TYPE, layer, arc, drc_callback); + PlowsPolygon(PCB->Data, PCB_TYPE_ARC, layer, arc, drc_callback); if (IsBad) break; if (arc->Thickness < PCB->minWid) { - AddObjectToFlagUndoList(ARC_TYPE, layer, arc, arc); + AddObjectToFlagUndoList(PCB_TYPE_ARC, layer, arc, arc); SET_FLAG(TheFlag, arc); DrawArc(layer, arc); drcerr_count++; - SetThing(ARC_TYPE, layer, arc, arc); + SetThing(PCB_TYPE_ARC, layer, arc, arc); LocateError(&x, &y); BuildObjectList(&object_count, &object_id_list, &object_type_list); violation = pcb_drc_violation_new(_("Arc width is too thin"), _("Process specifications dictate a minimum feature-width\n" "that can reliably be reproduced"), x, y, 0, /* ANGLE OF ERROR UNKNOWN */ @@ -448,15 +448,15 @@ if (!IsBad) { ALLPIN_LOOP(PCB->Data); { - PlowsPolygon(PCB->Data, PIN_TYPE, element, pin, drc_callback); + PlowsPolygon(PCB->Data, PCB_TYPE_PIN, element, pin, drc_callback); if (IsBad) break; if (!TEST_FLAG(HOLEFLAG, pin) && pin->Thickness - pin->DrillingHole < 2 * PCB->minRing) { - AddObjectToFlagUndoList(PIN_TYPE, element, pin, pin); + AddObjectToFlagUndoList(PCB_TYPE_PIN, element, pin, pin); SET_FLAG(TheFlag, pin); DrawPin(pin); drcerr_count++; - SetThing(PIN_TYPE, element, pin, pin); + SetThing(PCB_TYPE_PIN, element, pin, pin); LocateError(&x, &y); BuildObjectList(&object_count, &object_id_list, &object_type_list); violation = pcb_drc_violation_new(_("Pin annular ring too small"), _("Annular rings that are too small may erode during etching,\n" "resulting in a broken connection"), x, y, 0, /* ANGLE OF ERROR UNKNOWN */ @@ -475,11 +475,11 @@ Undo(false); } if (pin->DrillingHole < PCB->minDrill) { - AddObjectToFlagUndoList(PIN_TYPE, element, pin, pin); + AddObjectToFlagUndoList(PCB_TYPE_PIN, element, pin, pin); SET_FLAG(TheFlag, pin); DrawPin(pin); drcerr_count++; - SetThing(PIN_TYPE, element, pin, pin); + SetThing(PCB_TYPE_PIN, element, pin, pin); LocateError(&x, &y); BuildObjectList(&object_count, &object_id_list, &object_type_list); violation = pcb_drc_violation_new(_("Pin drill size is too small"), _("Process rules dictate the minimum drill size which can be used"), x, y, 0, /* ANGLE OF ERROR UNKNOWN */ @@ -502,15 +502,15 @@ if (!IsBad) { ALLPAD_LOOP(PCB->Data); { - PlowsPolygon(PCB->Data, PAD_TYPE, element, pad, drc_callback); + PlowsPolygon(PCB->Data, PCB_TYPE_PAD, element, pad, drc_callback); if (IsBad) break; if (pad->Thickness < PCB->minWid) { - AddObjectToFlagUndoList(PAD_TYPE, element, pad, pad); + AddObjectToFlagUndoList(PCB_TYPE_PAD, element, pad, pad); SET_FLAG(TheFlag, pad); DrawPad(pad); drcerr_count++; - SetThing(PAD_TYPE, element, pad, pad); + SetThing(PCB_TYPE_PAD, element, pad, pad); LocateError(&x, &y); BuildObjectList(&object_count, &object_id_list, &object_type_list); violation = pcb_drc_violation_new(_("Pad is too thin"), _("Pads which are too thin may erode during etching,\n" "resulting in a broken or unreliable connection"), x, y, 0, /* ANGLE OF ERROR UNKNOWN */ @@ -533,15 +533,15 @@ if (!IsBad) { VIA_LOOP(PCB->Data); { - PlowsPolygon(PCB->Data, VIA_TYPE, via, via, drc_callback); + PlowsPolygon(PCB->Data, PCB_TYPE_VIA, via, via, drc_callback); if (IsBad) break; if (!TEST_FLAG(HOLEFLAG, via) && via->Thickness - via->DrillingHole < 2 * PCB->minRing) { - AddObjectToFlagUndoList(VIA_TYPE, via, via, via); + AddObjectToFlagUndoList(PCB_TYPE_VIA, via, via, via); SET_FLAG(TheFlag, via); DrawVia(via); drcerr_count++; - SetThing(VIA_TYPE, via, via, via); + SetThing(PCB_TYPE_VIA, via, via, via); LocateError(&x, &y); BuildObjectList(&object_count, &object_id_list, &object_type_list); violation = pcb_drc_violation_new(_("Via annular ring too small"), _("Annular rings that are too small may erode during etching,\n" "resulting in a broken connection"), x, y, 0, /* ANGLE OF ERROR UNKNOWN */ @@ -560,11 +560,11 @@ Undo(false); } if (via->DrillingHole < PCB->minDrill) { - AddObjectToFlagUndoList(VIA_TYPE, via, via, via); + AddObjectToFlagUndoList(PCB_TYPE_VIA, via, via, via); SET_FLAG(TheFlag, via); DrawVia(via); drcerr_count++; - SetThing(VIA_TYPE, via, via, via); + SetThing(PCB_TYPE_VIA, via, via, via); LocateError(&x, &y); BuildObjectList(&object_count, &object_id_list, &object_type_list); violation = pcb_drc_violation_new(_("Via drill size is too small"), _("Process rules dictate the minimum drill size which can be used"), x, y, 0, /* ANGLE OF ERROR UNKNOWN */ @@ -599,7 +599,7 @@ SET_FLAG(TheFlag, line); DrawLine(layer, line); drcerr_count++; - SetThing(LINE_TYPE, layer, line, line); + SetThing(PCB_TYPE_LINE, layer, line, line); LocateError(&x, &y); BuildObjectList(&object_count, &object_id_list, &object_type_list); violation = pcb_drc_violation_new(_("Silk line is too thin"), _("Process specifications dictate a minimum silkscreen feature-width\n" "that can reliably be reproduced"), x, y, 0, /* ANGLE OF ERROR UNKNOWN */ @@ -640,7 +640,7 @@ SET_FLAG(TheFlag, element); DrawElement(element); drcerr_count++; - SetThing(ELEMENT_TYPE, element, element, element); + SetThing(PCB_TYPE_ELEMENT, element, element, element); LocateError(&x, &y); BuildObjectList(&object_count, &object_id_list, &object_type_list); @@ -821,9 +821,9 @@ LocateError(&X, &Y); switch (thing_type) { - case LINE_TYPE: - case ARC_TYPE: - case POLYGON_TYPE: + case PCB_TYPE_LINE: + case PCB_TYPE_ARC: + case PCB_TYPE_POLYGON: ChangeGroupVisibility(GetLayerNumber(PCB->Data, (LayerTypePtr) thing_ptr1), true, true); } CenterDisplay(X, Y); Index: trunk/src/find_lookup.c =================================================================== --- trunk/src/find_lookup.c (revision 2502) +++ trunk/src/find_lookup.c (revision 2503) @@ -30,9 +30,9 @@ static bool ADD_PV_TO_LIST(PinTypePtr Pin, int from_type, void *from_ptr, found_conn_type_t type) { if (User) - AddObjectToFlagUndoList(Pin->Element ? PIN_TYPE : VIA_TYPE, Pin->Element ? Pin->Element : Pin, Pin, Pin); + AddObjectToFlagUndoList(Pin->Element ? PCB_TYPE_PIN : PCB_TYPE_VIA, Pin->Element ? Pin->Element : Pin, Pin, Pin); SET_FLAG(TheFlag, Pin); - make_callback(PIN_TYPE, Pin, from_type, from_ptr, type); + make_callback(PCB_TYPE_PIN, Pin, from_type, from_ptr, type); PVLIST_ENTRY(PVList.Number) = Pin; PVList.Number++; #ifdef DEBUG @@ -40,7 +40,7 @@ printf("ADD_PV_TO_LIST overflow! num=%d size=%d\n", PVList.Number, PVList.Size); #endif if (drc && !TEST_FLAG(SELECTEDFLAG, Pin)) - return (SetThing(PIN_TYPE, Pin->Element, Pin, Pin)); + return (SetThing(PCB_TYPE_PIN, Pin->Element, Pin, Pin)); return false; } @@ -48,9 +48,9 @@ { /*fprintf(stderr, "ADD_PAD_TO_LIST cardinal %d %p %d\n", L, Pad, from_type);*/ if (User) - AddObjectToFlagUndoList(PAD_TYPE, Pad->Element, Pad, Pad); + AddObjectToFlagUndoList(PCB_TYPE_PAD, Pad->Element, Pad, Pad); SET_FLAG(TheFlag, Pad); - make_callback(PAD_TYPE, Pad, from_type, from_ptr, type); + make_callback(PCB_TYPE_PAD, Pad, from_type, from_ptr, type); PADLIST_ENTRY((L), PadList[(L)].Number) = Pad; PadList[(L)].Number++; #ifdef DEBUG @@ -58,7 +58,7 @@ printf("ADD_PAD_TO_LIST overflow! lay=%d, num=%d size=%d\n", L, PadList[(L)].Number, PadList[(L)].Size); #endif if (drc && !TEST_FLAG(SELECTEDFLAG, Pad)) - return (SetThing(PAD_TYPE, Pad->Element, Pad, Pad)); + return (SetThing(PCB_TYPE_PAD, Pad->Element, Pad, Pad)); return false; } @@ -65,9 +65,9 @@ static bool ADD_LINE_TO_LIST(Cardinal L, LineTypePtr Ptr, int from_type, void *from_ptr, found_conn_type_t type) { if (User) - AddObjectToFlagUndoList(LINE_TYPE, LAYER_PTR(L), (Ptr), (Ptr)); + AddObjectToFlagUndoList(PCB_TYPE_LINE, LAYER_PTR(L), (Ptr), (Ptr)); SET_FLAG(TheFlag, (Ptr)); - make_callback(LINE_TYPE, Ptr, from_type, from_ptr, type); + make_callback(PCB_TYPE_LINE, Ptr, from_type, from_ptr, type); LINELIST_ENTRY((L), LineList[(L)].Number) = (Ptr); LineList[(L)].Number++; #ifdef DEBUG @@ -75,7 +75,7 @@ printf("ADD_LINE_TO_LIST overflow! lay=%d, num=%d size=%d\n", L, LineList[(L)].Number, LineList[(L)].Size); #endif if (drc && !TEST_FLAG(SELECTEDFLAG, (Ptr))) - return (SetThing(LINE_TYPE, LAYER_PTR(L), (Ptr), (Ptr))); + return (SetThing(PCB_TYPE_LINE, LAYER_PTR(L), (Ptr), (Ptr))); return false; } @@ -82,9 +82,9 @@ static bool ADD_ARC_TO_LIST(Cardinal L, ArcTypePtr Ptr, int from_type, void *from_ptr, found_conn_type_t type) { if (User) - AddObjectToFlagUndoList(ARC_TYPE, LAYER_PTR(L), (Ptr), (Ptr)); + AddObjectToFlagUndoList(PCB_TYPE_ARC, LAYER_PTR(L), (Ptr), (Ptr)); SET_FLAG(TheFlag, (Ptr)); - make_callback(ARC_TYPE, Ptr, from_type, from_ptr, type); + make_callback(PCB_TYPE_ARC, Ptr, from_type, from_ptr, type); ARCLIST_ENTRY((L), ArcList[(L)].Number) = (Ptr); ArcList[(L)].Number++; #ifdef DEBUG @@ -92,7 +92,7 @@ printf("ADD_ARC_TO_LIST overflow! lay=%d, num=%d size=%d\n", L, ArcList[(L)].Number, ArcList[(L)].Size); #endif if (drc && !TEST_FLAG(SELECTEDFLAG, (Ptr))) - return (SetThing(ARC_TYPE, LAYER_PTR(L), (Ptr), (Ptr))); + return (SetThing(PCB_TYPE_ARC, LAYER_PTR(L), (Ptr), (Ptr))); return false; } @@ -99,9 +99,9 @@ static bool ADD_RAT_TO_LIST(RatTypePtr Ptr, int from_type, void *from_ptr, found_conn_type_t type) { if (User) - AddObjectToFlagUndoList(RATLINE_TYPE, (Ptr), (Ptr), (Ptr)); + AddObjectToFlagUndoList(PCB_TYPE_RATLINE, (Ptr), (Ptr), (Ptr)); SET_FLAG(TheFlag, (Ptr)); - make_callback(RATLINE_TYPE, Ptr, from_type, from_ptr, type); + make_callback(PCB_TYPE_RATLINE, Ptr, from_type, from_ptr, type); RATLIST_ENTRY(RatList.Number) = (Ptr); RatList.Number++; #ifdef DEBUG @@ -109,7 +109,7 @@ printf("ADD_RAT_TO_LIST overflow! num=%d size=%d\n", RatList.Number, RatList.Size); #endif if (drc && !TEST_FLAG(SELECTEDFLAG, (Ptr))) - return (SetThing(RATLINE_TYPE, (Ptr), (Ptr), (Ptr))); + return (SetThing(PCB_TYPE_RATLINE, (Ptr), (Ptr), (Ptr))); return false; } @@ -116,9 +116,9 @@ static bool ADD_POLYGON_TO_LIST(Cardinal L, PolygonTypePtr Ptr, int from_type, void *from_ptr, found_conn_type_t type) { if (User) - AddObjectToFlagUndoList(POLYGON_TYPE, LAYER_PTR(L), (Ptr), (Ptr)); + AddObjectToFlagUndoList(PCB_TYPE_POLYGON, LAYER_PTR(L), (Ptr), (Ptr)); SET_FLAG(TheFlag, (Ptr)); - make_callback(POLYGON_TYPE, Ptr, from_type, from_ptr, type); + make_callback(PCB_TYPE_POLYGON, Ptr, from_type, from_ptr, type); POLYGONLIST_ENTRY((L), PolygonList[(L)].Number) = (Ptr); PolygonList[(L)].Number++; #ifdef DEBUG @@ -126,7 +126,7 @@ printf("ADD_ARC_TO_LIST overflow! lay=%d, num=%d size=%d\n", L, PolygonList[(L)].Number, PolygonList[(L)].Size); #endif if (drc && !TEST_FLAG(SELECTEDFLAG, (Ptr))) - return (SetThing(POLYGON_TYPE, LAYER_PTR(L), (Ptr), (Ptr))); + return (SetThing(PCB_TYPE_POLYGON, LAYER_PTR(L), (Ptr), (Ptr))); return false; } @@ -136,9 +136,9 @@ thing_ptr2 = ptr2; thing_ptr3 = ptr3; thing_type = type; - if (type == PIN_TYPE && ptr1 == NULL) { + if (type == PCB_TYPE_PIN && ptr1 == NULL) { thing_ptr1 = ptr3; - thing_type = VIA_TYPE; + thing_type = PCB_TYPE_VIA; } return true; } @@ -278,7 +278,7 @@ struct pv_info *i = (struct pv_info *) cl; if (!TEST_FLAG(TheFlag, line) && PinLineIntersect(&i->pv, line) && !TEST_FLAG(HOLEFLAG, &i->pv)) { - if (ADD_LINE_TO_LIST(i->layer, line, PIN_TYPE, &i->pv, FCT_COPPER)) + if (ADD_LINE_TO_LIST(i->layer, line, PCB_TYPE_PIN, &i->pv, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -290,7 +290,7 @@ struct pv_info *i = (struct pv_info *) cl; if (!TEST_FLAG(TheFlag, arc) && IS_PV_ON_ARC(&i->pv, arc) && !TEST_FLAG(HOLEFLAG, &i->pv)) { - if (ADD_ARC_TO_LIST(i->layer, arc, PIN_TYPE, &i->pv, FCT_COPPER)) + if (ADD_ARC_TO_LIST(i->layer, arc, PCB_TYPE_PIN, &i->pv, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -303,7 +303,7 @@ if (!TEST_FLAG(TheFlag, pad) && IS_PV_ON_PAD(&i->pv, pad) && !TEST_FLAG(HOLEFLAG, &i->pv) && - ADD_PAD_TO_LIST(TEST_FLAG(ONSOLDERFLAG, pad) ? SOLDER_LAYER : COMPONENT_LAYER, pad, PIN_TYPE, &i->pv, FCT_COPPER)) + ADD_PAD_TO_LIST(TEST_FLAG(ONSOLDERFLAG, pad) ? SOLDER_LAYER : COMPONENT_LAYER, pad, PCB_TYPE_PIN, &i->pv, FCT_COPPER)) longjmp(i->env, 1); return R_DIR_NOT_FOUND; } @@ -313,7 +313,7 @@ RatTypePtr rat = (RatTypePtr) b; struct pv_info *i = (struct pv_info *) cl; - if (!TEST_FLAG(TheFlag, rat) && IS_PV_ON_RAT(&i->pv, rat) && ADD_RAT_TO_LIST(rat, PIN_TYPE, &i->pv, FCT_RAT)) + if (!TEST_FLAG(TheFlag, rat) && IS_PV_ON_RAT(&i->pv, rat) && ADD_RAT_TO_LIST(rat, PCB_TYPE_PIN, &i->pv, FCT_RAT)) longjmp(i->env, 1); return R_DIR_NOT_FOUND; } @@ -339,17 +339,17 @@ Coord y1 = i->pv.Y - (i->pv.Thickness + 1 + Bloat) / 2; Coord y2 = i->pv.Y + (i->pv.Thickness + 1 + Bloat) / 2; if (IsRectangleInPolygon(x1, y1, x2, y2, polygon) - && ADD_POLYGON_TO_LIST(i->layer, polygon, PIN_TYPE, &i->pv, FCT_COPPER)) + && ADD_POLYGON_TO_LIST(i->layer, polygon, PCB_TYPE_PIN, &i->pv, FCT_COPPER)) longjmp(i->env, 1); } else if (TEST_FLAG(OCTAGONFLAG, &i->pv)) { POLYAREA *oct = OctagonPoly(i->pv.X, i->pv.Y, i->pv.Thickness / 2, GET_SQUARE(&i->pv)); if (isects(oct, polygon, true) - && ADD_POLYGON_TO_LIST(i->layer, polygon, PIN_TYPE, &i->pv, FCT_COPPER)) + && ADD_POLYGON_TO_LIST(i->layer, polygon, PCB_TYPE_PIN, &i->pv, FCT_COPPER)) longjmp(i->env, 1); } else if (IsPointInPolygon(i->pv.X, i->pv.Y, wide, polygon) - && ADD_POLYGON_TO_LIST(i->layer, polygon, PIN_TYPE, &i->pv, FCT_COPPER)) + && ADD_POLYGON_TO_LIST(i->layer, polygon, PCB_TYPE_PIN, &i->pv, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -523,7 +523,7 @@ else Message(_("WARNING: Hole too close to via.\n")); } - else if (ADD_PV_TO_LIST(pin, PIN_TYPE, &i->pv, FCT_COPPER)) + else if (ADD_PV_TO_LIST(pin, PCB_TYPE_PIN, &i->pv, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -556,7 +556,7 @@ { if ((orig_pin != pin) && (ic == GET_INTCONN(pin))) { if (!TEST_FLAG(TheFlag, pin)) - ADD_PV_TO_LIST(pin, PIN_TYPE, orig_pin, FCT_INTERNAL); + ADD_PV_TO_LIST(pin, PCB_TYPE_PIN, orig_pin, FCT_INTERNAL); } } END_LOOP; @@ -599,7 +599,7 @@ conf_core.temp.rat_warn = true; Message(_("WARNING: Hole too close to line.\n")); } - else if (ADD_PV_TO_LIST(pv, LINE_TYPE, &i->line, FCT_COPPER)) + else if (ADD_PV_TO_LIST(pv, PCB_TYPE_LINE, &i->line, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -616,7 +616,7 @@ conf_core.temp.rat_warn = true; Message(_("WARNING: Hole too close to pad.\n")); } - else if (ADD_PV_TO_LIST(pv, PAD_TYPE, &i->pad, FCT_COPPER)) + else if (ADD_PV_TO_LIST(pv, PCB_TYPE_PAD, &i->pad, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -633,7 +633,7 @@ conf_core.temp.rat_warn = true; Message(_("WARNING: Hole touches arc.\n")); } - else if (ADD_PV_TO_LIST(pv, ARC_TYPE, &i->arc, FCT_COPPER)) + else if (ADD_PV_TO_LIST(pv, PCB_TYPE_ARC, &i->arc, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -654,17 +654,17 @@ y1 = pv->Y - (PIN_SIZE(pv) + 1 + Bloat) / 2; y2 = pv->Y + (PIN_SIZE(pv) + 1 + Bloat) / 2; if (IsRectangleInPolygon(x1, y1, x2, y2, &i->polygon) - && ADD_PV_TO_LIST(pv, POLYGON_TYPE, &i->polygon, FCT_COPPER)) + && ADD_PV_TO_LIST(pv, PCB_TYPE_POLYGON, &i->polygon, FCT_COPPER)) longjmp(i->env, 1); } else if (TEST_FLAG(OCTAGONFLAG, pv)) { POLYAREA *oct = OctagonPoly(pv->X, pv->Y, PIN_SIZE(pv) / 2, GET_SQUARE(pv)); - if (isects(oct, &i->polygon, true) && ADD_PV_TO_LIST(pv, POLYGON_TYPE, &i->polygon, FCT_COPPER)) + if (isects(oct, &i->polygon, true) && ADD_PV_TO_LIST(pv, PCB_TYPE_POLYGON, &i->polygon, FCT_COPPER)) longjmp(i->env, 1); } else { if (IsPointInPolygon(pv->X, pv->Y, PIN_SIZE(pv) * 0.5 + Bloat, &i->polygon) - && ADD_PV_TO_LIST(pv, POLYGON_TYPE, &i->polygon, FCT_COPPER)) + && ADD_PV_TO_LIST(pv, PCB_TYPE_POLYGON, &i->polygon, FCT_COPPER)) longjmp(i->env, 1); } } @@ -678,7 +678,7 @@ /* rats can't cause DRC so there is no early exit */ if (!TEST_FLAG(TheFlag, pv) && IS_PV_ON_RAT(pv, &i->rat)) - ADD_PV_TO_LIST(pv, RATLINE_TYPE, &i->rat, FCT_RAT); + ADD_PV_TO_LIST(pv, PCB_TYPE_RATLINE, &i->rat, FCT_RAT); return R_DIR_NOT_FOUND; } @@ -811,7 +811,7 @@ struct lo_info *i = (struct lo_info *) cl; if (!TEST_FLAG(TheFlag, line) && LineArcIntersect(line, &i->arc)) { - if (ADD_LINE_TO_LIST(i->layer, line, ARC_TYPE, &i->arc, FCT_COPPER)) + if (ADD_LINE_TO_LIST(i->layer, line, PCB_TYPE_ARC, &i->arc, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -825,7 +825,7 @@ if (!arc->Thickness) return 0; if (!TEST_FLAG(TheFlag, arc) && ArcArcIntersect(&i->arc, arc)) { - if (ADD_ARC_TO_LIST(i->layer, arc, ARC_TYPE, &i->arc, FCT_COPPER)) + if (ADD_ARC_TO_LIST(i->layer, arc, PCB_TYPE_ARC, &i->arc, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -837,7 +837,7 @@ struct lo_info *i = (struct lo_info *) cl; if (!TEST_FLAG(TheFlag, pad) && i->layer == (TEST_FLAG(ONSOLDERFLAG, pad) ? SOLDER_LAYER : COMPONENT_LAYER) - && ArcPadIntersect(&i->arc, pad) && ADD_PAD_TO_LIST(i->layer, pad, ARC_TYPE, &i->arc, FCT_COPPER)) + && ArcPadIntersect(&i->arc, pad) && ADD_PAD_TO_LIST(i->layer, pad, PCB_TYPE_ARC, &i->arc, FCT_COPPER)) longjmp(i->env, 1); return R_DIR_NOT_FOUND; } @@ -882,7 +882,7 @@ /* now check all polygons */ polylist_foreach(&(PCB->Data->Layer[layer].Polygon), &it, polygon) { if (!TEST_FLAG(TheFlag, polygon) && IsArcInPolygon(Arc, polygon) - && ADD_POLYGON_TO_LIST(layer, polygon, ARC_TYPE, Arc, FCT_COPPER)) + && ADD_POLYGON_TO_LIST(layer, polygon, PCB_TYPE_ARC, Arc, FCT_COPPER)) return true; } } @@ -903,7 +903,7 @@ struct lo_info *i = (struct lo_info *) cl; if (!TEST_FLAG(TheFlag, line) && LineLineIntersect(&i->line, line)) { - if (ADD_LINE_TO_LIST(i->layer, line, LINE_TYPE, &i->line, FCT_COPPER)) + if (ADD_LINE_TO_LIST(i->layer, line, PCB_TYPE_LINE, &i->line, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -917,7 +917,7 @@ if (!arc->Thickness) return 0; if (!TEST_FLAG(TheFlag, arc) && LineArcIntersect(&i->line, arc)) { - if (ADD_ARC_TO_LIST(i->layer, arc, LINE_TYPE, &i->line, FCT_COPPER)) + if (ADD_ARC_TO_LIST(i->layer, arc, PCB_TYPE_LINE, &i->line, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -931,12 +931,12 @@ if (!TEST_FLAG(TheFlag, rat)) { if ((rat->group1 == i->layer) && IsRatPointOnLineEnd(&rat->Point1, &i->line)) { - if (ADD_RAT_TO_LIST(rat, LINE_TYPE, &i->line, FCT_RAT)) + if (ADD_RAT_TO_LIST(rat, PCB_TYPE_LINE, &i->line, FCT_RAT)) longjmp(i->env, 1); } else if ((rat->group2 == i->layer) && IsRatPointOnLineEnd(&rat->Point2, &i->line)) { - if (ADD_RAT_TO_LIST(rat, LINE_TYPE, &i->line, FCT_RAT)) + if (ADD_RAT_TO_LIST(rat, PCB_TYPE_LINE, &i->line, FCT_RAT)) longjmp(i->env, 1); } } @@ -949,7 +949,7 @@ struct lo_info *i = (struct lo_info *) cl; if (!TEST_FLAG(TheFlag, pad) && i->layer == (TEST_FLAG(ONSOLDERFLAG, pad) ? SOLDER_LAYER : COMPONENT_LAYER) - && LinePadIntersect(&i->line, pad) && ADD_PAD_TO_LIST(i->layer, pad, LINE_TYPE, &i->line, FCT_COPPER)) + && LinePadIntersect(&i->line, pad) && ADD_PAD_TO_LIST(i->layer, pad, PCB_TYPE_LINE, &i->line, FCT_COPPER)) longjmp(i->env, 1); return R_DIR_NOT_FOUND; } @@ -1001,7 +1001,7 @@ polylist_foreach(&(PCB->Data->Layer[layer].Polygon), &it, polygon) { if (!TEST_FLAG(TheFlag, polygon) && IsLineInPolygon(Line, polygon) - && ADD_POLYGON_TO_LIST(layer, polygon, LINE_TYPE, Line, FCT_COPPER)) + && ADD_POLYGON_TO_LIST(layer, polygon, PCB_TYPE_LINE, Line, FCT_COPPER)) return true; } } @@ -1033,7 +1033,7 @@ if (!TEST_FLAG(TheFlag, line) && ((line->Point1.X == i->Point->X && line->Point1.Y == i->Point->Y) || (line->Point2.X == i->Point->X && line->Point2.Y == i->Point->Y))) { - if (ADD_LINE_TO_LIST(i->layer, line, RATLINE_TYPE, &i->Point, FCT_RAT)) + if (ADD_LINE_TO_LIST(i->layer, line, PCB_TYPE_RATLINE, &i->Point, FCT_RAT)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -1047,7 +1047,7 @@ if (!TEST_FLAG(TheFlag, polygon) && polygon->Clipped && (i->Point->X == polygon->Clipped->contours->head.point[0]) && (i->Point->Y == polygon->Clipped->contours->head.point[1])) { - if (ADD_POLYGON_TO_LIST(i->layer, polygon, RATLINE_TYPE, &i->Point, FCT_RAT)) + if (ADD_POLYGON_TO_LIST(i->layer, polygon, PCB_TYPE_RATLINE, &i->Point, FCT_RAT)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -1064,7 +1064,7 @@ (pad->Point2.X == i->Point->X && pad->Point2.Y == i->Point->Y) || ((pad->Point1.X + pad->Point2.X) / 2 == i->Point->X && (pad->Point1.Y + pad->Point2.Y) / 2 == i->Point->Y)) && - ADD_PAD_TO_LIST(i->layer, pad, RATLINE_TYPE, &i->Point, FCT_RAT)) + ADD_PAD_TO_LIST(i->layer, pad, PCB_TYPE_RATLINE, &i->Point, FCT_RAT)) longjmp(i->env, 1); return R_DIR_NOT_FOUND; } @@ -1119,7 +1119,7 @@ struct lo_info *i = (struct lo_info *) cl; if (!TEST_FLAG(TheFlag, line) && LinePadIntersect(line, &i->pad)) { - if (ADD_LINE_TO_LIST(i->layer, line, PAD_TYPE, &i->pad, FCT_COPPER)) + if (ADD_LINE_TO_LIST(i->layer, line, PCB_TYPE_PAD, &i->pad, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -1133,7 +1133,7 @@ if (!arc->Thickness) return 0; if (!TEST_FLAG(TheFlag, arc) && ArcPadIntersect(arc, &i->pad)) { - if (ADD_ARC_TO_LIST(i->layer, arc, PAD_TYPE, &i->pad, FCT_COPPER)) + if (ADD_ARC_TO_LIST(i->layer, arc, PCB_TYPE_PAD, &i->pad, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -1146,7 +1146,7 @@ if (!TEST_FLAG(TheFlag, polygon) && (!TEST_FLAG(CLEARPOLYFLAG, polygon) || !i->pad.Clearance)) { - if (IsPadInPolygon(&i->pad, polygon) && ADD_POLYGON_TO_LIST(i->layer, polygon, PAD_TYPE, &i->pad, FCT_COPPER)) + if (IsPadInPolygon(&i->pad, polygon) && ADD_POLYGON_TO_LIST(i->layer, polygon, PCB_TYPE_PAD, &i->pad, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -1163,7 +1163,7 @@ (rat->Point1.X == i->pad.Point2.X && rat->Point1.Y == i->pad.Point2.Y) || (rat->Point1.X == (i->pad.Point1.X + i->pad.Point2.X) / 2 && rat->Point1.Y == (i->pad.Point1.Y + i->pad.Point2.Y) / 2))) { - if (ADD_RAT_TO_LIST(rat, PAD_TYPE, &i->pad, FCT_RAT)) + if (ADD_RAT_TO_LIST(rat, PCB_TYPE_PAD, &i->pad, FCT_RAT)) longjmp(i->env, 1); } else if (rat->group2 == i->layer && @@ -1171,7 +1171,7 @@ (rat->Point2.X == i->pad.Point2.X && rat->Point2.Y == i->pad.Point2.Y) || (rat->Point2.X == (i->pad.Point1.X + i->pad.Point2.X) / 2 && rat->Point2.Y == (i->pad.Point1.Y + i->pad.Point2.Y) / 2))) { - if (ADD_RAT_TO_LIST(rat, PAD_TYPE, &i->pad, FCT_RAT)) + if (ADD_RAT_TO_LIST(rat, PCB_TYPE_PAD, &i->pad, FCT_RAT)) longjmp(i->env, 1); } } @@ -1184,7 +1184,7 @@ struct lo_info *i = (struct lo_info *) cl; if (!TEST_FLAG(TheFlag, pad) && i->layer == (TEST_FLAG(ONSOLDERFLAG, pad) ? SOLDER_LAYER : COMPONENT_LAYER) - && PadPadIntersect(pad, &i->pad) && ADD_PAD_TO_LIST(i->layer, pad, PAD_TYPE, &i->pad, FCT_COPPER)) + && PadPadIntersect(pad, &i->pad) && ADD_PAD_TO_LIST(i->layer, pad, PCB_TYPE_PAD, &i->pad, FCT_COPPER)) longjmp(i->env, 1); return R_DIR_NOT_FOUND; } @@ -1229,7 +1229,7 @@ /*fprintf(stderr, "layergroup1: %d {%d %d %d} %d \n", tlayer, TEST_FLAG(ONSOLDERFLAG, pad), SOLDER_LAYER, COMPONENT_LAYER, padlayer);*/ if ((!TEST_FLAG(TheFlag, pad)) && (tlayer != padlayer)) { /*fprintf(stderr, "layergroup2\n");*/ - ADD_PAD_TO_LIST(padlayer, pad, PAD_TYPE, orig_pad, FCT_INTERNAL); + ADD_PAD_TO_LIST(padlayer, pad, PCB_TYPE_PAD, orig_pad, FCT_INTERNAL); if (LookupLOConnectionsToPad(pad, LayerGroup)) retv = true; } @@ -1295,7 +1295,7 @@ struct lo_info *i = (struct lo_info *) cl; if (!TEST_FLAG(TheFlag, line) && IsLineInPolygon(line, &i->polygon)) { - if (ADD_LINE_TO_LIST(i->layer, line, POLYGON_TYPE, &i->polygon, FCT_COPPER)) + if (ADD_LINE_TO_LIST(i->layer, line, PCB_TYPE_POLYGON, &i->polygon, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -1309,7 +1309,7 @@ if (!arc->Thickness) return 0; if (!TEST_FLAG(TheFlag, arc) && IsArcInPolygon(arc, &i->polygon)) { - if (ADD_ARC_TO_LIST(i->layer, arc, POLYGON_TYPE, &i->polygon, FCT_COPPER)) + if (ADD_ARC_TO_LIST(i->layer, arc, PCB_TYPE_POLYGON, &i->polygon, FCT_COPPER)) longjmp(i->env, 1); } return 0; @@ -1322,7 +1322,7 @@ if (!TEST_FLAG(TheFlag, pad) && i->layer == (TEST_FLAG(ONSOLDERFLAG, pad) ? SOLDER_LAYER : COMPONENT_LAYER) && IsPadInPolygon(pad, &i->polygon)) { - if (ADD_PAD_TO_LIST(i->layer, pad, POLYGON_TYPE, &i->polygon, FCT_COPPER)) + if (ADD_PAD_TO_LIST(i->layer, pad, PCB_TYPE_POLYGON, &i->polygon, FCT_COPPER)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -1339,7 +1339,7 @@ rat->group1 == i->layer) || (rat->Point2.X == (i->polygon.Clipped->contours->head.point[0]) && rat->Point2.Y == (i->polygon.Clipped->contours->head.point[1]) && rat->group2 == i->layer)) - if (ADD_RAT_TO_LIST(rat, POLYGON_TYPE, &i->polygon, FCT_RAT)) + if (ADD_RAT_TO_LIST(rat, PCB_TYPE_POLYGON, &i->polygon, FCT_RAT)) longjmp(i->env, 1); } return R_DIR_NOT_FOUND; @@ -1380,7 +1380,7 @@ polylist_foreach(&(PCB->Data->Layer[layer].Polygon), &it, polygon) { if (!TEST_FLAG(TheFlag, polygon) && IsPolygonInPolygon(polygon, Polygon) - && ADD_POLYGON_TO_LIST(layer, polygon, POLYGON_TYPE, Polygon, FCT_COPPER)) + && ADD_POLYGON_TO_LIST(layer, polygon, PCB_TYPE_POLYGON, Polygon, FCT_COPPER)) return true; } Index: trunk/src/find_misc.c =================================================================== --- trunk/src/find_misc.c (revision 2502) +++ trunk/src/find_misc.c (revision 2503) @@ -151,8 +151,8 @@ { DumpList(); switch (type) { - case PIN_TYPE: - case VIA_TYPE: + case PCB_TYPE_PIN: + case PCB_TYPE_VIA: { if (ADD_PV_TO_LIST((PinTypePtr) ptr2, 0, NULL, FCT_START)) return true; @@ -159,7 +159,7 @@ break; } - case RATLINE_TYPE: + case PCB_TYPE_RATLINE: { if (ADD_RAT_TO_LIST((RatTypePtr) ptr1, 0, NULL, FCT_START)) return true; @@ -166,7 +166,7 @@ break; } - case LINE_TYPE: + case PCB_TYPE_LINE: { int layer = GetLayerNumber(PCB->Data, (LayerTypePtr) ptr1); @@ -176,7 +176,7 @@ break; } - case ARC_TYPE: + case PCB_TYPE_ARC: { int layer = GetLayerNumber(PCB->Data, (LayerTypePtr) ptr1); @@ -186,7 +186,7 @@ break; } - case POLYGON_TYPE: + case PCB_TYPE_POLYGON: { int layer = GetLayerNumber(PCB->Data, (LayerTypePtr) ptr1); @@ -196,7 +196,7 @@ break; } - case PAD_TYPE: + case PCB_TYPE_PAD: { PadTypePtr pad = (PadTypePtr) ptr2; if (ADD_PAD_TO_LIST(TEST_FLAG(ONSOLDERFLAG, pad) ? SOLDER_LAYER : COMPONENT_LAYER, pad, 0, NULL, FCT_START)) @@ -225,9 +225,9 @@ reassign_no_drc_flags(); type = SearchObjectByLocation(LOOKUP_FIRST, &ptr1, &ptr2, &ptr3, X, Y, Range); - if (type == NO_TYPE) { + if (type == PCB_TYPE_NONE) { type = SearchObjectByLocation(LOOKUP_MORE, &ptr1, &ptr2, &ptr3, X, Y, Range); - if (type == NO_TYPE) + if (type == PCB_TYPE_NONE) return; if (type & SILK_TYPE) { int laynum = GetLayerNumber(PCB->Data, @@ -288,7 +288,7 @@ { if (TEST_FLAG(TheFlag, via)) { if (AndDraw) - AddObjectToFlagUndoList(VIA_TYPE, via, via, via); + AddObjectToFlagUndoList(PCB_TYPE_VIA, via, via, via); CLEAR_FLAG(TheFlag, via); if (AndDraw) DrawVia(via); @@ -302,7 +302,7 @@ { if (TEST_FLAG(TheFlag, pin)) { if (AndDraw) - AddObjectToFlagUndoList(PIN_TYPE, element, pin, pin); + AddObjectToFlagUndoList(PCB_TYPE_PIN, element, pin, pin); CLEAR_FLAG(TheFlag, pin); if (AndDraw) DrawPin(pin); @@ -314,7 +314,7 @@ { if (TEST_FLAG(TheFlag, pad)) { if (AndDraw) - AddObjectToFlagUndoList(PAD_TYPE, element, pad, pad); + AddObjectToFlagUndoList(PCB_TYPE_PAD, element, pad, pad); CLEAR_FLAG(TheFlag, pad); if (AndDraw) DrawPad(pad); @@ -340,7 +340,7 @@ { if (TEST_FLAG(TheFlag, line)) { if (AndDraw) - AddObjectToFlagUndoList(RATLINE_TYPE, line, line, line); + AddObjectToFlagUndoList(PCB_TYPE_RATLINE, line, line, line); CLEAR_FLAG(TheFlag, line); if (AndDraw) DrawRat(line); @@ -352,7 +352,7 @@ { if (TEST_FLAG(TheFlag, line)) { if (AndDraw) - AddObjectToFlagUndoList(LINE_TYPE, layer, line, line); + AddObjectToFlagUndoList(PCB_TYPE_LINE, layer, line, line); CLEAR_FLAG(TheFlag, line); if (AndDraw) DrawLine(layer, line); @@ -364,7 +364,7 @@ { if (TEST_FLAG(TheFlag, arc)) { if (AndDraw) - AddObjectToFlagUndoList(ARC_TYPE, layer, arc, arc); + AddObjectToFlagUndoList(PCB_TYPE_ARC, layer, arc, arc); CLEAR_FLAG(TheFlag, arc); if (AndDraw) DrawArc(layer, arc); @@ -376,7 +376,7 @@ { if (TEST_FLAG(TheFlag, polygon)) { if (AndDraw) - AddObjectToFlagUndoList(POLYGON_TYPE, layer, polygon, polygon); + AddObjectToFlagUndoList(PCB_TYPE_POLYGON, layer, polygon, polygon); CLEAR_FLAG(TheFlag, polygon); if (AndDraw) DrawPolygon(layer, polygon); Index: trunk/src/find_print.c =================================================================== --- trunk/src/find_print.c (revision 2502) +++ trunk/src/find_print.c (revision 2503) @@ -170,7 +170,7 @@ fputs("\t\t__CHECKED_BEFORE__\n\t}\n", FP); continue; } - if (ADD_PV_TO_LIST(pin, ELEMENT_TYPE, Element, FCT_ELEMENT)) + if (ADD_PV_TO_LIST(pin, PCB_TYPE_ELEMENT, Element, FCT_ELEMENT)) return true; DoIt(true, AndDraw); /* printout all found connections */ @@ -194,7 +194,7 @@ continue; } layer = TEST_FLAG(ONSOLDERFLAG, pad) ? SOLDER_LAYER : COMPONENT_LAYER; - if (ADD_PAD_TO_LIST(layer, pad, ELEMENT_TYPE, Element, FCT_ELEMENT)) + if (ADD_PAD_TO_LIST(layer, pad, PCB_TYPE_ELEMENT, Element, FCT_ELEMENT)) return true; DoIt(true, AndDraw); /* print all found connections */ Index: trunk/src/gui_act.c =================================================================== --- trunk/src/gui_act.c (revision 2502) +++ trunk/src/gui_act.c (revision 2503) @@ -421,7 +421,7 @@ Coord x, y; gui->get_coords(_("Click on an element"), &x, &y); - if ((SearchScreen(x, y, ELEMENT_TYPE, &ptrtmp, &ptrtmp, &ptrtmp)) != NO_TYPE) { + if ((SearchScreen(x, y, PCB_TYPE_ELEMENT, &ptrtmp, &ptrtmp, &ptrtmp)) != PCB_TYPE_NONE) { element = (ElementTypePtr) ptrtmp; gui->show_item(element); } @@ -436,9 +436,9 @@ gui->get_coords(_("Click on an element"), &x, &y); switch (SearchScreen(x, y, - ELEMENT_TYPE | PIN_TYPE | PAD_TYPE | - VIA_TYPE, (void **) &ptr1, (void **) &ptr2, (void **) &ptr3)) { - case ELEMENT_TYPE: + PCB_TYPE_ELEMENT | PCB_TYPE_PIN | PCB_TYPE_PAD | + PCB_TYPE_VIA, (void **) &ptr1, (void **) &ptr2, (void **) &ptr3)) { + case PCB_TYPE_ELEMENT: PIN_LOOP((ElementTypePtr) ptr1); { if (TEST_FLAG(DISPLAYNAMEFLAG, pin)) @@ -445,7 +445,7 @@ ErasePinName(pin); else DrawPinName(pin); - AddObjectToFlagUndoList(PIN_TYPE, ptr1, pin, pin); + AddObjectToFlagUndoList(PCB_TYPE_PIN, ptr1, pin, pin); TOGGLE_FLAG(DISPLAYNAMEFLAG, pin); } END_LOOP; @@ -455,7 +455,7 @@ ErasePadName(pad); else DrawPadName(pad); - AddObjectToFlagUndoList(PAD_TYPE, ptr1, pad, pad); + AddObjectToFlagUndoList(PCB_TYPE_PAD, ptr1, pad, pad); TOGGLE_FLAG(DISPLAYNAMEFLAG, pad); } END_LOOP; @@ -464,12 +464,12 @@ Draw(); break; - case PIN_TYPE: + case PCB_TYPE_PIN: if (TEST_FLAG(DISPLAYNAMEFLAG, (PinTypePtr) ptr2)) ErasePinName((PinTypePtr) ptr2); else DrawPinName((PinTypePtr) ptr2); - AddObjectToFlagUndoList(PIN_TYPE, ptr1, ptr2, ptr3); + AddObjectToFlagUndoList(PCB_TYPE_PIN, ptr1, ptr2, ptr3); TOGGLE_FLAG(DISPLAYNAMEFLAG, (PinTypePtr) ptr2); SetChangedFlag(true); IncrementUndoSerialNumber(); @@ -476,23 +476,23 @@ Draw(); break; - case PAD_TYPE: + case PCB_TYPE_PAD: if (TEST_FLAG(DISPLAYNAMEFLAG, (PadTypePtr) ptr2)) ErasePadName((PadTypePtr) ptr2); else DrawPadName((PadTypePtr) ptr2); - AddObjectToFlagUndoList(PAD_TYPE, ptr1, ptr2, ptr3); + AddObjectToFlagUndoList(PCB_TYPE_PAD, ptr1, ptr2, ptr3); TOGGLE_FLAG(DISPLAYNAMEFLAG, (PadTypePtr) ptr2); SetChangedFlag(true); IncrementUndoSerialNumber(); Draw(); break; - case VIA_TYPE: + case PCB_TYPE_VIA: if (TEST_FLAG(DISPLAYNAMEFLAG, (PinTypePtr) ptr2)) EraseViaName((PinTypePtr) ptr2); else DrawViaName((PinTypePtr) ptr2); - AddObjectToFlagUndoList(VIA_TYPE, ptr1, ptr2, ptr3); + AddObjectToFlagUndoList(PCB_TYPE_VIA, ptr1, ptr2, ptr3); TOGGLE_FLAG(DISPLAYNAMEFLAG, (PinTypePtr) ptr2); SetChangedFlag(true); IncrementUndoSerialNumber(); @@ -797,11 +797,11 @@ over++; } - if (SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Crosshair.drags[Crosshair.drags_current], LINE_TYPE) != NO_TYPE) { + if (SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Crosshair.drags[Crosshair.drags_current], PCB_TYPE_LINE) != PCB_TYPE_NONE) { /* line has two endpoints, check which one is close to the original x;y */ LineType *l = ptr2; if (close_enough(Note.X, l->Point1.X) && close_enough(Note.Y, l->Point1.Y)) { - Crosshair.AttachedObject.Type = LINEPOINT_TYPE; + Crosshair.AttachedObject.Type = PCB_TYPE_LINE_POINT; Crosshair.AttachedObject.Ptr1 = ptr1; Crosshair.AttachedObject.Ptr2 = ptr2; Crosshair.AttachedObject.Ptr3 = &l->Point1; @@ -808,7 +808,7 @@ return 0; } if (close_enough(Note.X, l->Point2.X) && close_enough(Note.Y, l->Point2.Y)) { - Crosshair.AttachedObject.Type = LINEPOINT_TYPE; + Crosshair.AttachedObject.Type = PCB_TYPE_LINE_POINT; Crosshair.AttachedObject.Ptr1 = ptr1; Crosshair.AttachedObject.Ptr2 = ptr2; Crosshair.AttachedObject.Ptr3 = &l->Point2; @@ -815,22 +815,22 @@ return 0; } } - else if (SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Crosshair.drags[Crosshair.drags_current], VIA_TYPE) != NO_TYPE) { - Crosshair.AttachedObject.Type = VIA_TYPE; + else if (SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Crosshair.drags[Crosshair.drags_current], PCB_TYPE_VIA) != PCB_TYPE_NONE) { + Crosshair.AttachedObject.Type = PCB_TYPE_VIA; Crosshair.AttachedObject.Ptr1 = ptr1; Crosshair.AttachedObject.Ptr2 = ptr2; Crosshair.AttachedObject.Ptr3 = ptr3; return 0; } - else if (SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Crosshair.drags[Crosshair.drags_current], PAD_TYPE) != NO_TYPE) { - Crosshair.AttachedObject.Type = ELEMENT_TYPE; + else if (SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Crosshair.drags[Crosshair.drags_current], PCB_TYPE_PAD) != PCB_TYPE_NONE) { + Crosshair.AttachedObject.Type = PCB_TYPE_ELEMENT; Crosshair.AttachedObject.Ptr1 = ptr1; Crosshair.AttachedObject.Ptr2 = ptr1; Crosshair.AttachedObject.Ptr3 = ptr1; return 0; } - else if (SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Crosshair.drags[Crosshair.drags_current], ARC_TYPE) != NO_TYPE) { - Crosshair.AttachedObject.Type = ARC_TYPE; + else if (SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Crosshair.drags[Crosshair.drags_current], PCB_TYPE_ARC) != PCB_TYPE_NONE) { + Crosshair.AttachedObject.Type = PCB_TYPE_ARC; Crosshair.AttachedObject.Ptr1 = ptr1; Crosshair.AttachedObject.Ptr2 = ptr2; Crosshair.AttachedObject.Ptr3 = ptr3; @@ -898,7 +898,7 @@ void *ptr1, *ptr2, *ptr3; gui->get_coords(_("Select an Object"), &x, &y); - if ((type = SearchScreen(x, y, ELEMENT_TYPE, &ptr1, &ptr2, &ptr3)) != NO_TYPE) { + if ((type = SearchScreen(x, y, PCB_TYPE_ELEMENT, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) { AddObjectToFlagUndoList(type, ptr1, ptr2, ptr3); EraseElementName((ElementTypePtr) ptr2); TOGGLE_FLAG(HIDENAMEFLAG, (ElementTypePtr) ptr2); @@ -916,7 +916,7 @@ { if ((TEST_FLAG(SELECTEDFLAG, element) || TEST_FLAG(SELECTEDFLAG, &NAMEONPCB_TEXT(element))) && (FRONT(element) || PCB->InvisibleObjectsOn)) { - AddObjectToFlagUndoList(ELEMENT_TYPE, element, element, element); + AddObjectToFlagUndoList(PCB_TYPE_ELEMENT, element, element, element); EraseElementName(element); TOGGLE_FLAG(HIDENAMEFLAG, element); DrawElementName(element); @@ -1059,7 +1059,7 @@ type = SearchScreen(x, y, CLONE_TYPES, &ptr1, &ptr2, &ptr3); /* set layer current and size from line or arc */ switch (type) { - case LINE_TYPE: + case PCB_TYPE_LINE: notify_crosshair_change(false); conf_set_design("design/line_thickness", "%$mS", ((LineTypePtr) ptr2)->Thickness); conf_set_design("design/clearance", "%$mS", ((LineTypePtr) ptr2)->Clearance / 2); @@ -1070,7 +1070,7 @@ hid_action("RouteStylesChanged"); break; - case ARC_TYPE: + case PCB_TYPE_ARC: notify_crosshair_change(false); conf_set_design("design/line_thickness", "%$mS", ((ArcTypePtr) ptr2)->Thickness); conf_set_design("design/clearance", "%$mS", ((ArcTypePtr) ptr2)->Clearance / 2); @@ -1081,11 +1081,11 @@ hid_action("RouteStylesChanged"); break; - case POLYGON_TYPE: + case PCB_TYPE_POLYGON: layer = (LayerTypePtr) ptr1; break; - case VIA_TYPE: + case PCB_TYPE_VIA: notify_crosshair_change(false); conf_set_design("design/via_thickness", "%$mS", ((PinTypePtr) ptr2)->Thickness); conf_set_design("design/via_drilling_hole", "%$mS", ((PinTypePtr) ptr2)->DrillingHole); Index: trunk/src/insert.c =================================================================== --- trunk/src/insert.c (revision 2502) +++ trunk/src/insert.c (revision 2503) @@ -85,16 +85,16 @@ InsertX, InsertY, conf_core.design.line_thickness, 2 * conf_core.design.clearance, Rat->Flags); if (!newone) return newone; - AddObjectToCreateUndoList(LINE_TYPE, CURRENT, newone, newone); + AddObjectToCreateUndoList(PCB_TYPE_LINE, CURRENT, newone, newone); EraseRat(Rat); DrawLine(CURRENT, newone); newone = CreateDrawnLineOnLayer(CURRENT, Rat->Point2.X, Rat->Point2.Y, InsertX, InsertY, conf_core.design.line_thickness, 2 * conf_core.design.clearance, Rat->Flags); if (newone) { - AddObjectToCreateUndoList(LINE_TYPE, CURRENT, newone, newone); + AddObjectToCreateUndoList(PCB_TYPE_LINE, CURRENT, newone, newone); DrawLine(CURRENT, newone); } - MoveObjectToRemoveUndoList(RATLINE_TYPE, Rat, Rat, Rat); + MoveObjectToRemoveUndoList(PCB_TYPE_RATLINE, Rat, Rat, Rat); Draw(); return (newone); } @@ -112,23 +112,23 @@ return (NULL); X = Line->Point2.X; Y = Line->Point2.Y; - AddObjectToMoveUndoList(LINEPOINT_TYPE, Layer, Line, &Line->Point2, InsertX - X, InsertY - Y); + AddObjectToMoveUndoList(PCB_TYPE_LINE_POINT, Layer, Line, &Line->Point2, InsertX - X, InsertY - Y); EraseLine(Line); r_delete_entry(Layer->line_tree, (BoxTypePtr) Line); - RestoreToPolygon(PCB->Data, LINE_TYPE, Layer, Line); + RestoreToPolygon(PCB->Data, PCB_TYPE_LINE, Layer, Line); Line->Point2.X = InsertX; Line->Point2.Y = InsertY; SetLineBoundingBox(Line); r_insert_entry(Layer->line_tree, (BoxTypePtr) Line, 0); - ClearFromPolygon(PCB->Data, LINE_TYPE, Layer, Line); + ClearFromPolygon(PCB->Data, PCB_TYPE_LINE, Layer, Line); DrawLine(Layer, Line); /* we must create after playing with Line since creation may * invalidate the line pointer */ if ((line = CreateDrawnLineOnLayer(Layer, InsertX, InsertY, X, Y, Line->Thickness, Line->Clearance, Line->Flags))) { - AddObjectToCreateUndoList(LINE_TYPE, Layer, line, line); + AddObjectToCreateUndoList(PCB_TYPE_LINE, Layer, line, line); DrawLine(Layer, line); - ClearFromPolygon(PCB->Data, LINE_TYPE, Layer, line); + ClearFromPolygon(PCB->Data, PCB_TYPE_LINE, Layer, line); /* creation call adds it to the rtree */ } Draw(); @@ -170,7 +170,7 @@ Polygon->Points[InsertAt] = save; SetChangedFlag(true); - AddObjectToInsertPointUndoList(POLYGONPOINT_TYPE, Layer, Polygon, &Polygon->Points[InsertAt]); + AddObjectToInsertPointUndoList(PCB_TYPE_POLYGON_POINT, Layer, Polygon, &Polygon->Points[InsertAt]); SetPolygonBoundingBox(Polygon); r_insert_entry(Layer->polygon_tree, (BoxType *) Polygon, 0); Index: trunk/src/insert.h =================================================================== --- trunk/src/insert.h (revision 2502) +++ trunk/src/insert.h (revision 2503) @@ -31,7 +31,7 @@ #include "global.h" -#define INSERT_TYPES (POLYGON_TYPE | LINE_TYPE | RATLINE_TYPE) +#define INSERT_TYPES (PCB_TYPE_POLYGON | PCB_TYPE_LINE | PCB_TYPE_RATLINE) /* --------------------------------------------------------------------------- * prototypes Index: trunk/src/mirror.c =================================================================== --- trunk/src/mirror.c (revision 2502) +++ trunk/src/mirror.c (revision 2503) @@ -57,7 +57,7 @@ END_LOOP; PIN_LOOP(Element); { - RestoreToPolygon(Data, PIN_TYPE, Element, pin); + RestoreToPolygon(Data, PCB_TYPE_PIN, Element, pin); pin->X = SWAP_X(pin->X); pin->Y = SWAP_Y(pin->Y) + yoff; } @@ -64,7 +64,7 @@ END_LOOP; PAD_LOOP(Element); { - RestoreToPolygon(Data, PAD_TYPE, Element, pad); + RestoreToPolygon(Data, PCB_TYPE_PAD, Element, pad); pad->Point1.X = SWAP_X(pad->Point1.X); pad->Point1.Y = SWAP_Y(pad->Point1.Y) + yoff; pad->Point2.X = SWAP_X(pad->Point2.X); @@ -94,5 +94,5 @@ TOGGLE_FLAG(ONSOLDERFLAG, Element); /* this inserts all of the rtree data too */ SetElementBoundingBox(Data, Element, &PCB->Font); - ClearFromPolygon(Data, ELEMENT_TYPE, Element, Element); + ClearFromPolygon(Data, PCB_TYPE_ELEMENT, Element, Element); } Index: trunk/src/mirror.h =================================================================== --- trunk/src/mirror.h (revision 2502) +++ trunk/src/mirror.h (revision 2503) @@ -36,7 +36,7 @@ */ #define MIRROR(object) TOGGLE_FLAG(MIRRORFLAG, (object)) -#define MIRROR_TYPES (TEXT_TYPE | ELEMENTNAME_TYPE) +#define MIRROR_TYPES (PCB_TYPE_TEXT | PCB_TYPE_ELEMENT_NAME) void MirrorElementCoordinates(DataTypePtr, ElementTypePtr, Coord); Index: trunk/src/misc.c =================================================================== --- trunk/src/misc.c (revision 2502) +++ trunk/src/misc.c (revision 2503) @@ -1091,19 +1091,19 @@ BoxTypePtr GetObjectBoundingBox(int Type, void *Ptr1, void *Ptr2, void *Ptr3) { switch (Type) { - case LINE_TYPE: - case ARC_TYPE: - case TEXT_TYPE: - case POLYGON_TYPE: - case PAD_TYPE: - case PIN_TYPE: - case ELEMENTNAME_TYPE: + case PCB_TYPE_LINE: + case PCB_TYPE_ARC: + case PCB_TYPE_TEXT: + case PCB_TYPE_POLYGON: + case PCB_TYPE_PAD: + case PCB_TYPE_PIN: + case PCB_TYPE_ELEMENT_NAME: return (BoxType *) Ptr2; - case VIA_TYPE: - case ELEMENT_TYPE: + case PCB_TYPE_VIA: + case PCB_TYPE_ELEMENT: return (BoxType *) Ptr1; - case POLYGONPOINT_TYPE: - case LINEPOINT_TYPE: + case PCB_TYPE_POLYGON_POINT: + case PCB_TYPE_LINE_POINT: return (BoxType *) Ptr3; default: Message("Request for bounding box of unsupported type %d\n", Type); @@ -1280,14 +1280,14 @@ new_da = 360; new_sa = 0; } - RestoreToPolygon(PCB->Data, ARC_TYPE, Layer, a); + RestoreToPolygon(PCB->Data, PCB_TYPE_ARC, Layer, a); r_delete_entry(Layer->arc_tree, (BoxTypePtr) a); - AddObjectToChangeAnglesUndoList(ARC_TYPE, a, a, a); + AddObjectToChangeAnglesUndoList(PCB_TYPE_ARC, a, a, a); a->StartAngle = new_sa; a->Delta = new_da; SetArcBoundingBox(a); r_insert_entry(Layer->arc_tree, (BoxTypePtr) a, 0); - ClearFromPolygon(PCB->Data, ARC_TYPE, Layer, a); + ClearFromPolygon(PCB->Data, PCB_TYPE_ARC, Layer, a); } static char *BumpName(char *Name) @@ -1346,34 +1346,34 @@ static void GetGridLockCoordinates(int type, void *ptr1, void *ptr2, void *ptr3, Coord * x, Coord * y) { switch (type) { - case VIA_TYPE: + case PCB_TYPE_VIA: *x = ((PinTypePtr) ptr2)->X; *y = ((PinTypePtr) ptr2)->Y; break; - case LINE_TYPE: + case PCB_TYPE_LINE: *x = ((LineTypePtr) ptr2)->Point1.X; *y = ((LineTypePtr) ptr2)->Point1.Y; break; - case TEXT_TYPE: - case ELEMENTNAME_TYPE: + case PCB_TYPE_TEXT: + case PCB_TYPE_ELEMENT_NAME: *x = ((TextTypePtr) ptr2)->X; *y = ((TextTypePtr) ptr2)->Y; break; - case ELEMENT_TYPE: + case PCB_TYPE_ELEMENT: *x = ((ElementTypePtr) ptr2)->MarkX; *y = ((ElementTypePtr) ptr2)->MarkY; break; - case POLYGON_TYPE: + case PCB_TYPE_POLYGON: *x = ((PolygonTypePtr) ptr2)->Points[0].X; *y = ((PolygonTypePtr) ptr2)->Points[0].Y; break; - case LINEPOINT_TYPE: - case POLYGONPOINT_TYPE: + case PCB_TYPE_LINE_POINT: + case PCB_TYPE_POLYGON_POINT: *x = ((PointTypePtr) ptr3)->X; *y = ((PointTypePtr) ptr3)->Y; break; - case ARC_TYPE: + case PCB_TYPE_ARC: { BoxTypePtr box; @@ -1420,9 +1420,9 @@ LookupRubberbandLines(Crosshair.AttachedObject.Type, Crosshair.AttachedObject.Ptr1, Crosshair.AttachedObject.Ptr2, Crosshair.AttachedObject.Ptr3); if (conf_core.editor.mode != COPY_MODE && - (Crosshair.AttachedObject.Type == ELEMENT_TYPE || - Crosshair.AttachedObject.Type == VIA_TYPE || - Crosshair.AttachedObject.Type == LINE_TYPE || Crosshair.AttachedObject.Type == LINEPOINT_TYPE)) + (Crosshair.AttachedObject.Type == PCB_TYPE_ELEMENT || + Crosshair.AttachedObject.Type == PCB_TYPE_VIA || + Crosshair.AttachedObject.Type == PCB_TYPE_LINE || Crosshair.AttachedObject.Type == PCB_TYPE_LINE_POINT)) LookupRatLines(Crosshair.AttachedObject.Type, Crosshair.AttachedObject.Ptr1, Crosshair.AttachedObject.Ptr2, Crosshair.AttachedObject.Ptr3); } Index: trunk/src/move.c =================================================================== --- trunk/src/move.c (revision 2502) +++ trunk/src/move.c (revision 2503) @@ -104,12 +104,12 @@ { if (Data) { r_delete_entry(Data->pin_tree, (BoxType *) pin); - RestoreToPolygon(Data, PIN_TYPE, Element, pin); + RestoreToPolygon(Data, PCB_TYPE_PIN, Element, pin); } MOVE_PIN_LOWLEVEL(pin, DX, DY); if (Data) { r_insert_entry(Data->pin_tree, (BoxType *) pin, 0); - ClearFromPolygon(Data, PIN_TYPE, Element, pin); + ClearFromPolygon(Data, PCB_TYPE_PIN, Element, pin); } } END_LOOP; @@ -117,12 +117,12 @@ { if (Data) { r_delete_entry(Data->pad_tree, (BoxType *) pad); - RestoreToPolygon(Data, PAD_TYPE, Element, pad); + RestoreToPolygon(Data, PCB_TYPE_PAD, Element, pad); } MOVE_PAD_LOWLEVEL(pad, DX, DY); if (Data) { r_insert_entry(Data->pad_tree, (BoxType *) pad, 0); - ClearFromPolygon(Data, PAD_TYPE, Element, pad); + ClearFromPolygon(Data, PCB_TYPE_PAD, Element, pad); } } END_LOOP; @@ -221,12 +221,12 @@ static void *MoveVia(PinTypePtr Via) { r_delete_entry(PCB->Data->via_tree, (BoxType *) Via); - RestoreToPolygon(PCB->Data, VIA_TYPE, Via, Via); + RestoreToPolygon(PCB->Data, PCB_TYPE_VIA, Via, Via); MOVE_VIA_LOWLEVEL(Via, DeltaX, DeltaY); if (PCB->ViaOn) EraseVia(Via); r_insert_entry(PCB->Data->via_tree, (BoxType *) Via, 0); - ClearFromPolygon(PCB->Data, VIA_TYPE, Via, Via); + ClearFromPolygon(PCB->Data, PCB_TYPE_VIA, Via, Via); if (PCB->ViaOn) { DrawVia(Via); Draw(); @@ -241,11 +241,11 @@ { if (Layer->On) EraseLine(Line); - RestoreToPolygon(PCB->Data, LINE_TYPE, Layer, Line); + RestoreToPolygon(PCB->Data, PCB_TYPE_LINE, Layer, Line); r_delete_entry(Layer->line_tree, (BoxType *) Line); MOVE_LINE_LOWLEVEL(Line, DeltaX, DeltaY); r_insert_entry(Layer->line_tree, (BoxType *) Line, 0); - ClearFromPolygon(PCB->Data, LINE_TYPE, Layer, Line); + ClearFromPolygon(PCB->Data, PCB_TYPE_LINE, Layer, Line); if (Layer->On) { DrawLine(Layer, Line); Draw(); @@ -258,7 +258,7 @@ */ static void *MoveArc(LayerTypePtr Layer, ArcTypePtr Arc) { - RestoreToPolygon(PCB->Data, ARC_TYPE, Layer, Arc); + RestoreToPolygon(PCB->Data, PCB_TYPE_ARC, Layer, Arc); r_delete_entry(Layer->arc_tree, (BoxType *) Arc); if (Layer->On) { EraseArc(Arc); @@ -270,7 +270,7 @@ MOVE_ARC_LOWLEVEL(Arc, DeltaX, DeltaY); } r_insert_entry(Layer->arc_tree, (BoxType *) Arc, 0); - ClearFromPolygon(PCB->Data, ARC_TYPE, Layer, Arc); + ClearFromPolygon(PCB->Data, PCB_TYPE_ARC, Layer, Arc); return (Arc); } @@ -279,7 +279,7 @@ */ static void *MoveText(LayerTypePtr Layer, TextTypePtr Text) { - RestoreToPolygon(PCB->Data, TEXT_TYPE, Layer, Text); + RestoreToPolygon(PCB->Data, PCB_TYPE_TEXT, Layer, Text); r_delete_entry(Layer->text_tree, (BoxType *) Text); if (Layer->On) { EraseText(Layer, Text); @@ -290,7 +290,7 @@ else MOVE_TEXT_LOWLEVEL(Text, DeltaX, DeltaY); r_insert_entry(Layer->text_tree, (BoxType *) Text, 0); - ClearFromPolygon(PCB->Data, TEXT_TYPE, Layer, Text); + ClearFromPolygon(PCB->Data, PCB_TYPE_TEXT, Layer, Text); return (Text); } @@ -334,12 +334,12 @@ if (Layer) { if (Layer->On) EraseLine(Line); - RestoreToPolygon(PCB->Data, LINE_TYPE, Layer, Line); + RestoreToPolygon(PCB->Data, PCB_TYPE_LINE, Layer, Line); r_delete_entry(Layer->line_tree, &Line->BoundingBox); MOVE(Point->X, Point->Y, DeltaX, DeltaY); SetLineBoundingBox(Line); r_insert_entry(Layer->line_tree, &Line->BoundingBox, 0); - ClearFromPolygon(PCB->Data, LINE_TYPE, Layer, Line); + ClearFromPolygon(PCB->Data, PCB_TYPE_LINE, Layer, Line); if (Layer->On) { DrawLine(Layer, Line); Draw(); @@ -433,12 +433,12 @@ } if (((long int) Dest == -1) || Dest == Layer) return (Arc); - AddObjectToMoveToLayerUndoList(ARC_TYPE, Layer, Arc, Arc); - RestoreToPolygon(PCB->Data, ARC_TYPE, Layer, Arc); + AddObjectToMoveToLayerUndoList(PCB_TYPE_ARC, Layer, Arc, Arc); + RestoreToPolygon(PCB->Data, PCB_TYPE_ARC, Layer, Arc); if (Layer->On) EraseArc(Arc); newone = (ArcTypePtr) MoveArcToLayerLowLevel(Layer, Arc, Dest); - ClearFromPolygon(PCB->Data, ARC_TYPE, Dest, Arc); + ClearFromPolygon(PCB->Data, PCB_TYPE_ARC, Dest, Arc); if (Dest->On) DrawArc(Dest, newone); Draw(); @@ -464,10 +464,10 @@ conf_set_editor(clear_line, 1); if (!newone) return (NULL); - AddObjectToCreateUndoList(LINE_TYPE, Dest, newone, newone); + AddObjectToCreateUndoList(PCB_TYPE_LINE, Dest, newone, newone); if (PCB->RatOn) EraseRat(Rat); - MoveObjectToRemoveUndoList(RATLINE_TYPE, Rat, Rat, Rat); + MoveObjectToRemoveUndoList(PCB_TYPE_RATLINE, Rat, Rat, Rat); DrawLine(Dest, newone); Draw(); return (newone); @@ -490,7 +490,7 @@ if ((via = CreateNewVia(PCB->Data, i->X, i->Y, conf_core.design.via_thickness, 2 * conf_core.design.clearance, NOFLAG, conf_core.design.via_drilling_hole, NULL, NoFlags())) != NULL) { - AddObjectToCreateUndoList(VIA_TYPE, via, via, via); + AddObjectToCreateUndoList(PCB_TYPE_VIA, via, via, via); DrawVia(via); } longjmp(i->env, 1); @@ -514,13 +514,13 @@ if (((long int) Dest == -1) || Dest == Layer) return (Line); - AddObjectToMoveToLayerUndoList(LINE_TYPE, Layer, Line, Line); + AddObjectToMoveToLayerUndoList(PCB_TYPE_LINE, Layer, Line, Line); if (Layer->On) EraseLine(Line); - RestoreToPolygon(PCB->Data, LINE_TYPE, Layer, Line); + RestoreToPolygon(PCB->Data, PCB_TYPE_LINE, Layer, Line); newone = (LineTypePtr) MoveLineToLayerLowLevel(Layer, Line, Dest); Line = NULL; - ClearFromPolygon(PCB->Data, LINE_TYPE, Dest, newone); + ClearFromPolygon(PCB->Data, PCB_TYPE_LINE, Dest, newone); if (Dest->On) DrawLine(Dest, newone); Draw(); @@ -533,8 +533,8 @@ sb.X2 = newone->Point1.X + newone->Thickness / 2; sb.Y1 = newone->Point1.Y - newone->Thickness / 2; sb.Y2 = newone->Point1.Y + newone->Thickness / 2; - if ((SearchObjectByLocation(PIN_TYPES, &ptr1, &ptr2, &ptr3, - newone->Point1.X, newone->Point1.Y, conf_core.design.via_thickness / 2) == NO_TYPE)) { + if ((SearchObjectByLocation(PCB_TYPEMASK_PIN, &ptr1, &ptr2, &ptr3, + newone->Point1.X, newone->Point1.Y, conf_core.design.via_thickness / 2) == PCB_TYPE_NONE)) { info.X = newone->Point1.X; info.Y = newone->Point1.Y; if (setjmp(info.env) == 0) @@ -545,8 +545,8 @@ sb.X2 = newone->Point2.X + newone->Thickness / 2; sb.Y1 = newone->Point2.Y - newone->Thickness / 2; sb.Y2 = newone->Point2.Y + newone->Thickness / 2; - if ((SearchObjectByLocation(PIN_TYPES, &ptr1, &ptr2, &ptr3, - newone->Point2.X, newone->Point2.Y, conf_core.design.via_thickness / 2) == NO_TYPE)) { + if ((SearchObjectByLocation(PCB_TYPEMASK_PIN, &ptr1, &ptr2, &ptr3, + newone->Point2.X, newone->Point2.Y, conf_core.design.via_thickness / 2) == PCB_TYPE_NONE)) { info.X = newone->Point2.X; info.Y = newone->Point2.Y; if (setjmp(info.env) == 0) @@ -561,7 +561,7 @@ */ static void *MoveTextToLayerLowLevel(LayerType * Source, TextType * text, LayerType * Destination) { - RestoreToPolygon(PCB->Data, TEXT_TYPE, Source, text); + RestoreToPolygon(PCB->Data, PCB_TYPE_TEXT, Source, text); r_delete_entry(Source->text_tree, (BoxType *) text); textlist_remove(text); @@ -577,7 +577,7 @@ if (!Destination->text_tree) Destination->text_tree = r_create_tree(NULL, 0, 0); r_insert_entry(Destination->text_tree, (BoxType *) text, 0); - ClearFromPolygon(PCB->Data, TEXT_TYPE, Destination, text); + ClearFromPolygon(PCB->Data, PCB_TYPE_TEXT, Destination, text); return text; } @@ -592,7 +592,7 @@ return NULL; } if (Dest != layer) { - AddObjectToMoveToLayerUndoList(TEXT_TYPE, layer, text, text); + AddObjectToMoveToLayerUndoList(PCB_TYPE_TEXT, layer, text, text); if (layer->On) EraseText(layer, text); text = MoveTextToLayerLowLevel(layer, text, Dest); @@ -633,10 +633,10 @@ PinTypePtr pin = (PinTypePtr) b; if (!TEST_THERM(d->snum, pin) || !IsPointInPolygon(pin->X, pin->Y, pin->Thickness + pin->Clearance + 2, d->polygon)) return R_DIR_NOT_FOUND; - if (d->type == PIN_TYPE) - AddObjectToFlagUndoList(PIN_TYPE, pin->Element, pin, pin); + if (d->type == PCB_TYPE_PIN) + AddObjectToFlagUndoList(PCB_TYPE_PIN, pin->Element, pin, pin); else - AddObjectToFlagUndoList(VIA_TYPE, pin, pin, pin); + AddObjectToFlagUndoList(PCB_TYPE_VIA, pin, pin, pin); ASSIGN_THERM(d->dnum, GET_THERM(d->snum, pin), pin); CLEAR_THERM(d->snum, pin); return R_DIR_FOUND_CONTINUE; @@ -656,7 +656,7 @@ } if (((long int) Dest == -1) || (Layer == Dest)) return (Polygon); - AddObjectToMoveToLayerUndoList(POLYGON_TYPE, Layer, Polygon, Polygon); + AddObjectToMoveToLayerUndoList(PCB_TYPE_POLYGON, Layer, Polygon, Polygon); if (Layer->On) ErasePolygon(Polygon); /* Move all of the thermals with the polygon */ @@ -663,9 +663,9 @@ d.snum = GetLayerNumber(PCB->Data, Layer); d.dnum = GetLayerNumber(PCB->Data, Dest); d.polygon = Polygon; - d.type = PIN_TYPE; + d.type = PCB_TYPE_PIN; r_search(PCB->Data->pin_tree, &Polygon->BoundingBox, NULL, mptl_pin_callback, &d, NULL); - d.type = VIA_TYPE; + d.type = PCB_TYPE_VIA; r_search(PCB->Data->via_tree, &Polygon->BoundingBox, NULL, mptl_pin_callback, &d, NULL); newone = (struct polygon_st *) MovePolygonToLayerLowLevel(Layer, Polygon, Dest); InitClip(PCB->Data, Dest, newone); @@ -711,7 +711,7 @@ while (Crosshair.AttachedObject.RubberbandN) { /* first clear any marks that we made in the line flags */ CLEAR_FLAG(RUBBERENDFLAG, ptr->Line); - AddObjectToMoveUndoList(LINEPOINT_TYPE, ptr->Layer, ptr->Line, ptr->MovedPoint, DX, DY); + AddObjectToMoveUndoList(PCB_TYPE_LINE_POINT, ptr->Layer, ptr->Line, ptr->MovedPoint, DX, DY); MoveLinePoint(ptr->Layer, ptr->Line, ptr->MovedPoint); Crosshair.AttachedObject.RubberbandN--; ptr++; @@ -750,7 +750,7 @@ /* setup global identifiers */ Dest = Target; MoreToCome = true; - changed = SelectedOperation(&MoveToLayerFunctions, true, ALL_TYPES); + changed = SelectedOperation(&MoveToLayerFunctions, true, PCB_TYPEMASK_ALL); /* passing true to above operation causes Undoserial to auto-increment */ return (changed); } Index: trunk/src/move.h =================================================================== --- trunk/src/move.h (revision 2502) +++ trunk/src/move.h (revision 2503) @@ -82,10 +82,10 @@ } #define MOVE_TYPES \ - (VIA_TYPE | LINE_TYPE | TEXT_TYPE | ELEMENT_TYPE | ELEMENTNAME_TYPE | \ - POLYGON_TYPE | POLYGONPOINT_TYPE | LINEPOINT_TYPE | ARC_TYPE) + (PCB_TYPE_VIA | PCB_TYPE_LINE | PCB_TYPE_TEXT | PCB_TYPE_ELEMENT | PCB_TYPE_ELEMENT_NAME | \ + PCB_TYPE_POLYGON | PCB_TYPE_POLYGON_POINT | PCB_TYPE_LINE_POINT | PCB_TYPE_ARC) #define MOVETOLAYER_TYPES \ - (LINE_TYPE | TEXT_TYPE | POLYGON_TYPE | RATLINE_TYPE | ARC_TYPE) + (PCB_TYPE_LINE | PCB_TYPE_TEXT | PCB_TYPE_POLYGON | PCB_TYPE_RATLINE | PCB_TYPE_ARC) /* --------------------------------------------------------------------------- Index: trunk/src/netlist.c =================================================================== --- trunk/src/netlist.c (revision 2502) +++ trunk/src/netlist.c (revision 2503) @@ -121,11 +121,11 @@ if (!SeekPad(pin, &conn, false)) return 1; switch (conn.type) { - case PIN_TYPE: + case PCB_TYPE_PIN: *x = ((PinType *) (conn.ptr2))->X; *y = ((PinType *) (conn.ptr2))->Y; return 0; - case PAD_TYPE: + case PCB_TYPE_PAD: *x = ((PadType *) (conn.ptr2))->Point1.X; *y = ((PadType *) (conn.ptr2))->Point1.Y; return 0; Index: trunk/src/object_act.c =================================================================== --- trunk/src/object_act.c (revision 2502) +++ trunk/src/object_act.c (revision 2503) @@ -168,7 +168,7 @@ if (n_found == 0) { void *ptrtmp; gui->get_coords(_("Click on an element"), &x, &y); - if ((SearchScreen(x, y, ELEMENT_TYPE, &ptrtmp, &ptrtmp, &ptrtmp)) != NO_TYPE) + if ((SearchScreen(x, y, PCB_TYPE_ELEMENT, &ptrtmp, &ptrtmp, &ptrtmp)) != PCB_TYPE_NONE) e = (ElementTypePtr) ptrtmp; else { Message(_("No element found there\n")); @@ -285,7 +285,7 @@ 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); + AddObjectToMoveUndoList(PCB_TYPE_ELEMENT, NULL, NULL, element, dx, dy); /* keep track of how tall this row is */ minx += element->BoundingBox.X2 - element->BoundingBox.X1 + GAP; @@ -334,7 +334,7 @@ if (function) { switch (funchash_get(function, NULL)) { case F_Object: - if ((SearchScreen(x, y, ELEMENT_TYPE, &ptrtmp, &ptrtmp, &ptrtmp)) != NO_TYPE) { + if ((SearchScreen(x, y, PCB_TYPE_ELEMENT, &ptrtmp, &ptrtmp, &ptrtmp)) != PCB_TYPE_NONE) { element = (ElementTypePtr) ptrtmp; ChangeElementSide(element, 2 * Crosshair.Y - PCB->MaxHeight); IncrementUndoSerialNumber(); @@ -385,7 +385,7 @@ nx = GetValue(x_str, units, &absolute2, NULL); type = SearchScreen(x, y, MOVE_TYPES, &ptr1, &ptr2, &ptr3); - if (type == NO_TYPE) { + if (type == PCB_TYPE_NONE) { Message(_("Nothing found under crosshair\n")); return 1; } @@ -396,7 +396,7 @@ Crosshair.AttachedObject.RubberbandN = 0; if (conf_core.editor.rubber_band_mode) LookupRubberbandLines(type, ptr1, ptr2, ptr3); - if (type == ELEMENT_TYPE) + if (type == PCB_TYPE_ELEMENT) LookupRatLines(type, ptr1, ptr2, ptr3); MoveObjectAndRubberband(type, ptr1, ptr2, ptr3, nx, ny); SetChangedFlag(true); @@ -428,7 +428,7 @@ void *ptr1, *ptr2, *ptr3; gui->get_coords(_("Select an Object"), &x, &y); - if ((type = SearchScreen(x, y, MOVETOLAYER_TYPES, &ptr1, &ptr2, &ptr3)) != NO_TYPE) + if ((type = SearchScreen(x, y, MOVETOLAYER_TYPES, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) if (MoveObjectToLayer(type, ptr1, ptr2, ptr3, CURRENT, false)) SetChangedFlag(true); break; @@ -739,7 +739,7 @@ ALLLINE_LOOP(PCB->Data); { if (TEST_FLAG(AUTOFLAG, line) && !TEST_FLAG(LOCKFLAG, line)) { - RemoveObject(LINE_TYPE, layer, line, line); + RemoveObject(PCB_TYPE_LINE, layer, line, line); changed = true; } } @@ -747,7 +747,7 @@ ALLARC_LOOP(PCB->Data); { if (TEST_FLAG(AUTOFLAG, arc) && !TEST_FLAG(LOCKFLAG, arc)) { - RemoveObject(ARC_TYPE, layer, arc, arc); + RemoveObject(PCB_TYPE_ARC, layer, arc, arc); changed = true; } } @@ -755,7 +755,7 @@ VIA_LOOP(PCB->Data); { if (TEST_FLAG(AUTOFLAG, via) && !TEST_FLAG(LOCKFLAG, via)) { - RemoveObject(VIA_TYPE, via, via, via); + RemoveObject(PCB_TYPE_VIA, via, via, via); changed = true; } } @@ -771,7 +771,7 @@ { if (TEST_FLAGS(AUTOFLAG | SELECTEDFLAG, line) && !TEST_FLAG(LOCKFLAG, line)) { - RemoveObject(LINE_TYPE, layer, line, line); + RemoveObject(PCB_TYPE_LINE, layer, line, line); changed = true; } } @@ -781,7 +781,7 @@ { if (TEST_FLAGS(AUTOFLAG | SELECTEDFLAG, via) && !TEST_FLAG(LOCKFLAG, via)) { - RemoveObject(VIA_TYPE, via, via, via); + RemoveObject(PCB_TYPE_VIA, via, via, via); changed = true; } } @@ -795,17 +795,17 @@ { void *ptr1, *ptr2, *ptr3; - if (SearchScreen(Crosshair.X, Crosshair.Y, ELEMENT_TYPE, &ptr1, &ptr2, &ptr3) != NO_TYPE) { + if (SearchScreen(Crosshair.X, Crosshair.Y, PCB_TYPE_ELEMENT, &ptr1, &ptr2, &ptr3) != PCB_TYPE_NONE) { Note.Buffer = conf_core.editor.buffer_number; SetBufferNumber(MAX_BUFFER - 1); ClearBuffer(PASTEBUFFER); - CopyObjectToBuffer(PASTEBUFFER->Data, PCB->Data, ELEMENT_TYPE, ptr1, ptr2, ptr3); + CopyObjectToBuffer(PASTEBUFFER->Data, PCB->Data, PCB_TYPE_ELEMENT, ptr1, ptr2, ptr3); SmashBufferElement(PASTEBUFFER); PASTEBUFFER->X = 0; PASTEBUFFER->Y = 0; SaveUndoSerialNumber(); - EraseObject(ELEMENT_TYPE, ptr1, ptr1); - MoveObjectToRemoveUndoList(ELEMENT_TYPE, ptr1, ptr2, ptr3); + EraseObject(PCB_TYPE_ELEMENT, ptr1, ptr1); + MoveObjectToRemoveUndoList(PCB_TYPE_ELEMENT, ptr1, ptr2, ptr3); RestoreUndoSerialNumber(); CopyPastebufferToLayout(0, 0); SetBufferNumber(Note.Buffer); @@ -860,7 +860,7 @@ if (!TEST_FLAGS(flags, pin)) continue; if (pin->Mask < pin->Thickness + value) { - ChangeObjectMaskSize(PIN_TYPE, element, pin, 0, pin->Thickness + value, 1); + ChangeObjectMaskSize(PCB_TYPE_PIN, element, pin, 0, pin->Thickness + value, 1); RestoreUndoSerialNumber(); } } @@ -870,7 +870,7 @@ if (!TEST_FLAGS(flags, pad)) continue; if (pad->Mask < pad->Thickness + value) { - ChangeObjectMaskSize(PAD_TYPE, element, pad, 0, pad->Thickness + value, 1); + ChangeObjectMaskSize(PCB_TYPE_PAD, element, pad, 0, pad->Thickness + value, 1); RestoreUndoSerialNumber(); } } @@ -882,7 +882,7 @@ if (!TEST_FLAGS(flags, via)) continue; if (via->Mask && via->Mask < via->Thickness + value) { - ChangeObjectMaskSize(VIA_TYPE, via, 0, 0, via->Thickness + value, 1); + ChangeObjectMaskSize(PCB_TYPE_VIA, via, 0, 0, via->Thickness + value, 1); RestoreUndoSerialNumber(); } } @@ -934,7 +934,7 @@ if (!TEST_FLAGS(flags, pin)) continue; if (pin->Clearance < value) { - ChangeObjectClearSize(PIN_TYPE, element, pin, 0, value, 1); + ChangeObjectClearSize(PCB_TYPE_PIN, element, pin, 0, value, 1); RestoreUndoSerialNumber(); } } @@ -944,7 +944,7 @@ if (!TEST_FLAGS(flags, pad)) continue; if (pad->Clearance < value) { - ChangeObjectClearSize(PAD_TYPE, element, pad, 0, value, 1); + ChangeObjectClearSize(PCB_TYPE_PAD, element, pad, 0, value, 1); RestoreUndoSerialNumber(); } } @@ -956,7 +956,7 @@ if (!TEST_FLAGS(flags, via)) continue; if (via->Clearance < value) { - ChangeObjectClearSize(VIA_TYPE, via, 0, 0, value, 1); + ChangeObjectClearSize(PCB_TYPE_VIA, via, 0, 0, value, 1); RestoreUndoSerialNumber(); } } @@ -966,7 +966,7 @@ if (!TEST_FLAGS(flags, line)) continue; if (line->Clearance < value) { - ChangeObjectClearSize(LINE_TYPE, layer, line, 0, value, 1); + ChangeObjectClearSize(PCB_TYPE_LINE, layer, line, 0, value, 1); RestoreUndoSerialNumber(); } } @@ -976,7 +976,7 @@ if (!TEST_FLAGS(flags, arc)) continue; if (arc->Clearance < value) { - ChangeObjectClearSize(ARC_TYPE, layer, arc, 0, value, 1); + ChangeObjectClearSize(PCB_TYPE_ARC, layer, arc, 0, value, 1); RestoreUndoSerialNumber(); } } Index: trunk/src/polygon.c =================================================================== --- trunk/src/polygon.c (revision 2502) +++ trunk/src/polygon.c (revision 2503) @@ -1213,7 +1213,7 @@ line.Point2 = Polygon->Points[next]; line.Thickness = 0; if (IsPointOnLine(p->X, p->Y, 0.0, &line)) { - RemoveObject(POLYGONPOINT_TYPE, Layer, Polygon, p); + RemoveObject(PCB_TYPE_POLYGON_POINT, Layer, Polygon, p); changed = true; } } @@ -1357,7 +1357,7 @@ addedLines = 0; /* add to undo list */ - AddObjectToCreateUndoList(POLYGON_TYPE, CURRENT, polygon, polygon); + AddObjectToCreateUndoList(PCB_TYPE_POLYGON, CURRENT, polygon, polygon); IncrementUndoSerialNumber(); } @@ -1398,24 +1398,24 @@ if (!Polygon->Clipped) return 0; switch (type) { - case PIN_TYPE: - case VIA_TYPE: + case PCB_TYPE_PIN: + case PCB_TYPE_VIA: SubtractPin(Data, (PinTypePtr) ptr2, Layer, Polygon); Polygon->NoHolesValid = 0; return R_DIR_FOUND_CONTINUE; - case LINE_TYPE: + case PCB_TYPE_LINE: SubtractLine((LineTypePtr) ptr2, Polygon); Polygon->NoHolesValid = 0; return R_DIR_FOUND_CONTINUE; - case ARC_TYPE: + case PCB_TYPE_ARC: SubtractArc((ArcTypePtr) ptr2, Polygon); Polygon->NoHolesValid = 0; return R_DIR_FOUND_CONTINUE; - case PAD_TYPE: + case PCB_TYPE_PAD: SubtractPad((PadTypePtr) ptr2, Polygon); Polygon->NoHolesValid = 0; return R_DIR_FOUND_CONTINUE; - case TEXT_TYPE: + case PCB_TYPE_TEXT: SubtractText((TextTypePtr) ptr2, Polygon); Polygon->NoHolesValid = 0; return R_DIR_FOUND_CONTINUE; @@ -1426,20 +1426,20 @@ static r_dir_t add_plow(DataTypePtr Data, LayerTypePtr Layer, PolygonTypePtr Polygon, int type, void *ptr1, void *ptr2) { switch (type) { - case PIN_TYPE: - case VIA_TYPE: + case PCB_TYPE_PIN: + case PCB_TYPE_VIA: UnsubtractPin((PinTypePtr) ptr2, Layer, Polygon); return R_DIR_FOUND_CONTINUE; - case LINE_TYPE: + case PCB_TYPE_LINE: UnsubtractLine((LineTypePtr) ptr2, Layer, Polygon); return R_DIR_FOUND_CONTINUE; - case ARC_TYPE: + case PCB_TYPE_ARC: UnsubtractArc((ArcTypePtr) ptr2, Layer, Polygon); return R_DIR_FOUND_CONTINUE; - case PAD_TYPE: + case PCB_TYPE_PAD: UnsubtractPad((PadTypePtr) ptr2, Layer, Polygon); return R_DIR_FOUND_CONTINUE; - case TEXT_TYPE: + case PCB_TYPE_TEXT: UnsubtractText((TextTypePtr) ptr2, Layer, Polygon); return R_DIR_FOUND_CONTINUE; } @@ -1470,9 +1470,9 @@ info.data = Data; info.callback = call_back; switch (type) { - case PIN_TYPE: - case VIA_TYPE: - if (type == PIN_TYPE || ptr1 == ptr2 || ptr1 == NULL) { + case PCB_TYPE_PIN: + case PCB_TYPE_VIA: + if (type == PCB_TYPE_PIN || ptr1 == ptr2 || ptr1 == NULL) { LAYER_LOOP(Data, max_copper_layer); { info.layer = layer; @@ -1491,9 +1491,9 @@ END_LOOP; } break; - case LINE_TYPE: - case ARC_TYPE: - case TEXT_TYPE: + case PCB_TYPE_LINE: + case PCB_TYPE_ARC: + case PCB_TYPE_TEXT: /* the cast works equally well for lines and arcs */ if (!TEST_FLAG(CLEARLINEFLAG, (LineTypePtr) ptr2)) return 0; @@ -1508,7 +1508,7 @@ } END_LOOP; break; - case PAD_TYPE: + case PCB_TYPE_PAD: { Cardinal group = GetLayerGroupNumberByNumber(TEST_FLAG(ONSOLDERFLAG, (PadType *) ptr2) ? solder_silk_layer : component_silk_layer); @@ -1522,16 +1522,16 @@ } break; - case ELEMENT_TYPE: + case PCB_TYPE_ELEMENT: { PIN_LOOP((ElementType *) ptr1); { - PlowsPolygon(Data, PIN_TYPE, ptr1, pin, call_back); + PlowsPolygon(Data, PCB_TYPE_PIN, ptr1, pin, call_back); } END_LOOP; PAD_LOOP((ElementType *) ptr1); { - PlowsPolygon(Data, PAD_TYPE, ptr1, pad, call_back); + PlowsPolygon(Data, PCB_TYPE_PAD, ptr1, pad, call_back); } END_LOOP; } @@ -1542,7 +1542,7 @@ void RestoreToPolygon(DataType * Data, int type, void *ptr1, void *ptr2) { - if (type == POLYGON_TYPE) + if (type == PCB_TYPE_POLYGON) InitClip(PCB->Data, (LayerTypePtr) ptr1, (PolygonTypePtr) ptr2); else PlowsPolygon(Data, type, ptr1, ptr2, add_plow); @@ -1550,7 +1550,7 @@ void ClearFromPolygon(DataType * Data, int type, void *ptr1, void *ptr2) { - if (type == POLYGON_TYPE) + if (type == PCB_TYPE_POLYGON) InitClip(PCB->Data, (LayerTypePtr) ptr1, (PolygonTypePtr) ptr2); else PlowsPolygon(Data, type, ptr1, ptr2, subtract_plow); @@ -1719,7 +1719,7 @@ newone->BoundingBox.X2 = p->contours->xmax + 1; newone->BoundingBox.Y1 = p->contours->ymin; newone->BoundingBox.Y2 = p->contours->ymax + 1; - AddObjectToCreateUndoList(POLYGON_TYPE, layer, newone, newone); + AddObjectToCreateUndoList(PCB_TYPE_POLYGON, layer, newone, newone); newone->Clipped = p; p = p->f; /* go to next pline */ newone->Clipped->b = newone->Clipped->f = newone->Clipped; /* unlink from others */ @@ -1828,7 +1828,7 @@ DrawPolygon(Layer, Polygon); /* add to undo list */ - AddObjectToCreateUndoList(POLYGON_TYPE, Layer, Polygon, Polygon); + AddObjectToCreateUndoList(PCB_TYPE_POLYGON, Layer, Polygon, Polygon); } while ((pa = pa->f) != Input); Index: trunk/src/polygon_act.c =================================================================== --- trunk/src/polygon_act.c (revision 2502) +++ trunk/src/polygon_act.c (revision 2503) @@ -64,7 +64,7 @@ void *ptr1, *ptr2, *ptr3; gui->get_coords(_("Select an Object"), &x, &y); - if ((type = SearchScreen(x, y, POLYGON_TYPE, &ptr1, &ptr2, &ptr3)) != NO_TYPE) { + if ((type = SearchScreen(x, y, PCB_TYPE_POLYGON, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) { MorphPolygon((LayerType *) ptr1, (PolygonType *) ptr3); Draw(); IncrementUndoSerialNumber(); Index: trunk/src/rats.c =================================================================== --- trunk/src/rats.c (revision 2502) +++ trunk/src/rats.c (revision 2503) @@ -109,7 +109,7 @@ padlist_foreach(&element->Pad, &it, pad) { if (NSTRCMP(PinNum, pad->Number) == 0 && (!Same || !TEST_FLAG(DRCFLAG, pad))) { - conn->type = PAD_TYPE; + conn->type = PCB_TYPE_PAD; conn->ptr1 = element; conn->ptr2 = pad; conn->group = TEST_FLAG(ONSOLDERFLAG, pad) ? SLayer : CLayer; @@ -128,7 +128,7 @@ padlist_foreach(&element->Pin, &it, pin) { if (!TEST_FLAG(HOLEFLAG, pin) && pin->Number && NSTRCMP(PinNum, pin->Number) == 0 && (!Same || !TEST_FLAG(DRCFLAG, pin))) { - conn->type = PIN_TYPE; + conn->type = PCB_TYPE_PIN; conn->ptr1 = element; conn->ptr2 = pin; conn->group = SLayer; /* any layer will do */ @@ -234,7 +234,7 @@ ("Error! Element %s pin %s appears multiple times in the netlist file.\n"), NAMEONPCB_NAME((ElementTypePtr) LastPoint.ptr1), (LastPoint.type == - PIN_TYPE) ? ((PinTypePtr) LastPoint.ptr2)->Number : ((PadTypePtr) LastPoint.ptr2)->Number); + PCB_TYPE_PIN) ? ((PinTypePtr) LastPoint.ptr2)->Number : ((PadTypePtr) LastPoint.ptr2)->Number); else { connection = GetConnectionMemory(net); *connection = LastPoint; @@ -242,7 +242,7 @@ connection->menu = menu; /* mark as visited */ SET_FLAG(DRCFLAG, (PinTypePtr) LastPoint.ptr2); - if (LastPoint.type == PIN_TYPE) + if (LastPoint.type == PCB_TYPE_PIN) ((PinTypePtr) LastPoint.ptr2)->Spare = (void *) menu; else ((PadTypePtr) LastPoint.ptr2)->Spare = (void *) menu; @@ -258,7 +258,7 @@ connection->menu = menu; /* mark as visited */ SET_FLAG(DRCFLAG, (PinTypePtr) LastPoint.ptr2); - if (LastPoint.type == PIN_TYPE) + if (LastPoint.type == PCB_TYPE_PIN) ((PinTypePtr) LastPoint.ptr2)->Spare = (void *) menu; else ((PadTypePtr) LastPoint.ptr2)->Spare = (void *) menu; @@ -425,7 +425,7 @@ conn = GetConnectionMemory(a); conn->X = line->Point1.X; conn->Y = line->Point1.Y; - conn->type = LINE_TYPE; + conn->type = PCB_TYPE_LINE; conn->ptr1 = layer; conn->ptr2 = line; conn->group = GetLayerGroupNumberByPointer(layer); @@ -433,7 +433,7 @@ conn = GetConnectionMemory(a); conn->X = line->Point2.X; conn->Y = line->Point2.Y; - conn->type = LINE_TYPE; + conn->type = PCB_TYPE_LINE; conn->ptr1 = layer; conn->ptr2 = line; conn->group = GetLayerGroupNumberByPointer(layer); @@ -449,7 +449,7 @@ /* make point on a vertex */ conn->X = polygon->Clipped->contours->head.point[0]; conn->Y = polygon->Clipped->contours->head.point[1]; - conn->type = POLYGON_TYPE; + conn->type = PCB_TYPE_POLYGON; conn->ptr1 = layer; conn->ptr2 = polygon; conn->group = GetLayerGroupNumberByPointer(layer); @@ -463,7 +463,7 @@ conn = GetConnectionMemory(a); conn->X = via->X; conn->Y = via->Y; - conn->type = VIA_TYPE; + conn->type = PCB_TYPE_VIA; conn->ptr1 = via; conn->ptr2 = via; conn->group = SLayer; @@ -565,10 +565,10 @@ * not a daisy chain). Further prefer to pick an existing * via in the Net to make that connection. */ - if (conn1->type == POLYGON_TYPE && + if (conn1->type == PCB_TYPE_POLYGON && (polygon = (PolygonTypePtr) conn1->ptr2) && !(distance == 0 && - firstpoint && firstpoint->type == VIA_TYPE) && IsPointInPolygonIgnoreHoles(conn2->X, conn2->Y, polygon)) { + firstpoint && firstpoint->type == PCB_TYPE_VIA) && IsPointInPolygonIgnoreHoles(conn2->X, conn2->Y, polygon)) { distance = 0; firstpoint = conn2; secondpoint = conn1; @@ -575,10 +575,10 @@ theSubnet = next; havepoints = true; } - else if (conn2->type == POLYGON_TYPE && + else if (conn2->type == PCB_TYPE_POLYGON && (polygon = (PolygonTypePtr) conn2->ptr2) && !(distance == 0 && - firstpoint && firstpoint->type == VIA_TYPE) && IsPointInPolygonIgnoreHoles(conn1->X, conn1->Y, polygon)) { + firstpoint && firstpoint->type == PCB_TYPE_VIA) && IsPointInPolygonIgnoreHoles(conn1->X, conn1->Y, polygon)) { distance = 0; firstpoint = conn1; secondpoint = conn2; @@ -612,7 +612,7 @@ firstpoint->group, secondpoint->group, conf_core.appearance.rat_thickness, NoFlags())) != NULL) { if (distance == 0) SET_FLAG(VIAFLAG, line); - AddObjectToCreateUndoList(RATLINE_TYPE, line, line, line); + AddObjectToCreateUndoList(PCB_TYPE_RATLINE, line, line, line); DrawRat(line); changed = true; } @@ -819,9 +819,9 @@ && Crosshair.AttachedLine.Point1.Y == Crosshair.AttachedLine.Point2.Y) return (NULL); - found = SearchObjectByLocation(PAD_TYPE | PIN_TYPE, &ptr1, &ptr2, &ptr3, + found = SearchObjectByLocation(PCB_TYPE_PAD | PCB_TYPE_PIN, &ptr1, &ptr2, &ptr3, Crosshair.AttachedLine.Point1.X, Crosshair.AttachedLine.Point1.Y, 5); - if (found == NO_TYPE) { + if (found == PCB_TYPE_NONE) { Message(_("No pad/pin under rat line\n")); return (NULL); } @@ -834,9 +834,9 @@ group1 = (TEST_FLAG(ONSOLDERFLAG, (PadTypePtr) ptr2) ? GetLayerGroupNumberByNumber(solder_silk_layer) : GetLayerGroupNumberByNumber(component_silk_layer)); strcpy(name1, ConnectionName(found, ptr1, ptr2)); - found = SearchObjectByLocation(PAD_TYPE | PIN_TYPE, &ptr1, &ptr2, &ptr3, + found = SearchObjectByLocation(PCB_TYPE_PAD | PCB_TYPE_PIN, &ptr1, &ptr2, &ptr3, Crosshair.AttachedLine.Point2.X, Crosshair.AttachedLine.Point2.Y, 5); - if (found == NO_TYPE) { + if (found == PCB_TYPE_NONE) { Message(_("No pad/pin under rat line\n")); return (NULL); } @@ -907,10 +907,10 @@ char *num; switch (type) { - case PIN_TYPE: + case PCB_TYPE_PIN: num = ((PinTypePtr) ptr2)->Number; break; - case PAD_TYPE: + case PCB_TYPE_PAD: num = ((PadTypePtr) ptr2)->Number; break; default: Index: trunk/src/rats_act.c =================================================================== --- trunk/src/rats_act.c (revision 2502) +++ trunk/src/rats_act.c (revision 2503) @@ -99,7 +99,7 @@ } END_LOOP; if (shorty) { - AddObjectToFlagUndoList(RATLINE_TYPE, shorty, shorty, shorty); + AddObjectToFlagUndoList(PCB_TYPE_RATLINE, shorty, shorty, shorty); SET_FLAG(SELECTEDFLAG, shorty); DrawRat(shorty); Draw(); Index: trunk/src/remove.c =================================================================== --- trunk/src/remove.c (revision 2502) +++ trunk/src/remove.c (revision 2503) @@ -262,7 +262,7 @@ if (!Bulk) Draw(); } - MoveObjectToRemoveUndoList(VIA_TYPE, Via, Via, Via); + MoveObjectToRemoveUndoList(PCB_TYPE_VIA, Via, Via, Via); return NULL; } @@ -277,7 +277,7 @@ if (!Bulk) Draw(); } - MoveObjectToRemoveUndoList(RATLINE_TYPE, Rat, Rat, Rat); + MoveObjectToRemoveUndoList(PCB_TYPE_RATLINE, Rat, Rat, Rat); return NULL; } @@ -324,7 +324,7 @@ r_search(Layer->line_tree, (const BoxType *) Point, NULL, remove_point, &info, NULL); return RemoveLine(Layer, Line); } - MoveObject(LINEPOINT_TYPE, Layer, info.line, info.point, other.X - Point->X, other.Y - Point->Y); + MoveObject(PCB_TYPE_LINE_POINT, Layer, info.line, info.point, other.X - Point->X, other.Y - Point->Y); return (RemoveLine(Layer, Line)); } @@ -339,7 +339,7 @@ if (!Bulk) Draw(); } - MoveObjectToRemoveUndoList(LINE_TYPE, Layer, Line, Line); + MoveObjectToRemoveUndoList(PCB_TYPE_LINE, Layer, Line, Line); return NULL; } @@ -354,7 +354,7 @@ if (!Bulk) Draw(); } - MoveObjectToRemoveUndoList(ARC_TYPE, Layer, Arc, Arc); + MoveObjectToRemoveUndoList(PCB_TYPE_ARC, Layer, Arc, Arc); return NULL; } @@ -369,7 +369,7 @@ if (!Bulk) Draw(); } - MoveObjectToRemoveUndoList(TEXT_TYPE, Layer, Text, Text); + MoveObjectToRemoveUndoList(PCB_TYPE_TEXT, Layer, Text, Text); return NULL; } @@ -384,7 +384,7 @@ if (!Bulk) Draw(); } - MoveObjectToRemoveUndoList(POLYGON_TYPE, Layer, Polygon, Polygon); + MoveObjectToRemoveUndoList(PCB_TYPE_POLYGON, Layer, Polygon, Polygon); return NULL; } @@ -407,7 +407,7 @@ } /* Copy the polygon to the undo list */ - AddObjectToRemoveContourUndoList(POLYGON_TYPE, Layer, Polygon); + AddObjectToRemoveContourUndoList(PCB_TYPE_POLYGON, Layer, Polygon); contour_start = (contour == 0) ? 0 : Polygon->HoleIndex[contour - 1]; contour_end = (contour == Polygon->HoleIndexN) ? Polygon->PointN : Polygon->HoleIndex[contour]; @@ -456,7 +456,7 @@ ErasePolygon(Polygon); /* insert the polygon-point into the undo list */ - AddObjectToRemovePointUndoList(POLYGONPOINT_TYPE, Layer, Polygon, point_idx); + AddObjectToRemovePointUndoList(PCB_TYPE_POLYGON_POINT, Layer, Polygon, point_idx); r_delete_entry(Layer->polygon_tree, (BoxType *) Polygon); /* remove point from list, keep point order */ @@ -494,7 +494,7 @@ if (!Bulk) Draw(); } - MoveObjectToRemoveUndoList(ELEMENT_TYPE, Element, Element, Element); + MoveObjectToRemoveUndoList(PCB_TYPE_ELEMENT, Element, Element, Element); return NULL; } @@ -505,7 +505,7 @@ bool RemoveSelected(void) { Bulk = true; - if (SelectedOperation(&RemoveFunctions, false, ALL_TYPES)) { + if (SelectedOperation(&RemoveFunctions, false, PCB_TYPEMASK_ALL)) { IncrementUndoSerialNumber(); Draw(); Bulk = false; Index: trunk/src/remove.h =================================================================== --- trunk/src/remove.h (revision 2502) +++ trunk/src/remove.h (revision 2503) @@ -35,8 +35,8 @@ * some constants */ #define REMOVE_TYPES \ - (VIA_TYPE | LINEPOINT_TYPE | LINE_TYPE | TEXT_TYPE | ELEMENT_TYPE | \ - POLYGONPOINT_TYPE | POLYGON_TYPE | RATLINE_TYPE | ARC_TYPE) + (PCB_TYPE_VIA | PCB_TYPE_LINE_POINT | PCB_TYPE_LINE | PCB_TYPE_TEXT | PCB_TYPE_ELEMENT | \ + PCB_TYPE_POLYGON_POINT | PCB_TYPE_POLYGON | PCB_TYPE_RATLINE | PCB_TYPE_ARC) void *RemoveLine(LayerTypePtr, LineTypePtr); void *RemoveArc(LayerTypePtr, ArcTypePtr); Index: trunk/src/rotate.c =================================================================== --- trunk/src/rotate.c (revision 2502) +++ trunk/src/rotate.c (revision 2503) @@ -150,11 +150,11 @@ static void *RotateText(LayerTypePtr Layer, TextTypePtr Text) { EraseText(Layer, Text); - RestoreToPolygon(PCB->Data, TEXT_TYPE, Layer, Text); + RestoreToPolygon(PCB->Data, PCB_TYPE_TEXT, Layer, Text); r_delete_entry(Layer->text_tree, (BoxTypePtr) Text); RotateTextLowLevel(Text, CenterX, CenterY, Number); r_insert_entry(Layer->text_tree, (BoxTypePtr) Text, 0); - ClearFromPolygon(PCB->Data, TEXT_TYPE, Layer, Text); + ClearFromPolygon(PCB->Data, PCB_TYPE_TEXT, Layer, Text); DrawText(Layer, Text); Draw(); return (Text); @@ -207,7 +207,7 @@ /* pre-delete the pins from the pin-tree before their coordinates change */ if (Data) r_delete_entry(Data->pin_tree, (BoxType *) pin); - RestoreToPolygon(Data, PIN_TYPE, Element, pin); + RestoreToPolygon(Data, PCB_TYPE_PIN, Element, pin); ROTATE_PIN_LOWLEVEL(pin, X, Y, Number); } END_LOOP; @@ -216,7 +216,7 @@ /* pre-delete the pads before their coordinates change */ if (Data) r_delete_entry(Data->pad_tree, (BoxType *) pad); - RestoreToPolygon(Data, PAD_TYPE, Element, pad); + RestoreToPolygon(Data, PCB_TYPE_PAD, Element, pad); ROTATE_PAD_LOWLEVEL(pad, X, Y, Number); } END_LOOP; @@ -228,7 +228,7 @@ ROTATE(Element->MarkX, Element->MarkY, X, Y, Number); /* SetElementBoundingBox reenters the rtree data */ SetElementBoundingBox(Data, Element, &PCB->Font); - ClearFromPolygon(Data, ELEMENT_TYPE, Element, Element); + ClearFromPolygon(Data, PCB_TYPE_ELEMENT, Element, Element); } /* --------------------------------------------------------------------------- @@ -238,7 +238,7 @@ { EraseLine(Line); if (Layer) { - RestoreToPolygon(PCB->Data, LINE_TYPE, Layer, Line); + RestoreToPolygon(PCB->Data, PCB_TYPE_LINE, Layer, Line); r_delete_entry(Layer->line_tree, (BoxTypePtr) Line); } else @@ -247,7 +247,7 @@ SetLineBoundingBox(Line); if (Layer) { r_insert_entry(Layer->line_tree, (BoxTypePtr) Line, 0); - ClearFromPolygon(PCB->Data, LINE_TYPE, Layer, Line); + ClearFromPolygon(PCB->Data, PCB_TYPE_LINE, Layer, Line); DrawLine(Layer, Line); } else { @@ -337,10 +337,10 @@ while (Crosshair.AttachedObject.RubberbandN) { changed = true; CLEAR_FLAG(RUBBERENDFLAG, ptr->Line); - AddObjectToRotateUndoList(LINEPOINT_TYPE, ptr->Layer, ptr->Line, ptr->MovedPoint, CenterX, CenterY, Steps); + AddObjectToRotateUndoList(PCB_TYPE_LINE_POINT, ptr->Layer, ptr->Line, ptr->MovedPoint, CenterX, CenterY, Steps); EraseLine(ptr->Line); if (ptr->Layer) { - RestoreToPolygon(PCB->Data, LINE_TYPE, ptr->Layer, ptr->Line); + RestoreToPolygon(PCB->Data, PCB_TYPE_LINE, ptr->Layer, ptr->Line); r_delete_entry(ptr->Layer->line_tree, (BoxType *) ptr->Line); } else @@ -349,7 +349,7 @@ SetLineBoundingBox(ptr->Line); if (ptr->Layer) { r_insert_entry(ptr->Layer->line_tree, (BoxType *) ptr->Line, 0); - ClearFromPolygon(PCB->Data, LINE_TYPE, ptr->Layer, ptr->Line); + ClearFromPolygon(PCB->Data, PCB_TYPE_LINE, ptr->Layer, ptr->Line); DrawLine(ptr->Layer, ptr->Line); } else { @@ -373,7 +373,7 @@ { int type; void *ptr1, *ptr2, *ptr3; - if ((type = SearchScreen(X, Y, ROTATE_TYPES, &ptr1, &ptr2, &ptr3)) != NO_TYPE) { + if ((type = SearchScreen(X, Y, ROTATE_TYPES, &ptr1, &ptr2, &ptr3)) != PCB_TYPE_NONE) { if (TEST_FLAG(LOCKFLAG, (ArcTypePtr) ptr2)) { Message(_("Sorry, the object is locked\n")); return; @@ -381,7 +381,7 @@ Crosshair.AttachedObject.RubberbandN = 0; if (conf_core.editor.rubber_band_mode) LookupRubberbandLines(type, ptr1, ptr2, ptr3); - if (type == ELEMENT_TYPE) + if (type == PCB_TYPE_ELEMENT) LookupRatLines(type, ptr1, ptr2, ptr3); RotateObject(type, ptr1, ptr2, ptr3, X, Y, Steps); SetChangedFlag(true); Index: trunk/src/rotate.h =================================================================== --- trunk/src/rotate.h (revision 2502) +++ trunk/src/rotate.h (revision 2503) @@ -88,7 +88,7 @@ #define ROTATE_PAD_LOWLEVEL(p,x0,y0,n) \ RotateLineLowLevel(((LineTypePtr) (p)),(x0),(y0),(n)) -#define ROTATE_TYPES (ELEMENT_TYPE | TEXT_TYPE | ELEMENTNAME_TYPE | ARC_TYPE) +#define ROTATE_TYPES (PCB_TYPE_ELEMENT | PCB_TYPE_TEXT | PCB_TYPE_ELEMENT_NAME | PCB_TYPE_ARC) void RotateLineLowLevel(LineTypePtr, Coord, Coord, unsigned); Index: trunk/src/rubberband.c =================================================================== --- trunk/src/rubberband.c (revision 2502) +++ trunk/src/rubberband.c (revision 2503) @@ -221,13 +221,13 @@ struct rinfo *i = (struct rinfo *) cl; switch (i->type) { - case PIN_TYPE: + case PCB_TYPE_PIN: if (rat->Point1.X == i->pin->X && rat->Point1.Y == i->pin->Y) CreateNewRubberbandEntry(NULL, (LineTypePtr) rat, &rat->Point1); else if (rat->Point2.X == i->pin->X && rat->Point2.Y == i->pin->Y) CreateNewRubberbandEntry(NULL, (LineTypePtr) rat, &rat->Point2); break; - case PAD_TYPE: + case PCB_TYPE_PAD: if (rat->Point1.X == i->pad->Point1.X && rat->Point1.Y == i->pad->Point1.Y && rat->group1 == i->group) CreateNewRubberbandEntry(NULL, (LineTypePtr) rat, &rat->Point1); else if (rat->Point2.X == i->pad->Point1.X && rat->Point2.Y == i->pad->Point1.Y && rat->group2 == i->group) @@ -245,7 +245,7 @@ rat->Point2.Y == (i->pad->Point1.Y + i->pad->Point2.Y) / 2 && rat->group2 == i->group) CreateNewRubberbandEntry(NULL, (LineTypePtr) rat, &rat->Point2); break; - case LINEPOINT_TYPE: + case PCB_TYPE_LINE_POINT: if (rat->group1 == i->group && rat->Point1.X == i->point->X && rat->Point1.Y == i->point->Y) CreateNewRubberbandEntry(NULL, (LineTypePtr) rat, &rat->Point1); else if (rat->group2 == i->group && rat->Point2.X == i->point->X && rat->Point2.Y == i->point->Y) @@ -265,7 +265,7 @@ i = TEST_FLAG(ONSOLDERFLAG, Pad) ? solder_silk_layer : component_silk_layer; info.group = GetLayerGroupNumberByNumber(i); info.pad = Pad; - info.type = PAD_TYPE; + info.type = PCB_TYPE_PAD; r_search(PCB->Data->rat_tree, &Pad->BoundingBox, NULL, rat_callback, &info, NULL); } @@ -274,7 +274,7 @@ { struct rinfo info; - info.type = PIN_TYPE; + info.type = PCB_TYPE_PIN; info.pin = Pin; r_search(PCB->Data->rat_tree, &Pin->BoundingBox, NULL, rat_callback, &info, NULL); } @@ -284,7 +284,7 @@ struct rinfo info; info.group = GetLayerGroupNumberByPointer(Layer); info.point = Point; - info.type = LINEPOINT_TYPE; + info.type = PCB_TYPE_LINE_POINT; r_search(PCB->Data->rat_tree, (BoxType *) Point, NULL, rat_callback, &info, NULL); } @@ -405,7 +405,7 @@ * is connected */ switch (Type) { - case ELEMENT_TYPE: + case PCB_TYPE_ELEMENT: { ElementTypePtr element = (ElementTypePtr) Ptr1; @@ -426,7 +426,7 @@ break; } - case LINE_TYPE: + case PCB_TYPE_LINE: { LayerTypePtr layer = (LayerTypePtr) Ptr1; LineTypePtr line = (LineTypePtr) Ptr2; @@ -437,16 +437,16 @@ break; } - case LINEPOINT_TYPE: + case PCB_TYPE_LINE_POINT: if (GetLayerNumber(PCB->Data, (LayerTypePtr) Ptr1) < max_copper_layer) CheckLinePointForRubberbandConnection((LayerTypePtr) Ptr1, (LineTypePtr) Ptr2, (PointTypePtr) Ptr3, true); break; - case VIA_TYPE: + case PCB_TYPE_VIA: CheckPinForRubberbandConnection((PinTypePtr) Ptr1); break; - case POLYGON_TYPE: + case PCB_TYPE_POLYGON: if (GetLayerNumber(PCB->Data, (LayerTypePtr) Ptr1) < max_copper_layer) CheckPolygonForRubberbandConnection((LayerTypePtr) Ptr1, (PolygonTypePtr) Ptr2); break; @@ -456,7 +456,7 @@ void LookupRatLines(int Type, void *Ptr1, void *Ptr2, void *Ptr3) { switch (Type) { - case ELEMENT_TYPE: + case PCB_TYPE_ELEMENT: { ElementTypePtr element = (ElementTypePtr) Ptr1; @@ -473,7 +473,7 @@ break; } - case LINE_TYPE: + case PCB_TYPE_LINE: { LayerTypePtr layer = (LayerTypePtr) Ptr1; LineTypePtr line = (LineTypePtr) Ptr2; @@ -483,11 +483,11 @@ break; } - case LINEPOINT_TYPE: + case PCB_TYPE_LINE_POINT: CheckLinePointForRat((LayerTypePtr) Ptr1, (PointTypePtr) Ptr3); break; - case VIA_TYPE: + case PCB_TYPE_VIA: CheckPinForRat((PinTypePtr) Ptr1); break; } Index: trunk/src/search.c =================================================================== --- trunk/src/search.c (revision 2502) +++ trunk/src/search.c (revision 2503) @@ -52,7 +52,7 @@ static LayerTypePtr SearchLayer; /* --------------------------------------------------------------------------- - * some local prototypes. The first parameter includes LOCKED_TYPE if we + * some local prototypes. The first parameter includes PCB_TYPE_LOCKED if we * want to include locked types in the search. */ static bool SearchLineByLocation(int, LayerTypePtr *, LineTypePtr *, LineTypePtr *); @@ -105,7 +105,7 @@ info.ptr1 = (void **) Via; info.ptr2 = (void **) Dummy1; info.ptr3 = (void **) Dummy2; - info.locked = (locked & LOCKED_TYPE) ? 0 : LOCKFLAG; + info.locked = (locked & PCB_TYPE_LOCKED) ? 0 : LOCKFLAG; if (r_search(PCB->Data->via_tree, &SearchBox, NULL, pinorvia_callback, &info, NULL) != R_DIR_NOT_FOUND) return true; @@ -126,7 +126,7 @@ info.ptr1 = (void **) Element; info.ptr2 = (void **) Pin; info.ptr3 = (void **) Dummy; - info.locked = (locked & LOCKED_TYPE) ? 0 : LOCKFLAG; + info.locked = (locked & PCB_TYPE_LOCKED) ? 0 : LOCKFLAG; if (r_search(PCB->Data->pin_tree, &SearchBox, NULL, pinorvia_callback, &info, NULL) != R_DIR_NOT_FOUND) return true; @@ -166,7 +166,7 @@ info.ptr1 = (void **) Element; info.ptr2 = (void **) Pad; info.ptr3 = (void **) Dummy; - info.locked = (locked & LOCKED_TYPE) ? 0 : LOCKFLAG; + info.locked = (locked & PCB_TYPE_LOCKED) ? 0 : LOCKFLAG; info.BackToo = (BackToo && PCB->InvisibleObjectsOn); if (r_search(PCB->Data->pad_tree, &SearchBox, NULL, pad_callback, &info, NULL) != R_DIR_NOT_FOUND) return true; @@ -207,7 +207,7 @@ info.Line = Line; info.Point = (PointTypePtr *) Dummy; - info.locked = (locked & LOCKED_TYPE) ? 0 : LOCKFLAG; + info.locked = (locked & PCB_TYPE_LOCKED) ? 0 : LOCKFLAG; *Layer = SearchLayer; if (r_search(SearchLayer->line_tree, &SearchBox, NULL, line_callback, &info, NULL) != R_DIR_NOT_FOUND) @@ -243,7 +243,7 @@ info.ptr1 = (void **) Line; info.ptr2 = (void **) Dummy1; info.ptr3 = (void **) Dummy2; - info.locked = (locked & LOCKED_TYPE) ? 0 : LOCKFLAG; + info.locked = (locked & PCB_TYPE_LOCKED) ? 0 : LOCKFLAG; if (r_search(PCB->Data->rat_tree, &SearchBox, NULL, rat_callback, &info, NULL) != R_DIR_NOT_FOUND) return true; @@ -280,7 +280,7 @@ info.Arc = Arc; info.Dummy = Dummy; - info.locked = (locked & LOCKED_TYPE) ? 0 : LOCKFLAG; + info.locked = (locked & PCB_TYPE_LOCKED) ? 0 : LOCKFLAG; *Layer = SearchLayer; if (r_search(SearchLayer->arc_tree, &SearchBox, NULL, arc_callback, &info, NULL) != R_DIR_NOT_FOUND) @@ -313,7 +313,7 @@ *Layer = SearchLayer; info.ptr2 = (void **) Text; info.ptr3 = (void **) Dummy; - info.locked = (locked & LOCKED_TYPE) ? 0 : LOCKFLAG; + info.locked = (locked & PCB_TYPE_LOCKED) ? 0 : LOCKFLAG; if (r_search(SearchLayer->text_tree, &SearchBox, NULL, text_callback, &info, NULL) != R_DIR_NOT_FOUND) return true; @@ -346,7 +346,7 @@ *Layer = SearchLayer; info.ptr2 = (void **) Polygon; info.ptr3 = (void **) Dummy; - info.locked = (locked & LOCKED_TYPE) ? 0 : LOCKFLAG; + info.locked = (locked & PCB_TYPE_LOCKED) ? 0 : LOCKFLAG; if (r_search(SearchLayer->polygon_tree, &SearchBox, NULL, polygon_callback, &info, NULL) != R_DIR_NOT_FOUND) return true; @@ -393,7 +393,7 @@ info.Point = Point; *Point = NULL; info.least = MAX_LINE_POINT_DISTANCE + SearchRadius; - info.locked = (locked & LOCKED_TYPE) ? 0 : LOCKFLAG; + info.locked = (locked & PCB_TYPE_LOCKED) ? 0 : LOCKFLAG; if (r_search(SearchLayer->line_tree, &SearchBox, NULL, linepoint_callback, &info, NULL)) return true; return false; @@ -469,7 +469,7 @@ info.ptr3 = (void **) Dummy; info.area = SQUARE(MAX_COORD); info.BackToo = (BackToo && PCB->InvisibleObjectsOn); - info.locked = (locked & LOCKED_TYPE) ? 0 : LOCKFLAG; + info.locked = (locked & PCB_TYPE_LOCKED) ? 0 : LOCKFLAG; if (r_search(PCB->Data->name_tree[NAME_INDEX()], &SearchBox, NULL, name_callback, &info, NULL)) return true; } @@ -514,7 +514,7 @@ info.ptr3 = (void **) Dummy2; info.area = SQUARE(MAX_COORD); info.BackToo = (BackToo && PCB->InvisibleObjectsOn); - info.locked = (locked & LOCKED_TYPE) ? 0 : LOCKFLAG; + info.locked = (locked & PCB_TYPE_LOCKED) ? 0 : LOCKFLAG; if (r_search(PCB->Data->element_tree, &SearchBox, NULL, element_callback, &info, NULL)) return true; } @@ -953,7 +953,7 @@ * searches for any kind of object or for a set of object types * the calling routine passes two pointers to allocated memory for storing * the results. - * A type value is returned too which is NO_TYPE if no objects has been found. + * A type value is returned too which is PCB_TYPE_NONE if no objects has been found. * A set of object types is passed in. * The object is located by it's position. * @@ -960,7 +960,7 @@ * The layout is checked in the following order: * polygon-point, pin, via, line, text, elementname, polygon, element * - * Note that if Type includes LOCKED_TYPE, then the search includes + * Note that if Type includes PCB_TYPE_LOCKED, then the search includes * locked items. Otherwise, locked items are ignored. */ int SearchObjectByLocation(unsigned Type, void **Result1, void **Result2, void **Result3, Coord X, Coord Y, Coord Radius) @@ -969,8 +969,8 @@ void **pr1 = &r1, **pr2 = &r2, **pr3 = &r3; int i; double HigherBound = 0; - int HigherAvail = NO_TYPE; - int locked = Type & LOCKED_TYPE; + int HigherAvail = PCB_TYPE_NONE; + int locked = Type & PCB_TYPE_LOCKED; /* setup variables used by local functions */ PosX = X; PosY = Y; @@ -986,44 +986,44 @@ } if (conf_core.editor.lock_names) { - Type &= ~(ELEMENTNAME_TYPE | TEXT_TYPE); + Type &= ~(PCB_TYPE_ELEMENT_NAME | PCB_TYPE_TEXT); } if (conf_core.editor.hide_names) { - Type &= ~ELEMENTNAME_TYPE; + Type &= ~PCB_TYPE_ELEMENT_NAME; } if (conf_core.editor.only_names) { - Type &= (ELEMENTNAME_TYPE | TEXT_TYPE); + Type &= (PCB_TYPE_ELEMENT_NAME | PCB_TYPE_TEXT); } if (conf_core.editor.thin_draw || conf_core.editor.thin_draw_poly) { - Type &= ~POLYGON_TYPE; + Type &= ~PCB_TYPE_POLYGON; } - if (Type & RATLINE_TYPE && PCB->RatOn && + if (Type & PCB_TYPE_RATLINE && PCB->RatOn && SearchRatLineByLocation(locked, (RatTypePtr *) Result1, (RatTypePtr *) Result2, (RatTypePtr *) Result3)) - return (RATLINE_TYPE); + return (PCB_TYPE_RATLINE); - if (Type & VIA_TYPE && SearchViaByLocation(locked, (PinTypePtr *) Result1, (PinTypePtr *) Result2, (PinTypePtr *) Result3)) - return (VIA_TYPE); + if (Type & PCB_TYPE_VIA && SearchViaByLocation(locked, (PinTypePtr *) Result1, (PinTypePtr *) Result2, (PinTypePtr *) Result3)) + return (PCB_TYPE_VIA); - if (Type & PIN_TYPE && SearchPinByLocation(locked, (ElementTypePtr *) pr1, (PinTypePtr *) pr2, (PinTypePtr *) pr3)) - HigherAvail = PIN_TYPE; + if (Type & PCB_TYPE_PIN && SearchPinByLocation(locked, (ElementTypePtr *) pr1, (PinTypePtr *) pr2, (PinTypePtr *) pr3)) + HigherAvail = PCB_TYPE_PIN; - if (!HigherAvail && Type & PAD_TYPE && + if (!HigherAvail && Type & PCB_TYPE_PAD && SearchPadByLocation(locked, (ElementTypePtr *) pr1, (PadTypePtr *) pr2, (PadTypePtr *) pr3, false)) - HigherAvail = PAD_TYPE; + HigherAvail = PCB_TYPE_PAD; - if (!HigherAvail && Type & ELEMENTNAME_TYPE && + if (!HigherAvail && Type & PCB_TYPE_ELEMENT_NAME && SearchElementNameByLocation(locked, (ElementTypePtr *) pr1, (TextTypePtr *) pr2, (TextTypePtr *) pr3, false)) { BoxTypePtr box = &((TextTypePtr) r2)->BoundingBox; HigherBound = (double) (box->X2 - box->X1) * (double) (box->Y2 - box->Y1); - HigherAvail = ELEMENTNAME_TYPE; + HigherAvail = PCB_TYPE_ELEMENT_NAME; } - if (!HigherAvail && Type & ELEMENT_TYPE && + if (!HigherAvail && Type & PCB_TYPE_ELEMENT && SearchElementByLocation(locked, (ElementTypePtr *) pr1, (ElementTypePtr *) pr2, (ElementTypePtr *) pr3, false)) { BoxTypePtr box = &((ElementTypePtr) r1)->BoundingBox; HigherBound = (double) (box->X2 - box->X1) * (double) (box->Y2 - box->Y1); - HigherAvail = ELEMENT_TYPE; + HigherAvail = PCB_TYPE_ELEMENT; } for (i = -1; i < max_copper_layer + 1; i++) { @@ -1037,29 +1037,29 @@ continue; } if (SearchLayer->On) { - if ((HigherAvail & (PIN_TYPE | PAD_TYPE)) == 0 && - Type & POLYGONPOINT_TYPE && + if ((HigherAvail & (PCB_TYPE_PIN | PCB_TYPE_PAD)) == 0 && + Type & PCB_TYPE_POLYGON_POINT && SearchPointByLocation(locked, (LayerTypePtr *) Result1, (PolygonTypePtr *) Result2, (PointTypePtr *) Result3)) - return (POLYGONPOINT_TYPE); + return (PCB_TYPE_POLYGON_POINT); - if ((HigherAvail & (PIN_TYPE | PAD_TYPE)) == 0 && - Type & LINEPOINT_TYPE && + if ((HigherAvail & (PCB_TYPE_PIN | PCB_TYPE_PAD)) == 0 && + Type & PCB_TYPE_LINE_POINT && SearchLinePointByLocation(locked, (LayerTypePtr *) Result1, (LineTypePtr *) Result2, (PointTypePtr *) Result3)) - return (LINEPOINT_TYPE); + return (PCB_TYPE_LINE_POINT); - if ((HigherAvail & (PIN_TYPE | PAD_TYPE)) == 0 && Type & LINE_TYPE + if ((HigherAvail & (PCB_TYPE_PIN | PCB_TYPE_PAD)) == 0 && Type & PCB_TYPE_LINE && SearchLineByLocation(locked, (LayerTypePtr *) Result1, (LineTypePtr *) Result2, (LineTypePtr *) Result3)) - return (LINE_TYPE); + return (PCB_TYPE_LINE); - if ((HigherAvail & (PIN_TYPE | PAD_TYPE)) == 0 && Type & ARC_TYPE && + if ((HigherAvail & (PCB_TYPE_PIN | PCB_TYPE_PAD)) == 0 && Type & PCB_TYPE_ARC && SearchArcByLocation(locked, (LayerTypePtr *) Result1, (ArcTypePtr *) Result2, (ArcTypePtr *) Result3)) - return (ARC_TYPE); + return (PCB_TYPE_ARC); - if ((HigherAvail & (PIN_TYPE | PAD_TYPE)) == 0 && Type & TEXT_TYPE + if ((HigherAvail & (PCB_TYPE_PIN | PCB_TYPE_PAD)) == 0 && Type & PCB_TYPE_TEXT && SearchTextByLocation(locked, (LayerTypePtr *) Result1, (TextTypePtr *) Result2, (TextTypePtr *) Result3)) - return (TEXT_TYPE); + return (PCB_TYPE_TEXT); - if (Type & POLYGON_TYPE && + if (Type & PCB_TYPE_POLYGON && SearchPolygonByLocation(locked, (LayerTypePtr *) Result1, (PolygonTypePtr *) Result2, (PolygonTypePtr *) Result3)) { if (HigherAvail) { BoxTypePtr box = &(*(PolygonTypePtr *) Result2)->BoundingBox; @@ -1067,59 +1067,59 @@ if (HigherBound < area) break; else - return (POLYGON_TYPE); + return (PCB_TYPE_POLYGON); } else - return (POLYGON_TYPE); + return (PCB_TYPE_POLYGON); } } } /* return any previously found objects */ - if (HigherAvail & PIN_TYPE) { + if (HigherAvail & PCB_TYPE_PIN) { *Result1 = r1; *Result2 = r2; *Result3 = r3; - return (PIN_TYPE); + return (PCB_TYPE_PIN); } - if (HigherAvail & PAD_TYPE) { + if (HigherAvail & PCB_TYPE_PAD) { *Result1 = r1; *Result2 = r2; *Result3 = r3; - return (PAD_TYPE); + return (PCB_TYPE_PAD); } - if (HigherAvail & ELEMENTNAME_TYPE) { + if (HigherAvail & PCB_TYPE_ELEMENT_NAME) { *Result1 = r1; *Result2 = r2; *Result3 = r3; - return (ELEMENTNAME_TYPE); + return (PCB_TYPE_ELEMENT_NAME); } - if (HigherAvail & ELEMENT_TYPE) { + if (HigherAvail & PCB_TYPE_ELEMENT) { *Result1 = r1; *Result2 = r2; *Result3 = r3; - return (ELEMENT_TYPE); + return (PCB_TYPE_ELEMENT); } /* search the 'invisible objects' last */ if (!PCB->InvisibleObjectsOn) - return (NO_TYPE); + return (PCB_TYPE_NONE); - if (Type & PAD_TYPE && + if (Type & PCB_TYPE_PAD && SearchPadByLocation(locked, (ElementTypePtr *) Result1, (PadTypePtr *) Result2, (PadTypePtr *) Result3, true)) - return (PAD_TYPE); + return (PCB_TYPE_PAD); - if (Type & ELEMENTNAME_TYPE && + if (Type & PCB_TYPE_ELEMENT_NAME && SearchElementNameByLocation(locked, (ElementTypePtr *) Result1, (TextTypePtr *) Result2, (TextTypePtr *) Result3, true)) - return (ELEMENTNAME_TYPE); + return (PCB_TYPE_ELEMENT_NAME); - if (Type & ELEMENT_TYPE && + if (Type & PCB_TYPE_ELEMENT && SearchElementByLocation(locked, (ElementTypePtr *) Result1, (ElementTypePtr *) Result2, (ElementTypePtr *) Result3, true)) - return (ELEMENT_TYPE); + return (PCB_TYPE_ELEMENT); - return (NO_TYPE); + return (PCB_TYPE_NONE); } /* --------------------------------------------------------------------------- @@ -1128,66 +1128,66 @@ * buffer or on the remove list. * The calling routine passes two pointers to allocated memory for storing * the results. - * A type value is returned too which is NO_TYPE if no objects has been found. + * A type value is returned too which is PCB_TYPE_NONE if no objects has been found. */ int SearchObjectByID(DataTypePtr Base, void **Result1, void **Result2, void **Result3, int ID, int type) { - if (type == LINE_TYPE || type == LINEPOINT_TYPE) { + if (type == PCB_TYPE_LINE || type == PCB_TYPE_LINE_POINT) { ALLLINE_LOOP(Base); { if (line->ID == ID) { *Result1 = (void *) layer; *Result2 = *Result3 = (void *) line; - return (LINE_TYPE); + return (PCB_TYPE_LINE); } if (line->Point1.ID == ID) { *Result1 = (void *) layer; *Result2 = (void *) line; *Result3 = (void *) &line->Point1; - return (LINEPOINT_TYPE); + return (PCB_TYPE_LINE_POINT); } if (line->Point2.ID == ID) { *Result1 = (void *) layer; *Result2 = (void *) line; *Result3 = (void *) &line->Point2; - return (LINEPOINT_TYPE); + return (PCB_TYPE_LINE_POINT); } } ENDALL_LOOP; } - if (type == ARC_TYPE) { + if (type == PCB_TYPE_ARC) { ALLARC_LOOP(Base); { if (arc->ID == ID) { *Result1 = (void *) layer; *Result2 = *Result3 = (void *) arc; - return (ARC_TYPE); + return (PCB_TYPE_ARC); } } ENDALL_LOOP; } - if (type == TEXT_TYPE) { + if (type == PCB_TYPE_TEXT) { ALLTEXT_LOOP(Base); { if (text->ID == ID) { *Result1 = (void *) layer; *Result2 = *Result3 = (void *) text; - return (TEXT_TYPE); + return (PCB_TYPE_TEXT); } } ENDALL_LOOP; } - if (type == POLYGON_TYPE || type == POLYGONPOINT_TYPE) { + if (type == PCB_TYPE_POLYGON || type == PCB_TYPE_POLYGON_POINT) { ALLPOLYGON_LOOP(Base); { if (polygon->ID == ID) { *Result1 = (void *) layer; *Result2 = *Result3 = (void *) polygon; - return (POLYGON_TYPE); + return (PCB_TYPE_POLYGON); } - if (type == POLYGONPOINT_TYPE) + if (type == PCB_TYPE_POLYGON_POINT) POLYGONPOINT_LOOP(polygon); { if (point->ID == ID) { @@ -1194,7 +1194,7 @@ *Result1 = (void *) layer; *Result2 = (void *) polygon; *Result3 = (void *) point; - return (POLYGONPOINT_TYPE); + return (PCB_TYPE_POLYGON_POINT); } } END_LOOP; @@ -1201,96 +1201,96 @@ } ENDALL_LOOP; } - if (type == VIA_TYPE) { + if (type == PCB_TYPE_VIA) { VIA_LOOP(Base); { if (via->ID == ID) { *Result1 = *Result2 = *Result3 = (void *) via; - return (VIA_TYPE); + return (PCB_TYPE_VIA); } } END_LOOP; } - if (type == RATLINE_TYPE || type == LINEPOINT_TYPE) { + if (type == PCB_TYPE_RATLINE || type == PCB_TYPE_LINE_POINT) { RAT_LOOP(Base); { if (line->ID == ID) { *Result1 = *Result2 = *Result3 = (void *) line; - return (RATLINE_TYPE); + return (PCB_TYPE_RATLINE); } if (line->Point1.ID == ID) { *Result1 = (void *) NULL; *Result2 = (void *) line; *Result3 = (void *) &line->Point1; - return (LINEPOINT_TYPE); + return (PCB_TYPE_LINE_POINT); } if (line->Point2.ID == ID) { *Result1 = (void *) NULL; *Result2 = (void *) line; *Result3 = (void *) &line->Point2; - return (LINEPOINT_TYPE); + return (PCB_TYPE_LINE_POINT); } } END_LOOP; } - if (type == ELEMENT_TYPE || type == PAD_TYPE || type == PIN_TYPE - || type == ELEMENTLINE_TYPE || type == ELEMENTNAME_TYPE || type == ELEMENTARC_TYPE) + if (type == PCB_TYPE_ELEMENT || type == PCB_TYPE_PAD || type == PCB_TYPE_PIN + || type == PCB_TYPE_ELEMENT_LINE || type == PCB_TYPE_ELEMENT_NAME || type == PCB_TYPE_ELEMENT_ARC) /* check pins and elementnames too */ ELEMENT_LOOP(Base); { if (element->ID == ID) { *Result1 = *Result2 = *Result3 = (void *) element; - return (ELEMENT_TYPE); + return (PCB_TYPE_ELEMENT); } - if (type == ELEMENTLINE_TYPE) + if (type == PCB_TYPE_ELEMENT_LINE) ELEMENTLINE_LOOP(element); { if (line->ID == ID) { *Result1 = (void *) element; *Result2 = *Result3 = (void *) line; - return (ELEMENTLINE_TYPE); + return (PCB_TYPE_ELEMENT_LINE); } } END_LOOP; - if (type == ELEMENTARC_TYPE) + if (type == PCB_TYPE_ELEMENT_ARC) ARC_LOOP(element); { if (arc->ID == ID) { *Result1 = (void *) element; *Result2 = *Result3 = (void *) arc; - return (ELEMENTARC_TYPE); + return (PCB_TYPE_ELEMENT_ARC); } } END_LOOP; - if (type == ELEMENTNAME_TYPE) + if (type == PCB_TYPE_ELEMENT_NAME) ELEMENTTEXT_LOOP(element); { if (text->ID == ID) { *Result1 = (void *) element; *Result2 = *Result3 = (void *) text; - return (ELEMENTNAME_TYPE); + return (PCB_TYPE_ELEMENT_NAME); } } END_LOOP; - if (type == PIN_TYPE) + if (type == PCB_TYPE_PIN) PIN_LOOP(element); { if (pin->ID == ID) { *Result1 = (void *) element; *Result2 = *Result3 = (void *) pin; - return (PIN_TYPE); + return (PCB_TYPE_PIN); } } END_LOOP; - if (type == PAD_TYPE) + if (type == PCB_TYPE_PAD) PAD_LOOP(element); { if (pad->ID == ID) { *Result1 = (void *) element; *Result2 = *Result3 = (void *) pad; - return (PAD_TYPE); + return (PCB_TYPE_PAD); } } END_LOOP; @@ -1298,7 +1298,7 @@ END_LOOP; Message("hace: Internal error, search for ID %d failed\n", ID); - return (NO_TYPE); + return (PCB_TYPE_NONE); } /* --------------------------------------------------------------------------- Index: trunk/src/select.c =================================================================== --- trunk/src/select.c (revision 2502) +++ trunk/src/select.c (revision 2503) @@ -63,64 +63,64 @@ bool changed = true; type = SearchScreen(Crosshair.X, Crosshair.Y, SELECT_TYPES, &ptr1, &ptr2, &ptr3); - if (type == NO_TYPE || TEST_FLAG(LOCKFLAG, (PinTypePtr) ptr2)) + if (type == PCB_TYPE_NONE || TEST_FLAG(LOCKFLAG, (PinTypePtr) ptr2)) return (false); switch (type) { - case VIA_TYPE: - AddObjectToFlagUndoList(VIA_TYPE, ptr1, ptr1, ptr1); + case PCB_TYPE_VIA: + AddObjectToFlagUndoList(PCB_TYPE_VIA, ptr1, ptr1, ptr1); TOGGLE_FLAG(SELECTEDFLAG, (PinTypePtr) ptr1); DrawVia((PinTypePtr) ptr1); break; - case LINE_TYPE: + case PCB_TYPE_LINE: { LineType *line = (LineTypePtr) ptr2; layer = (LayerTypePtr) ptr1; - AddObjectToFlagUndoList(LINE_TYPE, ptr1, ptr2, ptr2); + AddObjectToFlagUndoList(PCB_TYPE_LINE, ptr1, ptr2, ptr2); TOGGLE_FLAG(SELECTEDFLAG, line); DrawLine(layer, line); break; } - case RATLINE_TYPE: + case PCB_TYPE_RATLINE: { RatTypePtr rat = (RatTypePtr) ptr2; - AddObjectToFlagUndoList(RATLINE_TYPE, ptr1, ptr1, ptr1); + AddObjectToFlagUndoList(PCB_TYPE_RATLINE, ptr1, ptr1, ptr1); TOGGLE_FLAG(SELECTEDFLAG, rat); DrawRat(rat); break; } - case ARC_TYPE: + case PCB_TYPE_ARC: { ArcType *arc = (ArcTypePtr) ptr2; layer = (LayerTypePtr) ptr1; - AddObjectToFlagUndoList(ARC_TYPE, ptr1, ptr2, ptr2); + AddObjectToFlagUndoList(PCB_TYPE_ARC, ptr1, ptr2, ptr2); TOGGLE_FLAG(SELECTEDFLAG, arc); DrawArc(layer, arc); break; } - case TEXT_TYPE: + case PCB_TYPE_TEXT: { TextType *text = (TextTypePtr) ptr2; layer = (LayerTypePtr) ptr1; - AddObjectToFlagUndoList(TEXT_TYPE, ptr1, ptr2, ptr2); + AddObjectToFlagUndoList(PCB_TYPE_TEXT, ptr1, ptr2, ptr2); TOGGLE_FLAG(SELECTEDFLAG, text); DrawText(layer, text); break; } - case POLYGON_TYPE: + case PCB_TYPE_POLYGON: { PolygonType *poly = (PolygonTypePtr) ptr2; layer = (LayerTypePtr) ptr1; - AddObjectToFlagUndoList(POLYGON_TYPE, ptr1, ptr2, ptr2); + AddObjectToFlagUndoList(PCB_TYPE_POLYGON, ptr1, ptr2, ptr2); TOGGLE_FLAG(SELECTEDFLAG, poly); DrawPolygon(layer, poly); /* changing memory order no longer effects draw order */ @@ -127,19 +127,19 @@ break; } - case PIN_TYPE: - AddObjectToFlagUndoList(PIN_TYPE, ptr1, ptr2, ptr2); + case PCB_TYPE_PIN: + AddObjectToFlagUndoList(PCB_TYPE_PIN, ptr1, ptr2, ptr2); TOGGLE_FLAG(SELECTEDFLAG, (PinTypePtr) ptr2); DrawPin((PinTypePtr) ptr2); break; - case PAD_TYPE: - AddObjectToFlagUndoList(PAD_TYPE, ptr1, ptr2, ptr2); + case PCB_TYPE_PAD: + AddObjectToFlagUndoList(PCB_TYPE_PAD, ptr1, ptr2, ptr2); TOGGLE_FLAG(SELECTEDFLAG, (PadTypePtr) ptr2); DrawPad((PadTypePtr) ptr2); break; - case ELEMENTNAME_TYPE: + case PCB_TYPE_ELEMENT_NAME: { ElementTypePtr element = (ElementTypePtr) ptr1; @@ -146,7 +146,7 @@ /* select all names of the element */ ELEMENTTEXT_LOOP(element); { - AddObjectToFlagUndoList(ELEMENTNAME_TYPE, element, text, text); + AddObjectToFlagUndoList(PCB_TYPE_ELEMENT_NAME, element, text, text); TOGGLE_FLAG(SELECTEDFLAG, text); } END_LOOP; @@ -154,7 +154,7 @@ break; } - case ELEMENT_TYPE: + case PCB_TYPE_ELEMENT: { ElementTypePtr element = (ElementTypePtr) ptr1; @@ -161,23 +161,23 @@ /* select all pins and names of the element */ PIN_LOOP(element); { - AddObjectToFlagUndoList(PIN_TYPE, element, pin, pin); + AddObjectToFlagUndoList(PCB_TYPE_PIN, element, pin, pin); TOGGLE_FLAG(SELECTEDFLAG, pin); } END_LOOP; PAD_LOOP(element); { - AddObjectToFlagUndoList(PAD_TYPE, element, pad, pad); + AddObjectToFlagUndoList(PCB_TYPE_PAD, element, pad, pad); TOGGLE_FLAG(SELECTEDFLAG, pad); } END_LOOP; ELEMENTTEXT_LOOP(element); { - AddObjectToFlagUndoList(ELEMENTNAME_TYPE, element, text, text); + AddObjectToFlagUndoList(PCB_TYPE_ELEMENT_NAME, element, text, text); TOGGLE_FLAG(SELECTEDFLAG, text); } END_LOOP; - AddObjectToFlagUndoList(ELEMENT_TYPE, element, element, element); + AddObjectToFlagUndoList(PCB_TYPE_ELEMENT, element, element, element); TOGGLE_FLAG(SELECTEDFLAG, element); if (PCB->ElementOn && ((TEST_FLAG(ONSOLDERFLAG, element) != 0) == SWAP_IDENT || PCB->InvisibleObjectsOn)) if (PCB->ElementOn) { @@ -237,7 +237,7 @@ RAT_LOOP(PCB->Data); { if (LINE_NEAR_BOX((LineTypePtr) line, Box) && !TEST_FLAG(LOCKFLAG, line) && TEST_FLAG(SELECTEDFLAG, line) != Flag) { - append(RATLINE_TYPE, line, line); + append(PCB_TYPE_RATLINE, line, line); if (PCB->RatOn) DrawRat(line); } @@ -263,7 +263,7 @@ if (LINE_NEAR_BOX(line, Box) && !TEST_FLAG(LOCKFLAG, line) && TEST_FLAG(SELECTEDFLAG, line) != Flag) { - append(LINE_TYPE, layer, line); + append(PCB_TYPE_LINE, layer, line); if (layer->On) DrawLine(layer, line); } @@ -274,7 +274,7 @@ if (ARC_NEAR_BOX(arc, Box) && !TEST_FLAG(LOCKFLAG, arc) && TEST_FLAG(SELECTEDFLAG, arc) != Flag) { - append(ARC_TYPE, layer, arc); + append(PCB_TYPE_ARC, layer, arc); if (layer->On) DrawArc(layer, arc); } @@ -286,7 +286,7 @@ if (TEXT_NEAR_BOX(text, Box) && !TEST_FLAG(LOCKFLAG, text) && TEST_FLAG(SELECTEDFLAG, text) != Flag) { - append(TEXT_TYPE, layer, text); + append(PCB_TYPE_TEXT, layer, text); if (TEXT_IS_VISIBLE(PCB, layer, text)) DrawText(layer, text); } @@ -298,7 +298,7 @@ if (POLYGON_NEAR_BOX(polygon, Box) && !TEST_FLAG(LOCKFLAG, polygon) && TEST_FLAG(SELECTEDFLAG, polygon) != Flag) { - append(POLYGON_TYPE, layer, polygon); + append(PCB_TYPE_POLYGON, layer, polygon); if (layer->On) DrawPolygon(layer, polygon); } @@ -321,7 +321,7 @@ /* select all names of element */ ELEMENTTEXT_LOOP(element); { - append(ELEMENTNAME_TYPE, element, text); + append(PCB_TYPE_ELEMENT_NAME, element, text); } END_LOOP; if (PCB->ElementOn) @@ -329,11 +329,11 @@ } if ((PCB->PinOn || !Flag) && ELEMENT_NEAR_BOX(element, Box)) if (TEST_FLAG(SELECTEDFLAG, element) != Flag) { - append(ELEMENT_TYPE, element, element); + append(PCB_TYPE_ELEMENT, element, element); PIN_LOOP(element); { if (TEST_FLAG(SELECTEDFLAG, pin) != Flag) { - append(PIN_TYPE, element, pin); + append(PCB_TYPE_PIN, element, pin); if (PCB->PinOn) DrawPin(pin); } @@ -342,7 +342,7 @@ PAD_LOOP(element); { if (TEST_FLAG(SELECTEDFLAG, pad) != Flag) { - append(PAD_TYPE, element, pad); + append(PCB_TYPE_PAD, element, pad); if (PCB->PinOn) DrawPad(pad); } @@ -358,7 +358,7 @@ { if ((VIA_OR_PIN_NEAR_BOX(pin, Box) && TEST_FLAG(SELECTEDFLAG, pin) != Flag)) { - append(PIN_TYPE, element, pin); + append(PCB_TYPE_PIN, element, pin); if (PCB->PinOn) DrawPin(pin); } @@ -369,7 +369,7 @@ if (PAD_NEAR_BOX(pad, Box) && TEST_FLAG(SELECTEDFLAG, pad) != Flag && (TEST_FLAG(ONSOLDERFLAG, pad) == SWAP_IDENT || PCB->InvisibleObjectsOn || !Flag)) { - append(PAD_TYPE, element, pad); + append(PCB_TYPE_PAD, element, pad); if (PCB->PinOn) DrawPad(pad); } @@ -386,7 +386,7 @@ if (VIA_OR_PIN_NEAR_BOX(via, Box) && !TEST_FLAG(LOCKFLAG, via) && TEST_FLAG(SELECTEDFLAG, via) != Flag) { - append(VIA_TYPE, via, via); + append(PCB_TYPE_VIA, via, via); if (PCB->ViaOn) DrawVia(via); } @@ -435,62 +435,62 @@ void *ObjectOperation(ObjectFunctionTypePtr F, int Type, void *Ptr1, void *Ptr2, void *Ptr3) { switch (Type) { - case LINE_TYPE: + case PCB_TYPE_LINE: if (F->Line) return (F->Line((LayerTypePtr) Ptr1, (LineTypePtr) Ptr2)); break; - case ARC_TYPE: + case PCB_TYPE_ARC: if (F->Arc) return (F->Arc((LayerTypePtr) Ptr1, (ArcTypePtr) Ptr2)); break; - case LINEPOINT_TYPE: + case PCB_TYPE_LINE_POINT: if (F->LinePoint) return (F->LinePoint((LayerTypePtr) Ptr1, (LineTypePtr) Ptr2, (PointTypePtr) Ptr3)); break; - case TEXT_TYPE: + case PCB_TYPE_TEXT: if (F->Text) return (F->Text((LayerTypePtr) Ptr1, (TextTypePtr) Ptr2)); break; - case POLYGON_TYPE: + case PCB_TYPE_POLYGON: if (F->Polygon) return (F->Polygon((LayerTypePtr) Ptr1, (PolygonTypePtr) Ptr2)); break; - case POLYGONPOINT_TYPE: + case PCB_TYPE_POLYGON_POINT: if (F->Point) return (F->Point((LayerTypePtr) Ptr1, (PolygonTypePtr) Ptr2, (PointTypePtr) Ptr3)); break; - case VIA_TYPE: + case PCB_TYPE_VIA: if (F->Via) return (F->Via((PinTypePtr) Ptr1)); break; - case ELEMENT_TYPE: + case PCB_TYPE_ELEMENT: if (F->Element) return (F->Element((ElementTypePtr) Ptr1)); break; - case PIN_TYPE: + case PCB_TYPE_PIN: if (F->Pin) return (F->Pin((ElementTypePtr) Ptr1, (PinTypePtr) Ptr2)); break; - case PAD_TYPE: + case PCB_TYPE_PAD: if (F->Pad) return (F->Pad((ElementTypePtr) Ptr1, (PadTypePtr) Ptr2)); break; - case ELEMENTNAME_TYPE: + case PCB_TYPE_ELEMENT_NAME: if (F->ElementName) return (F->ElementName((ElementTypePtr) Ptr1)); break; - case RATLINE_TYPE: + case PCB_TYPE_RATLINE: if (F->Rat) return (F->Rat((RatTypePtr) Ptr1)); break; @@ -509,12 +509,12 @@ bool changed = false; /* check lines */ - if (type & LINE_TYPE && F->Line) + if (type & PCB_TYPE_LINE && F->Line) VISIBLELINE_LOOP(PCB->Data); { if (TEST_FLAG(SELECTEDFLAG, line)) { if (Reset) { - AddObjectToFlagUndoList(LINE_TYPE, layer, line, line); + AddObjectToFlagUndoList(PCB_TYPE_LINE, layer, line, line); CLEAR_FLAG(SELECTEDFLAG, line); } F->Line(layer, line); @@ -524,12 +524,12 @@ ENDALL_LOOP; /* check arcs */ - if (type & ARC_TYPE && F->Arc) + if (type & PCB_TYPE_ARC && F->Arc) VISIBLEARC_LOOP(PCB->Data); { if (TEST_FLAG(SELECTEDFLAG, arc)) { if (Reset) { - AddObjectToFlagUndoList(ARC_TYPE, layer, arc, arc); + AddObjectToFlagUndoList(PCB_TYPE_ARC, layer, arc, arc); CLEAR_FLAG(SELECTEDFLAG, arc); } F->Arc(layer, arc); @@ -539,12 +539,12 @@ ENDALL_LOOP; /* check text */ - if (type & TEXT_TYPE && F->Text) + if (type & PCB_TYPE_TEXT && F->Text) ALLTEXT_LOOP(PCB->Data); { if (TEST_FLAG(SELECTEDFLAG, text) && TEXT_IS_VISIBLE(PCB, layer, text)) { if (Reset) { - AddObjectToFlagUndoList(TEXT_TYPE, layer, text, text); + AddObjectToFlagUndoList(PCB_TYPE_TEXT, layer, text, text); CLEAR_FLAG(SELECTEDFLAG, text); } F->Text(layer, text); @@ -554,12 +554,12 @@ ENDALL_LOOP; /* check polygons */ - if (type & POLYGON_TYPE && F->Polygon) + if (type & PCB_TYPE_POLYGON && F->Polygon) VISIBLEPOLYGON_LOOP(PCB->Data); { if (TEST_FLAG(SELECTEDFLAG, polygon)) { if (Reset) { - AddObjectToFlagUndoList(POLYGON_TYPE, layer, polygon, polygon); + AddObjectToFlagUndoList(PCB_TYPE_POLYGON, layer, polygon, polygon); CLEAR_FLAG(SELECTEDFLAG, polygon); } F->Polygon(layer, polygon); @@ -569,12 +569,12 @@ ENDALL_LOOP; /* elements silkscreen */ - if (type & ELEMENT_TYPE && PCB->ElementOn && F->Element) + if (type & PCB_TYPE_ELEMENT && PCB->ElementOn && F->Element) ELEMENT_LOOP(PCB->Data); { if (TEST_FLAG(SELECTEDFLAG, element)) { if (Reset) { - AddObjectToFlagUndoList(ELEMENT_TYPE, element, element, element); + AddObjectToFlagUndoList(PCB_TYPE_ELEMENT, element, element, element); CLEAR_FLAG(SELECTEDFLAG, element); } F->Element(element); @@ -582,12 +582,12 @@ } } END_LOOP; - if (type & ELEMENTNAME_TYPE && PCB->ElementOn && F->ElementName) + if (type & PCB_TYPE_ELEMENT_NAME && PCB->ElementOn && F->ElementName) ELEMENT_LOOP(PCB->Data); { if (TEST_FLAG(SELECTEDFLAG, &ELEMENT_TEXT(PCB, element))) { if (Reset) { - AddObjectToFlagUndoList(ELEMENTNAME_TYPE, element, &ELEMENT_TEXT(PCB, element), &ELEMENT_TEXT(PCB, element)); + AddObjectToFlagUndoList(PCB_TYPE_ELEMENT_NAME, element, &ELEMENT_TEXT(PCB, element), &ELEMENT_TEXT(PCB, element)); CLEAR_FLAG(SELECTEDFLAG, &ELEMENT_TEXT(PCB, element)); } F->ElementName(element); @@ -596,7 +596,7 @@ } END_LOOP; - if (type & PIN_TYPE && PCB->PinOn && F->Pin) + if (type & PCB_TYPE_PIN && PCB->PinOn && F->Pin) ELEMENT_LOOP(PCB->Data); { PIN_LOOP(element); @@ -603,7 +603,7 @@ { if (TEST_FLAG(SELECTEDFLAG, pin)) { if (Reset) { - AddObjectToFlagUndoList(PIN_TYPE, element, pin, pin); + AddObjectToFlagUndoList(PCB_TYPE_PIN, element, pin, pin); CLEAR_FLAG(SELECTEDFLAG, pin); } F->Pin(element, pin); @@ -614,7 +614,7 @@ } END_LOOP; - if (type & PAD_TYPE && PCB->PinOn && F->Pad) + if (type & PCB_TYPE_PAD && PCB->PinOn && F->Pad) ELEMENT_LOOP(PCB->Data); { PAD_LOOP(element); @@ -621,7 +621,7 @@ { if (TEST_FLAG(SELECTEDFLAG, pad)) { if (Reset) { - AddObjectToFlagUndoList(PAD_TYPE, element, pad, pad); + AddObjectToFlagUndoList(PCB_TYPE_PAD, element, pad, pad); CLEAR_FLAG(SELECTEDFLAG, pad); } F->Pad(element, pad); @@ -633,12 +633,12 @@ END_LOOP; /* process vias */ - if (type & VIA_TYPE && PCB->ViaOn && F->Via) + if (type & PCB_TYPE_VIA && PCB->ViaOn && F->Via) VIA_LOOP(PCB->Data); { if (TEST_FLAG(SELECTEDFLAG, via)) { if (Reset) { - AddObjectToFlagUndoList(VIA_TYPE, via, via, via); + AddObjectToFlagUndoList(PCB_TYPE_VIA, via, via, via); CLEAR_FLAG(SELECTEDFLAG, via); } F->Via(via); @@ -647,12 +647,12 @@ } END_LOOP; /* and rat-lines */ - if (type & RATLINE_TYPE && PCB->RatOn && F->Rat) + if (type & PCB_TYPE_RATLINE && PCB->RatOn && F->Rat) RAT_LOOP(PCB->Data); { if (TEST_FLAG(SELECTEDFLAG, line)) { if (Reset) { - AddObjectToFlagUndoList(RATLINE_TYPE, line, line, line); + AddObjectToFlagUndoList(PCB_TYPE_RATLINE, line, line, line); CLEAR_FLAG(SELECTEDFLAG, line); } F->Rat(line); @@ -680,7 +680,7 @@ RAT_LOOP(PCB->Data); { if (TEST_FLAG(FOUNDFLAG, line)) { - AddObjectToFlagUndoList(RATLINE_TYPE, line, line, line); + AddObjectToFlagUndoList(PCB_TYPE_RATLINE, line, line, line); ASSIGN_FLAG(SELECTEDFLAG, Flag, line); DrawRat(line); changed = true; @@ -691,7 +691,7 @@ VISIBLELINE_LOOP(PCB->Data); { if (TEST_FLAG(FOUNDFLAG, line) && !TEST_FLAG(LOCKFLAG, line)) { - AddObjectToFlagUndoList(LINE_TYPE, layer, line, line); + AddObjectToFlagUndoList(PCB_TYPE_LINE, layer, line, line); ASSIGN_FLAG(SELECTEDFLAG, Flag, line); DrawLine(layer, line); changed = true; @@ -701,7 +701,7 @@ VISIBLEARC_LOOP(PCB->Data); { if (TEST_FLAG(FOUNDFLAG, arc) && !TEST_FLAG(LOCKFLAG, arc)) { - AddObjectToFlagUndoList(ARC_TYPE, layer, arc, arc); + AddObjectToFlagUndoList(PCB_TYPE_ARC, layer, arc, arc); ASSIGN_FLAG(SELECTEDFLAG, Flag, arc); DrawArc(layer, arc); changed = true; @@ -711,7 +711,7 @@ VISIBLEPOLYGON_LOOP(PCB->Data); { if (TEST_FLAG(FOUNDFLAG, polygon) && !TEST_FLAG(LOCKFLAG, polygon)) { - AddObjectToFlagUndoList(POLYGON_TYPE, layer, polygon, polygon); + AddObjectToFlagUndoList(PCB_TYPE_POLYGON, layer, polygon, polygon); ASSIGN_FLAG(SELECTEDFLAG, Flag, polygon); DrawPolygon(layer, polygon); changed = true; @@ -723,7 +723,7 @@ ALLPIN_LOOP(PCB->Data); { if (!TEST_FLAG(LOCKFLAG, element) && TEST_FLAG(FOUNDFLAG, pin)) { - AddObjectToFlagUndoList(PIN_TYPE, element, pin, pin); + AddObjectToFlagUndoList(PCB_TYPE_PIN, element, pin, pin); ASSIGN_FLAG(SELECTEDFLAG, Flag, pin); DrawPin(pin); changed = true; @@ -733,7 +733,7 @@ ALLPAD_LOOP(PCB->Data); { if (!TEST_FLAG(LOCKFLAG, element) && TEST_FLAG(FOUNDFLAG, pad)) { - AddObjectToFlagUndoList(PAD_TYPE, element, pad, pad); + AddObjectToFlagUndoList(PCB_TYPE_PAD, element, pad, pad); ASSIGN_FLAG(SELECTEDFLAG, Flag, pad); DrawPad(pad); changed = true; @@ -746,7 +746,7 @@ VIA_LOOP(PCB->Data); { if (TEST_FLAG(FOUNDFLAG, via) && !TEST_FLAG(LOCKFLAG, via)) { - AddObjectToFlagUndoList(VIA_TYPE, via, via, via); + AddObjectToFlagUndoList(PCB_TYPE_VIA, via, via, via); ASSIGN_FLAG(SELECTEDFLAG, Flag, via); DrawVia(via); changed = true; @@ -849,7 +849,7 @@ } /* loop over all visible objects with names */ - if (Type & TEXT_TYPE) + if (Type & PCB_TYPE_TEXT) ALLTEXT_LOOP(PCB->Data); { if (!TEST_FLAG(LOCKFLAG, text) @@ -856,7 +856,7 @@ && TEXT_IS_VISIBLE(PCB, layer, text) && text->TextString && REGEXEC(text->TextString) && TEST_FLAG(SELECTEDFLAG, text) != Flag) { - AddObjectToFlagUndoList(TEXT_TYPE, layer, text, text); + AddObjectToFlagUndoList(PCB_TYPE_TEXT, layer, text, text); ASSIGN_FLAG(SELECTEDFLAG, Flag, text); DrawText(layer, text); changed = true; @@ -864,7 +864,7 @@ } ENDALL_LOOP; - if (PCB->ElementOn && (Type & ELEMENT_TYPE)) + if (PCB->ElementOn && (Type & PCB_TYPE_ELEMENT)) ELEMENT_LOOP(PCB->Data); { if (!TEST_FLAG(LOCKFLAG, element) @@ -872,23 +872,23 @@ && TEST_FLAG(SELECTEDFLAG, element) != Flag) { String name = ELEMENT_NAME(PCB, element); if (name && REGEXEC(name)) { - AddObjectToFlagUndoList(ELEMENT_TYPE, element, element, element); + AddObjectToFlagUndoList(PCB_TYPE_ELEMENT, element, element, element); ASSIGN_FLAG(SELECTEDFLAG, Flag, element); PIN_LOOP(element); { - AddObjectToFlagUndoList(PIN_TYPE, element, pin, pin); + AddObjectToFlagUndoList(PCB_TYPE_PIN, element, pin, pin); ASSIGN_FLAG(SELECTEDFLAG, Flag, pin); } END_LOOP; PAD_LOOP(element); { - AddObjectToFlagUndoList(PAD_TYPE, element, pad, pad); + AddObjectToFlagUndoList(PCB_TYPE_PAD, element, pad, pad); ASSIGN_FLAG(SELECTEDFLAG, Flag, pad); } END_LOOP; ELEMENTTEXT_LOOP(element); { - AddObjectToFlagUndoList(ELEMENTNAME_TYPE, element, text, text); + AddObjectToFlagUndoList(PCB_TYPE_ELEMENT_NAME, element, text, text); ASSIGN_FLAG(SELECTEDFLAG, Flag, text); } END_LOOP; @@ -899,13 +899,13 @@ } } END_LOOP; - if (PCB->PinOn && (Type & PIN_TYPE)) + if (PCB->PinOn && (Type & PCB_TYPE_PIN)) ALLPIN_LOOP(PCB->Data); { if (!TEST_FLAG(LOCKFLAG, element) && pin->Name && REGEXEC(pin->Name) && TEST_FLAG(SELECTEDFLAG, pin) != Flag) { - AddObjectToFlagUndoList(PIN_TYPE, element, pin, pin); + AddObjectToFlagUndoList(PCB_TYPE_PIN, element, pin, pin); ASSIGN_FLAG(SELECTEDFLAG, Flag, pin); DrawPin(pin); changed = true; @@ -912,7 +912,7 @@ } } ENDALL_LOOP; - if (PCB->PinOn && (Type & PAD_TYPE)) + if (PCB->PinOn && (Type & PCB_TYPE_PAD)) ALLPAD_LOOP(PCB->Data); { if (!TEST_FLAG(LOCKFLAG, element) @@ -919,7 +919,7 @@ && ((TEST_FLAG(ONSOLDERFLAG, pad) != 0) == SWAP_IDENT || PCB->InvisibleObjectsOn) && TEST_FLAG(SELECTEDFLAG, pad) != Flag) if (pad->Name && REGEXEC(pad->Name)) { - AddObjectToFlagUndoList(PAD_TYPE, element, pad, pad); + AddObjectToFlagUndoList(PCB_TYPE_PAD, element, pad, pad); ASSIGN_FLAG(SELECTEDFLAG, Flag, pad); DrawPad(pad); changed = true; @@ -926,12 +926,12 @@ } } ENDALL_LOOP; - if (PCB->ViaOn && (Type & VIA_TYPE)) + if (PCB->ViaOn && (Type & PCB_TYPE_VIA)) VIA_LOOP(PCB->Data); { if (!TEST_FLAG(LOCKFLAG, via) && via->Name && REGEXEC(via->Name) && TEST_FLAG(SELECTEDFLAG, via) != Flag) { - AddObjectToFlagUndoList(VIA_TYPE, via, via, via); + AddObjectToFlagUndoList(PCB_TYPE_VIA, via, via, via); ASSIGN_FLAG(SELECTEDFLAG, Flag, via); DrawVia(via); changed = true; @@ -938,7 +938,7 @@ } } END_LOOP; - if (Type & NET_TYPE) { + if (Type & PCB_TYPE_NET) { InitConnectionLookup(); changed = ResetConnections(true) || changed; Index: trunk/src/select.h =================================================================== --- trunk/src/select.h (revision 2502) +++ trunk/src/select.h (revision 2503) @@ -32,8 +32,8 @@ #include "global.h" #define SELECT_TYPES \ - (VIA_TYPE | LINE_TYPE | TEXT_TYPE | POLYGON_TYPE | ELEMENT_TYPE | \ - PIN_TYPE | PAD_TYPE | ELEMENTNAME_TYPE | RATLINE_TYPE | ARC_TYPE) + (PCB_TYPE_VIA | PCB_TYPE_LINE | PCB_TYPE_TEXT | PCB_TYPE_POLYGON | PCB_TYPE_ELEMENT | \ + PCB_TYPE_PIN | PCB_TYPE_PAD | PCB_TYPE_ELEMENT_NAME | PCB_TYPE_RATLINE | PCB_TYPE_ARC) bool SelectObject(void); bool SelectBlock(BoxTypePtr, bool); Index: trunk/src/select_act.c =================================================================== --- trunk/src/select_act.c (revision 2502) +++ trunk/src/select_act.c (revision 2503) @@ -126,25 +126,25 @@ int type; /* select objects by their names */ case F_ElementByName: - type = ELEMENT_TYPE; + type = PCB_TYPE_ELEMENT; goto commonByName; case F_ObjectByName: - type = ALL_TYPES; + type = PCB_TYPEMASK_ALL; goto commonByName; case F_PadByName: - type = PAD_TYPE; + type = PCB_TYPE_PAD; goto commonByName; case F_PinByName: - type = PIN_TYPE; + type = PCB_TYPE_PIN; goto commonByName; case F_TextByName: - type = TEXT_TYPE; + type = PCB_TYPE_TEXT; goto commonByName; case F_ViaByName: - type = VIA_TYPE; + type = PCB_TYPE_VIA; goto commonByName; case F_NetByName: - type = NET_TYPE; + type = PCB_TYPE_NET; goto commonByName; commonByName: @@ -287,25 +287,25 @@ int type; /* select objects by their names */ case F_ElementByName: - type = ELEMENT_TYPE; + type = PCB_TYPE_ELEMENT; goto commonByName; case F_ObjectByName: - type = ALL_TYPES; + type = PCB_TYPEMASK_ALL; goto commonByName; case F_PadByName: - type = PAD_TYPE; + type = PCB_TYPE_PAD; goto commonByName; case F_PinByName: - type = PIN_TYPE; + type = PCB_TYPE_PIN; goto commonByName; case F_TextByName: - type = TEXT_TYPE; + type = PCB_TYPE_TEXT; goto commonByName; case F_ViaByName: - type = VIA_TYPE; + type = PCB_TYPE_VIA; goto commonByName; case F_NetByName: - type = NET_TYPE; + type = PCB_TYPE_NET; goto commonByName; commonByName: Index: trunk/src/set.c =================================================================== --- trunk/src/set.c (revision 2502) +++ trunk/src/set.c (revision 2503) @@ -203,7 +203,7 @@ recursing = true; notify_crosshair_change(false); addedLines = 0; - Crosshair.AttachedObject.Type = NO_TYPE; + Crosshair.AttachedObject.Type = PCB_TYPE_NONE; Crosshair.AttachedObject.State = STATE_FIRST; Crosshair.AttachedPolygon.PointN = 0; if (PCB->RatDraw) { Index: trunk/src/strflags.c =================================================================== --- trunk/src/strflags.c (revision 2502) +++ trunk/src/strflags.c (revision 2503) @@ -50,30 +50,30 @@ #define N(x) x, sizeof(x)-1 static FlagBitsType object_flagbits[] = { - {PINFLAG, N("pin"), ALL_TYPES}, - {VIAFLAG, N("via"), ALL_TYPES}, - {FOUNDFLAG, N("found"), ALL_TYPES}, - {HOLEFLAG, N("hole"), PIN_TYPES}, - {RATFLAG, N("rat"), RATLINE_TYPE}, - {PININPOLYFLAG, N("pininpoly"), PIN_TYPES | PAD_TYPE}, - {CLEARPOLYFLAG, N("clearpoly"), POLYGON_TYPE}, - {HIDENAMEFLAG, N("hidename"), ELEMENT_TYPE}, - {DISPLAYNAMEFLAG, N("showname"), ELEMENT_TYPE}, - {CLEARLINEFLAG, N("clearline"), LINE_TYPE | ARC_TYPE | TEXT_TYPE}, - {SELECTEDFLAG, N("selected"), ALL_TYPES}, - {ONSOLDERFLAG, N("onsolder"), ELEMENT_TYPE | PAD_TYPE | TEXT_TYPE}, - {AUTOFLAG, N("auto"), ALL_TYPES}, - {SQUAREFLAG, N("square"), PIN_TYPES | PAD_TYPE}, - {RUBBERENDFLAG, N("rubberend"), LINE_TYPE | ARC_TYPE}, - {WARNFLAG, N("warn"), PIN_TYPES | PAD_TYPE}, - {USETHERMALFLAG, N("usetherm"), PIN_TYPES | LINE_TYPE | ARC_TYPE}, - {OCTAGONFLAG, N("octagon"), PIN_TYPES | PAD_TYPE}, - {DRCFLAG, N("drc"), ALL_TYPES}, - {LOCKFLAG, N("lock"), ALL_TYPES}, - {EDGE2FLAG, N("edge2"), ALL_TYPES}, - {FULLPOLYFLAG, N("fullpoly"), POLYGON_TYPE}, - {NOPASTEFLAG, N("nopaste"), PAD_TYPE}, - {NONETLISTFLAG, N("nonetlist"), ALL_TYPES} + {PINFLAG, N("pin"), PCB_TYPEMASK_ALL}, + {VIAFLAG, N("via"), PCB_TYPEMASK_ALL}, + {FOUNDFLAG, N("found"), PCB_TYPEMASK_ALL}, + {HOLEFLAG, N("hole"), PCB_TYPEMASK_PIN}, + {RATFLAG, N("rat"), PCB_TYPE_RATLINE}, + {PININPOLYFLAG, N("pininpoly"), PCB_TYPEMASK_PIN | PCB_TYPE_PAD}, + {CLEARPOLYFLAG, N("clearpoly"), PCB_TYPE_POLYGON}, + {HIDENAMEFLAG, N("hidename"), PCB_TYPE_ELEMENT}, + {DISPLAYNAMEFLAG, N("showname"), PCB_TYPE_ELEMENT}, + {CLEARLINEFLAG, N("clearline"), PCB_TYPE_LINE | PCB_TYPE_ARC | PCB_TYPE_TEXT}, + {SELECTEDFLAG, N("selected"), PCB_TYPEMASK_ALL}, + {ONSOLDERFLAG, N("onsolder"), PCB_TYPE_ELEMENT | PCB_TYPE_PAD | PCB_TYPE_TEXT}, + {AUTOFLAG, N("auto"), PCB_TYPEMASK_ALL}, + {SQUAREFLAG, N("square"), PCB_TYPEMASK_PIN | PCB_TYPE_PAD}, + {RUBBERENDFLAG, N("rubberend"), PCB_TYPE_LINE | PCB_TYPE_ARC}, + {WARNFLAG, N("warn"), PCB_TYPEMASK_PIN | PCB_TYPE_PAD}, + {USETHERMALFLAG, N("usetherm"), PCB_TYPEMASK_PIN | PCB_TYPE_LINE | PCB_TYPE_ARC}, + {OCTAGONFLAG, N("octagon"), PCB_TYPEMASK_PIN | PCB_TYPE_PAD}, + {DRCFLAG, N("drc"), PCB_TYPEMASK_ALL}, + {LOCKFLAG, N("lock"), PCB_TYPEMASK_ALL}, + {EDGE2FLAG, N("edge2"), PCB_TYPEMASK_ALL}, + {FULLPOLYFLAG, N("fullpoly"), PCB_TYPE_POLYGON}, + {NOPASTEFLAG, N("nopaste"), PCB_TYPE_PAD}, + {NONETLISTFLAG, N("nonetlist"), PCB_TYPEMASK_ALL} }; #undef N @@ -412,7 +412,7 @@ * * Note that this function knows a little about what kinds of flags * will be automatically set by parsing, so it won't (for example) - * include the "via" flag for VIA_TYPEs because it knows those get + * include the "via" flag for PCB_TYPE_VIAs because it knows those get * forcibly set when vias are parsed. */ @@ -428,13 +428,13 @@ #ifndef FLAG_TEST switch (object_type) { - case VIA_TYPE: + case PCB_TYPE_VIA: CLEAR_FLAG(VIAFLAG, &fh); break; - case RATLINE_TYPE: + case PCB_TYPE_RATLINE: CLEAR_FLAG(RATFLAG, &fh); break; - case PIN_TYPE: + case PCB_TYPE_PIN: CLEAR_FLAG(PINFLAG, &fh); break; } Index: trunk/src/undo.c =================================================================== --- trunk/src/undo.c (revision 2502) +++ trunk/src/undo.c (revision 2503) @@ -180,7 +180,7 @@ size_t limit = ((size_t)conf_core.editor.undo_warning_size) * 1024; #ifdef DEBUG_ID - if (SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, ID, Kind) == NO_TYPE) + if (SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, ID, Kind) == PCB_TYPE_NONE) Message("hace: ID (%d) and Type (%x) mismatch in AddObject...\n", ID, Kind); #endif @@ -211,7 +211,7 @@ break; case UNDO_REMOVE: type = SearchObjectByID(RemoveList, &ptr1, &ptr2, &ptr3, ptr->ID, ptr->Kind); - if (type != NO_TYPE) { + if (type != PCB_TYPE_NONE) { DestroyObject(RemoveList, type, ptr1, ptr2, ptr3); } break; @@ -236,7 +236,7 @@ */ static void DrawRecoveredObject(int Type, void *Ptr1, void *Ptr2, void *Ptr3) { - if (Type & (LINE_TYPE | TEXT_TYPE | POLYGON_TYPE | ARC_TYPE)) { + if (Type & (PCB_TYPE_LINE | PCB_TYPE_TEXT | PCB_TYPE_POLYGON | PCB_TYPE_ARC)) { LayerTypePtr layer; layer = LAYER_PTR(GetLayerNumber(RemoveList, (LayerTypePtr) Ptr1)); @@ -257,7 +257,7 @@ /* lookup entry by it's ID */ type = SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind); - if (type != NO_TYPE) { + if (type != PCB_TYPE_NONE) { RotateObject(type, ptr1, ptr2, ptr3, Entry->Data.Rotate.CenterX, Entry->Data.Rotate.CenterY, (4 - Entry->Data.Rotate.Steps) & 0x03); Entry->Data.Rotate.Steps = (4 - Entry->Data.Rotate.Steps) & 0x03; @@ -276,7 +276,7 @@ int type; type = SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind); - if (type != NO_TYPE) { + if (type != PCB_TYPE_NONE) { if (Entry->Data.ClearPoly.Clear) RestoreToPolygon(PCB->Data, type, Entry->Data.ClearPoly.Layer, ptr3); else @@ -298,7 +298,7 @@ /* lookup entry by it's ID */ type = SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind); - if (type != NO_TYPE) { + if (type != PCB_TYPE_NONE) { Entry->Data.ChangeName.Name = (char *) (ChangeObjectName(type, ptr1, ptr2, ptr3, Entry->Data.ChangeName.Name)); return (true); } @@ -316,7 +316,7 @@ /* lookup entry by it's ID */ type = SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind); - if (type != NO_TYPE) { + if (type != PCB_TYPE_NONE) { Entry->Data.ChangeName.Name = (char *) (ChangeObjectPinnum(type, ptr1, ptr2, ptr3, Entry->Data.ChangeName.Name)); return (true); } @@ -334,7 +334,7 @@ /* lookup entry by ID */ type = SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind); - if (type != NO_TYPE) { + if (type != PCB_TYPE_NONE) { swap = ((PinTypePtr) ptr2)->DrillingHole; if (andDraw) EraseObject(type, ptr1, ptr2); @@ -357,7 +357,7 @@ /* lookup entry by ID */ type = SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind); - if (type == ARC_TYPE) { + if (type == PCB_TYPE_ARC) { LayerTypePtr Layer = (LayerTypePtr) ptr1; ArcTypePtr a = (ArcTypePtr) ptr2; r_delete_entry(Layer->arc_tree, (BoxTypePtr) a); @@ -388,7 +388,7 @@ /* lookup entry by ID */ type = SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind); - if (type != NO_TYPE) { + if (type != PCB_TYPE_NONE) { swap = ((PinTypePtr) ptr2)->Clearance; RestoreToPolygon(PCB->Data, type, ptr1, ptr2); if (andDraw) @@ -414,11 +414,11 @@ /* lookup entry by ID */ type = SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind); - if (type & (VIA_TYPE | PIN_TYPE | PAD_TYPE)) { - swap = (type == PAD_TYPE ? ((PadTypePtr) ptr2)->Mask : ((PinTypePtr) ptr2)->Mask); + if (type & (PCB_TYPE_VIA | PCB_TYPE_PIN | PCB_TYPE_PAD)) { + swap = (type == PCB_TYPE_PAD ? ((PadTypePtr) ptr2)->Mask : ((PinTypePtr) ptr2)->Mask); if (andDraw) EraseObject(type, ptr1, ptr2); - if (type == PAD_TYPE) + if (type == PCB_TYPE_PAD) ((PadTypePtr) ptr2)->Mask = Entry->Data.Size; else ((PinTypePtr) ptr2)->Mask = Entry->Data.Size; @@ -442,7 +442,7 @@ /* lookup entry by ID */ type = SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind); - if (type != NO_TYPE) { + if (type != PCB_TYPE_NONE) { /* Wow! can any object be treated as a pin type for size change?? */ /* pins, vias, lines, and arcs can. Text can't but it has it's own mechanism */ swap = ((PinTypePtr) ptr2)->Thickness; @@ -471,7 +471,7 @@ /* lookup entry by ID */ type = SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind); - if (type != NO_TYPE) { + if (type != PCB_TYPE_NONE) { FlagType f1, f2; PinTypePtr pin = (PinTypePtr) ptr2; @@ -511,7 +511,7 @@ /* lookup entry by ID */ type = SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind); - if (type == ELEMENT_TYPE) { + if (type == PCB_TYPE_ELEMENT) { ElementTypePtr element = (ElementTypePtr) ptr3; if (andDraw) EraseElement(element); @@ -535,7 +535,7 @@ /* lookup entry by it's ID */ type = SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind); - if (type != NO_TYPE) { + if (type != PCB_TYPE_NONE) { if (!RemoveList) RemoveList = CreateNewBuffer(); if (andDraw) @@ -559,7 +559,7 @@ /* lookup entry by it's ID */ type = SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind); - if (type != NO_TYPE) { + if (type != PCB_TYPE_NONE) { MoveObject(type, ptr1, ptr2, ptr3, -Entry->Data.Move.DX, -Entry->Data.Move.DY); Entry->Data.Move.DX *= -1; Entry->Data.Move.DY *= -1; @@ -579,7 +579,7 @@ /* lookup entry by it's ID */ type = SearchObjectByID(RemoveList, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind); - if (type != NO_TYPE) { + if (type != PCB_TYPE_NONE) { if (andDraw) DrawRecoveredObject(type, ptr1, ptr2, ptr3); MoveObjectToBuffer(PCB->Data, RemoveList, type, ptr1, ptr2, ptr3); @@ -600,7 +600,7 @@ /* lookup entry by it's ID */ type = SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, Entry->ID, Entry->Kind); - if (type != NO_TYPE) { + if (type != PCB_TYPE_NONE) { swap = GetLayerNumber(PCB->Data, (LayerTypePtr) ptr1); MoveObjectToLayer(type, ptr1, ptr2, ptr3, LAYER_PTR(Entry->Data.MoveToLayer.OriginalLayer), true); Entry->Data.MoveToLayer.OriginalLayer = swap; @@ -621,15 +621,15 @@ int type; /* lookup entry (polygon not point was saved) by it's ID */ - assert(Entry->Kind == POLYGON_TYPE); + assert(Entry->Kind == PCB_TYPE_POLYGON); type = SearchObjectByID(PCB->Data, (void **) &layer, (void **) &polygon, &ptr3, Entry->ID, Entry->Kind); switch (type) { - case POLYGON_TYPE: /* restore the removed point */ + case PCB_TYPE_POLYGON: /* restore the removed point */ { /* recover the point */ if (andDraw && layer->On) ErasePolygon(polygon); - InsertPointIntoObject(POLYGON_TYPE, layer, polygon, + InsertPointIntoObject(PCB_TYPE_POLYGON, layer, polygon, &Entry->Data.RemovedPoint.Index, Entry->Data.RemovedPoint.X, Entry->Data.RemovedPoint.Y, true, Entry->Data.RemovedPoint.last_in_contour); @@ -639,7 +639,7 @@ DrawPolygon(layer, polygon); Entry->Type = UNDO_INSERT_POINT; Entry->ID = Entry->Data.RemovedPoint.ID; - Entry->Kind = POLYGONPOINT_TYPE; + Entry->Kind = PCB_TYPE_POLYGON_POINT; return (true); } @@ -662,11 +662,11 @@ Cardinal hole; bool last_in_contour = false; - assert(Entry->Kind == POLYGONPOINT_TYPE); + assert(Entry->Kind == PCB_TYPE_POLYGON_POINT); /* lookup entry by it's ID */ type = SearchObjectByID(PCB->Data, (void **) &layer, (void **) &polygon, (void **) &pnt, Entry->ID, Entry->Kind); switch (type) { - case POLYGONPOINT_TYPE: /* removes an inserted polygon point */ + case PCB_TYPE_POLYGON_POINT: /* removes an inserted polygon point */ { if (andDraw && layer->On) ErasePolygon(polygon); @@ -687,10 +687,10 @@ Entry->Data.RemovedPoint.Y = pnt->Y; Entry->Data.RemovedPoint.ID = pnt->ID; Entry->ID = polygon->ID; - Entry->Kind = POLYGON_TYPE; + Entry->Kind = PCB_TYPE_POLYGON; Entry->Type = UNDO_REMOVE_POINT; Entry->Data.RemovedPoint.Index = point_idx; - DestroyObject(PCB->Data, POLYGONPOINT_TYPE, layer, polygon, pnt); + DestroyObject(PCB->Data, PCB_TYPE_POLYGON_POINT, layer, polygon, pnt); if (andDraw && layer->On) DrawPolygon(layer, polygon); return (true); @@ -711,11 +711,11 @@ /* lookup entry by it's ID */ type = SearchObjectByID(RemoveList, &ptr1, &ptr2, &ptr3, Entry->Data.CopyID, Entry->Kind); - if (type == NO_TYPE) + if (type == PCB_TYPE_NONE) return false; type = SearchObjectByID(PCB->Data, &ptr1b, &ptr2b, &ptr3b, Entry->ID, Entry->Kind); - if (type == NO_TYPE) + if (type == PCB_TYPE_NONE) return FALSE; obj = (AnyObjectType *) ptr2; @@ -731,7 +731,7 @@ DrawRecoveredObject(Entry->Kind, ptr1, ptr2, ptr3); obj = (AnyObjectType *) MoveObjectToBuffer(PCB->Data, RemoveList, type, ptr1, ptr2, ptr3); - if (Entry->Kind == POLYGON_TYPE) + if (Entry->Kind == PCB_TYPE_POLYGON) InitClip(PCB->Data, (LayerTypePtr) ptr1b, (PolygonType *) obj); return (true); } @@ -742,7 +742,7 @@ */ static bool UndoRemoveContour(UndoListTypePtr Entry) { - assert(Entry->Kind == POLYGON_TYPE); + assert(Entry->Kind == PCB_TYPE_POLYGON); return UndoSwapCopiedObject(Entry); } @@ -752,7 +752,7 @@ */ static bool UndoInsertContour(UndoListTypePtr Entry) { - assert(Entry->Kind == POLYGON_TYPE); + assert(Entry->Kind == PCB_TYPE_POLYGON); return UndoSwapCopiedObject(Entry); } @@ -1209,12 +1209,12 @@ if (!Locked) { switch (Type) { - case POLYGONPOINT_TYPE: + case PCB_TYPE_POLYGON_POINT: { /* save the ID of the parent object; else it will be * impossible to recover the point */ - undo = GetUndoSlot(UNDO_REMOVE_POINT, OBJECT_ID(polygon), POLYGON_TYPE); + undo = GetUndoSlot(UNDO_REMOVE_POINT, OBJECT_ID(polygon), PCB_TYPE_POLYGON); undo->Data.RemovedPoint.X = polygon->Points[index].X; undo->Data.RemovedPoint.Y = polygon->Points[index].Y; undo->Data.RemovedPoint.ID = polygon->Points[index].ID; @@ -1365,23 +1365,23 @@ if (!Locked) { undo = GetUndoSlot(UNDO_CHANGESIZE, OBJECT_ID(ptr2), Type); switch (Type) { - case PIN_TYPE: - case VIA_TYPE: + case PCB_TYPE_PIN: + case PCB_TYPE_VIA: undo->Data.Size = ((PinTypePtr) ptr2)->Thickness; break; - case LINE_TYPE: - case ELEMENTLINE_TYPE: + case PCB_TYPE_LINE: + case PCB_TYPE_ELEMENT_LINE: undo->Data.Size = ((LineTypePtr) ptr2)->Thickness; break; - case TEXT_TYPE: - case ELEMENTNAME_TYPE: + case PCB_TYPE_TEXT: + case PCB_TYPE_ELEMENT_NAME: undo->Data.Size = ((TextTypePtr) ptr2)->Scale; break; - case PAD_TYPE: + case PCB_TYPE_PAD: undo->Data.Size = ((PadTypePtr) ptr2)->Thickness; break; - case ARC_TYPE: - case ELEMENTARC_TYPE: + case PCB_TYPE_ARC: + case PCB_TYPE_ELEMENT_ARC: undo->Data.Size = ((ArcTypePtr) ptr2)->Thickness; break; } @@ -1398,17 +1398,17 @@ if (!Locked) { undo = GetUndoSlot(UNDO_CHANGECLEARSIZE, OBJECT_ID(ptr2), Type); switch (Type) { - case PIN_TYPE: - case VIA_TYPE: + case PCB_TYPE_PIN: + case PCB_TYPE_VIA: undo->Data.Size = ((PinTypePtr) ptr2)->Clearance; break; - case LINE_TYPE: + case PCB_TYPE_LINE: undo->Data.Size = ((LineTypePtr) ptr2)->Clearance; break; - case PAD_TYPE: + case PCB_TYPE_PAD: undo->Data.Size = ((PadTypePtr) ptr2)->Clearance; break; - case ARC_TYPE: + case PCB_TYPE_ARC: undo->Data.Size = ((ArcTypePtr) ptr2)->Clearance; break; } @@ -1425,11 +1425,11 @@ if (!Locked) { undo = GetUndoSlot(UNDO_CHANGEMASKSIZE, OBJECT_ID(ptr2), Type); switch (Type) { - case PIN_TYPE: - case VIA_TYPE: + case PCB_TYPE_PIN: + case PCB_TYPE_VIA: undo->Data.Size = ((PinTypePtr) ptr2)->Mask; break; - case PAD_TYPE: + case PCB_TYPE_PAD: undo->Data.Size = ((PadTypePtr) ptr2)->Mask; break; } @@ -1445,7 +1445,7 @@ if (!Locked) { undo = GetUndoSlot(UNDO_CHANGE2NDSIZE, OBJECT_ID(ptr2), Type); - if (Type == PIN_TYPE || Type == VIA_TYPE) + if (Type == PCB_TYPE_PIN || Type == PCB_TYPE_VIA) undo->Data.Size = ((PinTypePtr) ptr2)->DrillingHole; } } Index: trunk/src/undo_act.c =================================================================== --- trunk/src/undo_act.c (revision 2502) +++ trunk/src/undo_act.c (revision 2503) @@ -156,7 +156,7 @@ void *ptr1, *ptr3, *ptrtmp; LineTypePtr ptr2; /* this search is guaranteed to succeed */ - SearchObjectByLocation(LINE_TYPE | RATLINE_TYPE, &ptr1, + SearchObjectByLocation(PCB_TYPE_LINE | PCB_TYPE_RATLINE, &ptr1, &ptrtmp, &ptr3, Crosshair.AttachedLine.Point1.X, Crosshair.AttachedLine.Point1.Y, 0); ptr2 = (LineTypePtr) ptrtmp; @@ -179,7 +179,7 @@ /* check if an intermediate point was removed */ if (type & UNDO_REMOVE) { /* this search should find the restored line */ - SearchObjectByLocation(LINE_TYPE | RATLINE_TYPE, &ptr1, + SearchObjectByLocation(PCB_TYPE_LINE | PCB_TYPE_RATLINE, &ptr1, &ptrtmp, &ptr3, Crosshair.AttachedLine.Point2.X, Crosshair.AttachedLine.Point2.Y, 0); ptr2 = (LineTypePtr) ptrtmp; if (conf_core.editor.auto_drc) { @@ -198,7 +198,7 @@ } else { /* this search is guaranteed to succeed too */ - SearchObjectByLocation(LINE_TYPE | RATLINE_TYPE, &ptr1, + SearchObjectByLocation(PCB_TYPE_LINE | PCB_TYPE_RATLINE, &ptr1, &ptrtmp, &ptr3, Crosshair.AttachedLine.Point1.X, Crosshair.AttachedLine.Point1.Y, 0); ptr2 = (LineTypePtr) ptrtmp; lastLayer = (LayerTypePtr) ptr1; @@ -217,7 +217,7 @@ void *ptr1, *ptr2, *ptr3; BoxTypePtr bx; /* guaranteed to succeed */ - SearchObjectByLocation(ARC_TYPE, &ptr1, &ptr2, &ptr3, + SearchObjectByLocation(PCB_TYPE_ARC, &ptr1, &ptr2, &ptr3, Crosshair.AttachedBox.Point1.X, Crosshair.AttachedBox.Point1.Y, 0); bx = GetArcEnds((ArcTypePtr) ptr2); Crosshair.AttachedBox.Point1.X = Crosshair.AttachedBox.Point2.X = bx->X1; Index: trunk/src_plugins/autoplace/autoplace.c =================================================================== --- trunk/src_plugins/autoplace/autoplace.c (revision 2502) +++ trunk/src_plugins/autoplace/autoplace.c (revision 2503) @@ -148,13 +148,13 @@ for (j = 0; j < Nets->Net[i].ConnectionN; j++) { ConnectionTypePtr c = &(Nets->Net[i].Connection[j]); switch (c->type) { - case PAD_TYPE: + case PCB_TYPE_PAD: c->group = TEST_FLAG(ONSOLDERFLAG, (ElementTypePtr) c->ptr1) ? SLayer : CLayer; c->X = ((PadTypePtr) c->ptr2)->Point1.X; c->Y = ((PadTypePtr) c->ptr2)->Point1.Y; break; - case PIN_TYPE: + case PCB_TYPE_PIN: c->group = SLayer; /* any layer will do */ c->X = ((PinTypePtr) c->ptr2)->X; c->Y = ((PinTypePtr) c->ptr2)->Y; @@ -317,7 +317,7 @@ minx = maxx = n->Connection[0].X; miny = maxy = n->Connection[0].Y; thegroup = n->Connection[0].group; - allpads = (n->Connection[0].type == PAD_TYPE); + allpads = (n->Connection[0].type == PCB_TYPE_PAD); allsameside = true; for (j = 1; j < n->ConnectionN; j++) { ConnectionTypePtr c = &(n->Connection[j]); @@ -325,7 +325,7 @@ MAKEMAX(maxx, c->X); MAKEMIN(miny, c->Y); MAKEMAX(maxy, c->Y); - if (c->type != PAD_TYPE) + if (c->type != PCB_TYPE_PAD) allpads = false; if (c->group != thegroup) allsameside = false; Index: trunk/src_plugins/autoroute/autoroute.c =================================================================== --- trunk/src_plugins/autoroute/autoroute.c (revision 2502) +++ trunk/src_plugins/autoroute/autoroute.c (revision 2503) @@ -950,7 +950,7 @@ { routebox_t *rb = NULL; SET_FLAG(DRCFLAG, (PinTypePtr) connection->ptr2); - if (connection->type == LINE_TYPE) { + if (connection->type == PCB_TYPE_LINE) { LineType *line = (LineType *) connection->ptr2; /* lines are listed at each end, so skip one */ @@ -990,16 +990,16 @@ } else switch (connection->type) { - case PAD_TYPE: + case PCB_TYPE_PAD: rb = AddPad(layergroupboxes, (ElementType *) connection->ptr1, (PadType *) connection->ptr2, rd->styles[j]); break; - case PIN_TYPE: + case PCB_TYPE_PIN: rb = AddPin(layergroupboxes, (PinType *) connection->ptr2, false, rd->styles[j]); break; - case VIA_TYPE: + case PCB_TYPE_VIA: rb = AddPin(layergroupboxes, (PinType *) connection->ptr2, true, rd->styles[j]); break; - case POLYGON_TYPE: + case PCB_TYPE_POLYGON: rb = AddPolygon(layergroupboxes, GetLayerNumber(PCB->Data, (LayerType *) connection->ptr1), @@ -1335,16 +1335,16 @@ if (b.Y1 == b.Y2 || b.X1 == b.X2) thickness = 5; line = CreateNewLineOnLayer(LAYER_PTR(component_silk_layer), b.X1, b.Y1, b.X2, b.Y1, thickness, 0, MakeFlags(0)); - AddObjectToCreateUndoList(LINE_TYPE, LAYER_PTR(component_silk_layer), line, line); + AddObjectToCreateUndoList(PCB_TYPE_LINE, LAYER_PTR(component_silk_layer), line, line); if (b.Y1 != b.Y2) { line = CreateNewLineOnLayer(LAYER_PTR(component_silk_layer), b.X1, b.Y2, b.X2, b.Y2, thickness, 0, MakeFlags(0)); - AddObjectToCreateUndoList(LINE_TYPE, LAYER_PTR(component_silk_layer), line, line); + AddObjectToCreateUndoList(PCB_TYPE_LINE, LAYER_PTR(component_silk_layer), line, line); } line = CreateNewLineOnLayer(LAYER_PTR(component_silk_layer), b.X1, b.Y1, b.X1, b.Y2, thickness, 0, MakeFlags(0)); - AddObjectToCreateUndoList(LINE_TYPE, LAYER_PTR(component_silk_layer), line, line); + AddObjectToCreateUndoList(PCB_TYPE_LINE, LAYER_PTR(component_silk_layer), line, line); if (b.X1 != b.X2) { line = CreateNewLineOnLayer(LAYER_PTR(component_silk_layer), b.X2, b.Y1, b.X2, b.Y2, thickness, 0, MakeFlags(0)); - AddObjectToCreateUndoList(LINE_TYPE, LAYER_PTR(component_silk_layer), line, line); + AddObjectToCreateUndoList(PCB_TYPE_LINE, LAYER_PTR(component_silk_layer), line, line); } #endif } @@ -4076,12 +4076,12 @@ if (rb->type == LINE && rb->livedraw_obj.line) { LayerType *layer = LAYER_PTR(PCB->LayerGroups.Entries[rb->group][0]); EraseLine(rb->livedraw_obj.line); - DestroyObject(PCB->Data, LINE_TYPE, layer, rb->livedraw_obj.line, NULL); + DestroyObject(PCB->Data, PCB_TYPE_LINE, layer, rb->livedraw_obj.line, NULL); rb->livedraw_obj.line = NULL; } if (rb->type == VIA && rb->livedraw_obj.via) { EraseVia(rb->livedraw_obj.via); - DestroyObject(PCB->Data, VIA_TYPE, rb->livedraw_obj.via, NULL, NULL); + DestroyObject(PCB->Data, PCB_TYPE_VIA, rb->livedraw_obj.via, NULL, NULL); rb->livedraw_obj.via = NULL; } } @@ -4408,16 +4408,16 @@ r_search(PCB->Data->pin_tree, box, NULL, fpin_rect, &info, NULL); else { *pin = info.pin; - return PIN_TYPE; + return PCB_TYPE_PIN; } if (setjmp(info.env) == 0) r_search(PCB->Data->via_tree, box, NULL, fpin_rect, &info, NULL); else { *pin = info.pin; - return VIA_TYPE; + return PCB_TYPE_VIA; } *pin = NULL; - return NO_TYPE; + return PCB_TYPE_NONE; } @@ -4470,7 +4470,7 @@ p->style->Thick, p->style->Clearance * 2, MakeFlags(AUTOFLAG | (conf_core.editor.clear_line ? CLEARLINEFLAG : 0))); if (p->parent.line) { - AddObjectToCreateUndoList(LINE_TYPE, layer, p->parent.line, p->parent.line); + AddObjectToCreateUndoList(PCB_TYPE_LINE, layer, p->parent.line, p->parent.line); changed = true; } } @@ -4489,7 +4489,7 @@ pp->style->Diameter, 2 * pp->style->Clearance, 0, pp->style->Hole, NULL, MakeFlags(AUTOFLAG)); assert(pp->parent.via); if (pp->parent.via) { - AddObjectToCreateUndoList(VIA_TYPE, pp->parent.via, pp->parent.via, pp->parent.via); + AddObjectToCreateUndoList(PCB_TYPE_VIA, pp->parent.via, pp->parent.via, pp->parent.via); changed = true; } } @@ -4515,11 +4515,11 @@ int type = FindPin(&p->box, &pin); if (pin) { AddObjectToClearPolyUndoList(type, pin->Element ? pin->Element : pin, pin, pin, false); - RestoreToPolygon(PCB->Data, VIA_TYPE, LAYER_PTR(p->layer), pin); + RestoreToPolygon(PCB->Data, PCB_TYPE_VIA, LAYER_PTR(p->layer), pin); AddObjectToFlagUndoList(type, pin->Element ? pin->Element : pin, pin, pin); ASSIGN_THERM(p->layer, PCB->ThermStyle, pin); AddObjectToClearPolyUndoList(type, pin->Element ? pin->Element : pin, pin, pin, true); - ClearFromPolygon(PCB->Data, VIA_TYPE, LAYER_PTR(p->layer), pin); + ClearFromPolygon(PCB->Data, PCB_TYPE_VIA, LAYER_PTR(p->layer), pin); changed = true; } } @@ -4641,7 +4641,7 @@ b = FindRouteBoxOnLayerGroup(rd, line->Point2.X, line->Point2.Y, line->group2); if (!a || !b) { #ifdef DEBUG_STALE_RATS - AddObjectToFlagUndoList(RATLINE_TYPE, line, line, line); + AddObjectToFlagUndoList(PCB_TYPE_RATLINE, line, line, line); ASSIGN_FLAG(SELECTEDFLAG, true, line); DrawRat(line, 0); #endif /* DEBUG_STALE_RATS */ Index: trunk/src_plugins/djopt/djopt.c =================================================================== --- trunk/src_plugins/djopt/djopt.c (revision 2502) +++ trunk/src_plugins/djopt/djopt.c (revision 2503) @@ -451,7 +451,7 @@ from = (char *) linelist_first(&lyr->Line); nl = CreateNewLineOnLayer(PCB->Data->Layer + layer, x1, y1, x2, y2, thick, clear, flags); - AddObjectToCreateUndoList(LINE_TYPE, lyr, nl, nl); + AddObjectToCreateUndoList(PCB_TYPE_LINE, lyr, nl, nl); to = (char *) linelist_first(&lyr->Line); if (from != to) { @@ -497,7 +497,7 @@ LineType *nl; dprintf ("New line \033[35m%#mD to %#mD from l%d t%#mS c%#mS f%s\033[0m\n", - s->x, s->y, e->x, e->y, layer, example->Thickness, example->Clearance, flags_to_string(example->Flags, LINE_TYPE)); + s->x, s->y, e->x, e->y, layer, example->Thickness, example->Clearance, flags_to_string(example->Flags, PCB_TYPE_LINE)); nl = create_pcb_line(layer, s->x, s->y, e->x, e->y, example->Thickness, example->Clearance, example->Flags); if (!nl) @@ -678,13 +678,13 @@ ls = LAYER_PTR(l->layer); ld = LAYER_PTR(layer); - MoveObjectToLayer(LINE_TYPE, ls, l->line, 0, ld, 0); + MoveObjectToLayer(PCB_TYPE_LINE, ls, l->line, 0, ld, 0); l->layer = layer; } static void remove_via_at(corner_s * c) { - RemoveObject(VIA_TYPE, c->via, 0, 0); + RemoveObject(PCB_TYPE_VIA, c->via, 0, 0); c->via = 0; } @@ -749,7 +749,7 @@ c->y = y; via = c->via; if (via) { - MoveObject(VIA_TYPE, via, via, via, x - via->X, y - via->Y); + MoveObject(PCB_TYPE_VIA, via, via, via, x - via->X, y - via->Y); dprintf("via move %#mD to %#mD\n", via->X, via->Y, x, y); } for (i = 0; i < c->n_lines; i++) { @@ -756,10 +756,10 @@ LineTypePtr tl = c->lines[i]->line; if (tl) { if (c->lines[i]->s == c) { - MoveObject(LINEPOINT_TYPE, LAYER_PTR(c->lines[i]->layer), tl, &tl->Point1, x - (tl->Point1.X), y - (tl->Point1.Y)); + MoveObject(PCB_TYPE_LINE_POINT, LAYER_PTR(c->lines[i]->layer), tl, &tl->Point1, x - (tl->Point1.X), y - (tl->Point1.Y)); } else { - MoveObject(LINEPOINT_TYPE, LAYER_PTR(c->lines[i]->layer), tl, &tl->Point2, x - (tl->Point2.X), y - (tl->Point2.Y)); + MoveObject(PCB_TYPE_LINE_POINT, LAYER_PTR(c->lines[i]->layer), tl, &tl->Point2, x - (tl->Point2.X), y - (tl->Point2.Y)); } dprintf("Line %p moved to %#mD %#mD\n", (void *) tl, tl->Point1.X, tl->Point1.Y, tl->Point2.X, tl->Point2.Y); } @@ -851,7 +851,7 @@ add_line_to_corner(l, c); add_line_to_corner(ls, c); - MoveObject(LINEPOINT_TYPE, LAYER_PTR(l->layer), l->line, &l->line->Point2, + MoveObject(PCB_TYPE_LINE_POINT, LAYER_PTR(l->layer), l->line, &l->line->Point2, c->x - (l->line->Point2.X), c->y - (l->line->Point2.Y)); return 1; @@ -2173,7 +2173,7 @@ c[ci]->lines[li]->s->x, c[ci]->lines[li]->s->y, c[ci]->lines[li]->e->x, c[ci]->lines[li]->e->y, c[ci]->lines[li]->line->Thickness, - c[ci]->lines[li]->line->Clearance, flags_to_string(c[ci]->lines[li]->line->Flags, LINE_TYPE)); + c[ci]->lines[li]->line->Clearance, flags_to_string(c[ci]->lines[li]->line->Flags, PCB_TYPE_LINE)); /* Pads are disqualified, as we want to mimic a trace line. */ if (c[ci]->lines[li]->line == (LineTypePtr) c[ci]->pad) { dprintf(" bad, pad\n"); Index: trunk/src_plugins/export_nelma/nelma.c =================================================================== --- trunk/src_plugins/export_nelma/nelma.c (revision 2502) +++ trunk/src_plugins/export_nelma/nelma.c (revision 2503) @@ -242,11 +242,11 @@ if (!SeekPad(pin, &conn, false)) return 1; switch (conn.type) { - case PIN_TYPE: + case PCB_TYPE_PIN: *x = ((PinType *) (conn.ptr2))->X; *y = ((PinType *) (conn.ptr2))->Y; return 0; - case PAD_TYPE: + case PCB_TYPE_PAD: *x = ((PadType *) (conn.ptr2))->Point1.X; *y = ((PadType *) (conn.ptr2))->Point1.Y; return 0; Index: trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/layout/create.c =================================================================== --- trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/layout/create.c (revision 2502) +++ trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/layout/create.c (revision 2503) @@ -69,7 +69,7 @@ line = CreateNewLineOnLayer (CURRENT, x1, y1, x2, y2, thickness, clearance, get_flags(flags)); if (line != NULL) { - AddObjectToCreateUndoList (LINE_TYPE, CURRENT, line, line); + AddObjectToCreateUndoList (PCB_TYPE_LINE, CURRENT, line, line); return line; } return NULL; @@ -87,7 +87,7 @@ pin = CreateNewVia (PCB->Data, x, y, thickness, clearance, mask, hole, name, get_flags(flags)); if (pin != NULL) { - AddObjectToCreateUndoList (VIA_TYPE, pin, pin, pin); + AddObjectToCreateUndoList (PCB_TYPE_VIA, pin, pin, pin); return pin; } return NULL; @@ -103,7 +103,7 @@ void *arc; arc = CreateNewArcOnLayer (CURRENT, x, y, width, height, sa, dir, thickness, clearance, get_flags(flags)); if (arc != NULL) { - AddObjectToCreateUndoList (ARC_TYPE, CURRENT, arc, arc); + AddObjectToCreateUndoList (PCB_TYPE_ARC, CURRENT, arc, arc); return 0; } return NULL; Index: trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/layout/object.c =================================================================== --- trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/layout/object.c (revision 2502) +++ trunk/src_plugins/gpmi/pcb-gpmi/gpmi_plugin/gpmi_pkg/layout/object.c (revision 2503) @@ -90,7 +90,7 @@ case OM_LINE: switch(coord) { case OC_OBJ: - MoveObject (LINEPOINT_TYPE, CURRENT, obj->obj.l, &(obj->obj.l->Point2), dx, dy); + MoveObject (PCB_TYPE_LINE_POINT, CURRENT, obj->obj.l, &(obj->obj.l->Point2), dx, dy); /* intended falltrough */ case OC_P1X: case OC_P1Y: what = &(obj->obj.l->Point1); break; @@ -99,21 +99,21 @@ default: /* we do not handle anything else for now */ ; } - MoveObject (LINEPOINT_TYPE, CURRENT, obj->obj.l, what, dx, dy); + MoveObject (PCB_TYPE_LINE_POINT, CURRENT, obj->obj.l, what, dx, dy); return 0; case OM_TEXT: - MoveObject (TEXT_TYPE, CURRENT, obj->obj.t, obj->obj.t, dx, dy); + MoveObject (PCB_TYPE_TEXT, CURRENT, obj->obj.t, obj->obj.t, dx, dy); return 0; case OM_VIA: - MoveObject (VIA_TYPE, obj->obj.v, obj->obj.v, obj->obj.v, dx, dy); + MoveObject (PCB_TYPE_VIA, obj->obj.v, obj->obj.v, obj->obj.v, dx, dy); return 0; case OM_PIN: - MoveObject (PIN_TYPE, obj->obj.pin, obj->obj.pin, obj->obj.pin, dx, dy); + MoveObject (PCB_TYPE_PIN, obj->obj.pin, obj->obj.pin, obj->obj.pin, dx, dy); return 0; case OM_ARC: switch(coord) { case OC_OBJ: - MoveObject (ARC_TYPE, CURRENT, obj->obj.a, obj->obj.a, dx, dy); + MoveObject (PCB_TYPE_ARC, CURRENT, obj->obj.a, obj->obj.a, dx, dy); return 0; default: /* we do not handle anything else for now */ ; @@ -122,7 +122,7 @@ break; case OM_POLYGON: if (obj->layer != -1) { - MoveObject (POLYGON_TYPE, PCB->Data->Layer + obj->layer, obj->obj.p, obj->obj.p, dx, dy); + MoveObject (PCB_TYPE_POLYGON, PCB->Data->Layer + obj->layer, obj->obj.p, obj->obj.p, dx, dy); return 0; } } Index: trunk/src_plugins/hid_gtk/gui-drc-window.c =================================================================== --- trunk/src_plugins/hid_gtk/gui-drc-window.c (revision 2502) +++ trunk/src_plugins/hid_gtk/gui-drc-window.c (revision 2503) @@ -84,7 +84,7 @@ VIA_LOOP(PCB->Data); { if (TEST_FLAG(flag, via)) { - AddObjectToFlagUndoList(VIA_TYPE, via, via, via); + AddObjectToFlagUndoList(PCB_TYPE_VIA, via, via, via); CLEAR_FLAG(flag, via); DrawVia(via); change = true; @@ -96,7 +96,7 @@ PIN_LOOP(element); { if (TEST_FLAG(flag, pin)) { - AddObjectToFlagUndoList(PIN_TYPE, element, pin, pin); + AddObjectToFlagUndoList(PCB_TYPE_PIN, element, pin, pin); CLEAR_FLAG(flag, pin); DrawPin(pin); change = true; @@ -106,7 +106,7 @@ PAD_LOOP(element); { if (TEST_FLAG(flag, pad)) { - AddObjectToFlagUndoList(PAD_TYPE, element, pad, pad); + AddObjectToFlagUndoList(PCB_TYPE_PAD, element, pad, pad); CLEAR_FLAG(flag, pad); DrawPad(pad); change = true; @@ -118,7 +118,7 @@ RAT_LOOP(PCB->Data); { if (TEST_FLAG(flag, line)) { - AddObjectToFlagUndoList(RATLINE_TYPE, line, line, line); + AddObjectToFlagUndoList(PCB_TYPE_RATLINE, line, line, line); CLEAR_FLAG(flag, line); DrawRat(line); change = true; @@ -128,7 +128,7 @@ COPPERLINE_LOOP(PCB->Data); { if (TEST_FLAG(flag, line)) { - AddObjectToFlagUndoList(LINE_TYPE, layer, line, line); + AddObjectToFlagUndoList(PCB_TYPE_LINE, layer, line, line); CLEAR_FLAG(flag, line); DrawLine(layer, line); change = true; @@ -138,7 +138,7 @@ COPPERARC_LOOP(PCB->Data); { if (TEST_FLAG(flag, arc)) { - AddObjectToFlagUndoList(ARC_TYPE, layer, arc, arc); + AddObjectToFlagUndoList(PCB_TYPE_ARC, layer, arc, arc); CLEAR_FLAG(flag, arc); DrawArc(layer, arc); change = true; @@ -148,7 +148,7 @@ COPPERPOLYGON_LOOP(PCB->Data); { if (TEST_FLAG(flag, polygon)) { - AddObjectToFlagUndoList(POLYGON_TYPE, layer, polygon, polygon); + AddObjectToFlagUndoList(PCB_TYPE_POLYGON, layer, polygon, polygon); CLEAR_FLAG(flag, polygon); DrawPolygon(layer, polygon); change = true; @@ -195,7 +195,7 @@ void *ptr1, *ptr2, *ptr3; found_type = SearchObjectByID(PCB->Data, &ptr1, &ptr2, &ptr3, object_id, object_type); - if (found_type == NO_TYPE) { + if (found_type == PCB_TYPE_NONE) { Message(_("Object ID %i identified during DRC was not found. Stale DRC window?\n"), object_id); continue; } @@ -202,9 +202,9 @@ AddObjectToFlagUndoList(object_type, ptr1, ptr2, ptr3); SET_FLAG(FOUNDFLAG, (AnyObjectType *) ptr2); switch (violation->object_type_list[i]) { - case LINE_TYPE: - case ARC_TYPE: - case POLYGON_TYPE: + case PCB_TYPE_LINE: + case PCB_TYPE_ARC: + case PCB_TYPE_POLYGON: ChangeGroupVisibility(GetLayerNumber(PCB->Data, (LayerTypePtr) ptr1), true, true); } DrawObject(object_type, ptr1, ptr2); Index: trunk/src_plugins/hid_gtk/gui-netlist-window.c =================================================================== --- trunk/src_plugins/hid_gtk/gui-netlist-window.c (revision 2502) +++ trunk/src_plugins/hid_gtk/gui-netlist-window.c (revision 2503) @@ -268,7 +268,7 @@ /* And lead the user to the location */ if (SeekPad(node, &conn, false)) switch (conn.type) { - case PIN_TYPE: + case PCB_TYPE_PIN: { PinTypePtr pin = (PinTypePtr) conn.ptr2; x = pin->X; @@ -277,7 +277,7 @@ ghid_lead_user_to_location(x, y); break; } - case PAD_TYPE: + case PCB_TYPE_PAD: { PadTypePtr pad = (PadTypePtr) conn.ptr2; x = pad->Point1.X + (pad->Point2.X - pad->Point1.X) / 2; @@ -539,7 +539,7 @@ VISIBLELINE_LOOP(PCB->Data); { if (TEST_FLAG(FOUNDFLAG, line) && !TEST_FLAG(LOCKFLAG, line)) - RemoveObject(LINE_TYPE, layer, line, line); + RemoveObject(PCB_TYPE_LINE, layer, line, line); } ENDALL_LOOP; @@ -546,7 +546,7 @@ VISIBLEARC_LOOP(PCB->Data); { if (TEST_FLAG(FOUNDFLAG, arc) && !TEST_FLAG(LOCKFLAG, arc)) - RemoveObject(ARC_TYPE, layer, arc, arc); + RemoveObject(PCB_TYPE_ARC, layer, arc, arc); } ENDALL_LOOP; @@ -554,7 +554,7 @@ VIA_LOOP(PCB->Data); { if (TEST_FLAG(FOUNDFLAG, via) && !TEST_FLAG(LOCKFLAG, via)) - RemoveObject(VIA_TYPE, via, via, via); + RemoveObject(PCB_TYPE_VIA, via, via, via); } END_LOOP; Index: trunk/src_plugins/hid_gtk/gui-output-events.c =================================================================== --- trunk/src_plugins/hid_gtk/gui-output-events.c (revision 2502) +++ trunk/src_plugins/hid_gtk/gui-output-events.c (revision 2503) @@ -298,8 +298,8 @@ /* check if there are any pins or pads at that position */ - type = SearchObjectByLocation(PIN_TYPE | PAD_TYPE, &ptr1, &ptr2, &ptr3, X, Y, Range); - if (type == NO_TYPE) + type = SearchObjectByLocation(PCB_TYPE_PIN | PCB_TYPE_PAD, &ptr1, &ptr2, &ptr3, X, Y, Range); + if (type == PCB_TYPE_NONE) return NULL; /* don't mess with silk objects! */ @@ -306,7 +306,7 @@ if (type & SILK_TYPE && GetLayerNumber(PCB->Data, (LayerTypePtr) ptr1) >= max_copper_layer) return NULL; - if (type == PIN_TYPE || type == PAD_TYPE) + if (type == PCB_TYPE_PIN || type == PCB_TYPE_PAD) elename = (char *) UNKNOWN(NAMEONPCB_NAME((ElementTypePtr) ptr1)); pinname = ConnectionName(type, ptr1, ptr2); Index: trunk/src_plugins/hid_lesstif/netlist.c =================================================================== --- trunk/src_plugins/hid_lesstif/netlist.c (revision 2502) +++ trunk/src_plugins/hid_lesstif/netlist.c (revision 2503) @@ -176,7 +176,7 @@ VISIBLELINE_LOOP(PCB->Data); { if (TEST_FLAG(FOUNDFLAG, line) && !TEST_FLAG(LOCKFLAG, line)) - RemoveObject(LINE_TYPE, layer, line, line); + RemoveObject(PCB_TYPE_LINE, layer, line, line); } ENDALL_LOOP; @@ -183,7 +183,7 @@ VISIBLEARC_LOOP(PCB->Data); { if (TEST_FLAG(FOUNDFLAG, arc) && !TEST_FLAG(LOCKFLAG, arc)) - RemoveObject(ARC_TYPE, layer, arc, arc); + RemoveObject(PCB_TYPE_ARC, layer, arc, arc); } ENDALL_LOOP; @@ -191,7 +191,7 @@ VIA_LOOP(PCB->Data); { if (TEST_FLAG(FOUNDFLAG, via) && !TEST_FLAG(LOCKFLAG, via)) - RemoveObject(VIA_TYPE, via, via, via); + RemoveObject(PCB_TYPE_VIA, via, via, via); } END_LOOP; } Index: trunk/src_plugins/io_pcb/file.c =================================================================== --- trunk/src_plugins/io_pcb/file.c (revision 2502) +++ trunk/src_plugins/io_pcb/file.c (revision 2503) @@ -320,7 +320,7 @@ pcb_fprintf(FP, "Via[%mr %mr %mr %mr %mr %mr ", via->X, via->Y, via->Thickness, via->Clearance, via->Mask, via->DrillingHole); PrintQuotedString(FP, (char *) EMPTY(via->Name)); - fprintf(FP, " %s]\n", F2S(via, VIA_TYPE)); + fprintf(FP, " %s]\n", F2S(via, PCB_TYPE_VIA)); } } @@ -336,7 +336,7 @@ ratlist_foreach(&PCB->Data->Rat, &it, line) { pcb_fprintf(FP, "Rat[%mr %mr %d %mr %mr %d ", line->Point1.X, line->Point1.Y, line->group1, line->Point2.X, line->Point2.Y, line->group2); - fprintf(FP, " %s]\n", F2S(line, RATLINE_TYPE)); + fprintf(FP, " %s]\n", F2S(line, PCB_TYPE_RATLINE)); } } @@ -402,7 +402,7 @@ /* the coordinates and text-flags are the same for * both names of an element */ - fprintf(FP, "\nElement[%s ", F2S(element, ELEMENT_TYPE)); + fprintf(FP, "\nElement[%s ", F2S(element, PCB_TYPE_ELEMENT)); PrintQuotedString(FP, (char *) EMPTY(DESCRIPTION_NAME(element))); fputc(' ', FP); PrintQuotedString(FP, (char *) EMPTY(NAMEONPCB_NAME(element))); @@ -413,7 +413,7 @@ DESCRIPTION_TEXT(element).X - element->MarkX, DESCRIPTION_TEXT(element).Y - element->MarkY, DESCRIPTION_TEXT(element).Direction, - DESCRIPTION_TEXT(element).Scale, F2S(&(DESCRIPTION_TEXT(element)), ELEMENTNAME_TYPE)); + DESCRIPTION_TEXT(element).Scale, F2S(&(DESCRIPTION_TEXT(element)), PCB_TYPE_ELEMENT_NAME)); WriteAttributeList(FP, &element->Attributes, "\t"); pinlist_foreach(&element->Pin, &it, pin) { pcb_fprintf(FP, "\tPin[%mr %mr %mr %mr %mr %mr ", @@ -422,7 +422,7 @@ PrintQuotedString(FP, (char *) EMPTY(pin->Name)); fprintf(FP, " "); PrintQuotedString(FP, (char *) EMPTY(pin->Number)); - fprintf(FP, " %s]\n", F2S(pin, PIN_TYPE)); + fprintf(FP, " %s]\n", F2S(pin, PCB_TYPE_PIN)); } pinlist_foreach(&element->Pad, &it, pad) { pcb_fprintf(FP, "\tPad[%mr %mr %mr %mr %mr %mr %mr ", @@ -432,7 +432,7 @@ PrintQuotedString(FP, (char *) EMPTY(pad->Name)); fprintf(FP, " "); PrintQuotedString(FP, (char *) EMPTY(pad->Number)); - fprintf(FP, " %s]\n", F2S(pad, PAD_TYPE)); + fprintf(FP, " %s]\n", F2S(pad, PCB_TYPE_PAD)); } linelist_foreach(&element->Line, &it, line) { pcb_fprintf(FP, "\tElementLine [%mr %mr %mr %mr %mr]\n", @@ -471,22 +471,22 @@ linelist_foreach(&layer->Line, &it, line) { pcb_fprintf(FP, "\tLine[%mr %mr %mr %mr %mr %mr %s]\n", line->Point1.X, line->Point1.Y, - line->Point2.X, line->Point2.Y, line->Thickness, line->Clearance, F2S(line, LINE_TYPE)); + line->Point2.X, line->Point2.Y, line->Thickness, line->Clearance, F2S(line, PCB_TYPE_LINE)); } arclist_foreach(&layer->Arc, &it, arc) { pcb_fprintf(FP, "\tArc[%mr %mr %mr %mr %mr %mr %ma %ma %s]\n", arc->X, arc->Y, arc->Width, - arc->Height, arc->Thickness, arc->Clearance, arc->StartAngle, arc->Delta, F2S(arc, ARC_TYPE)); + arc->Height, arc->Thickness, arc->Clearance, arc->StartAngle, arc->Delta, F2S(arc, PCB_TYPE_ARC)); } textlist_foreach(&layer->Text, &it, text) { pcb_fprintf(FP, "\tText[%mr %mr %d %d ", text->X, text->Y, text->Direction, text->Scale); PrintQuotedString(FP, (char *) EMPTY(text->TextString)); - fprintf(FP, " %s]\n", F2S(text, TEXT_TYPE)); + fprintf(FP, " %s]\n", F2S(text, PCB_TYPE_TEXT)); } textlist_foreach(&layer->Polygon, &it, polygon) { int p, i = 0; Cardinal hole = 0; - fprintf(FP, "\tPolygon(%s)\n\t(", F2S(polygon, POLYGON_TYPE)); + fprintf(FP, "\tPolygon(%s)\n\t(", F2S(polygon, PCB_TYPE_POLYGON)); for (p = 0; p < polygon->PointN; p++) { PointTypePtr point = &polygon->Points[p]; Index: trunk/src_plugins/io_pcb/flags.c =================================================================== --- trunk/src_plugins/io_pcb/flags.c (revision 2502) +++ trunk/src_plugins/io_pcb/flags.c (revision 2503) @@ -59,7 +59,7 @@ char *pcbflags_to_string(FlagType flags) { - return common_flags_to_string(flags, ALL_TYPES, pcb_flagbits, ENTRIES(pcb_flagbits)); + return common_flags_to_string(flags, PCB_TYPEMASK_ALL, pcb_flagbits, ENTRIES(pcb_flagbits)); } FlagType string_to_pcbflags(const char *flagstring, int (*error) (const char *msg)) Index: trunk/src_plugins/io_pcb/parse_y.c =================================================================== --- trunk/src_plugins/io_pcb/parse_y.c (revision 2502) +++ trunk/src_plugins/io_pcb/parse_y.c (revision 2503) @@ -2387,7 +2387,7 @@ " line: %i\n" " description: 'ignored polygon (< 3 points in a contour)'\n", yyfilename, yylineno); - DestroyObject(yyData, POLYGON_TYPE, Layer, Polygon, Polygon); + DestroyObject(yyData, PCB_TYPE_POLYGON, Layer, Polygon, Polygon); } else { Index: trunk/src_plugins/io_pcb/parse_y.y =================================================================== --- trunk/src_plugins/io_pcb/parse_y.y (revision 2502) +++ trunk/src_plugins/io_pcb/parse_y.y (revision 2503) @@ -1173,7 +1173,7 @@ " line: %i\n" " description: 'ignored polygon (< 3 points in a contour)'\n", yyfilename, yylineno); - DestroyObject(yyData, POLYGON_TYPE, Layer, Polygon, Polygon); + DestroyObject(yyData, PCB_TYPE_POLYGON, Layer, Polygon, Polygon); } else { Index: trunk/src_plugins/mincut/rats_mincut.c =================================================================== --- trunk/src_plugins/mincut/rats_mincut.c (revision 2502) +++ trunk/src_plugins/mincut/rats_mincut.c (revision 2503) @@ -173,19 +173,19 @@ s = malloc(256); parent = NULL; switch (n->to_type) { - case PIN_TYPE: + case PCB_TYPE_PIN: typ = "pin"; parent = ((PinType *) (n->to))->Element; break; - case VIA_TYPE: + case PCB_TYPE_VIA: typ = "via"; parent = ((PinType *) (n->to))->Element; break; - case PAD_TYPE: + case PCB_TYPE_PAD: typ = "pad"; parent = ((PadType *) (n->to))->Element; break; - case LINE_TYPE: + case PCB_TYPE_LINE: typ = "line"; break; default: @@ -239,9 +239,9 @@ void *spare; spare = NULL; - if (n->to_type == PIN_TYPE) + if (n->to_type == PCB_TYPE_PIN) spare = ((PinType *) n->to)->Spare; - if (n->to_type == PAD_TYPE) + if (n->to_type == PCB_TYPE_PAD) spare = ((PadType *) n->to)->Spare; if (spare != NULL) { void *net = &(((LibraryMenuTypePtr) spare)->Name[2]); @@ -271,7 +271,7 @@ /* connection to a pin/pad is slightly stronger than the strongest obj-obj conn; obj-obj conns are weaker at junctions where many objects connect */ - if ((n->from_type == PIN_TYPE) || (n->from_type == PAD_TYPE) || (n->to_type == PIN_TYPE) || (n->to_type == PAD_TYPE)) + if ((n->from_type == PCB_TYPE_PIN) || (n->from_type == PCB_TYPE_PAD) || (n->to_type == PCB_TYPE_PIN) || (n->to_type == PCB_TYPE_PAD)) weight = maxedges * 2 + 2; else weight = maxedges * 2 - n->edges - from->edges + 1; Index: trunk/src_plugins/puller/puller.c =================================================================== --- trunk/src_plugins/puller/puller.c (revision 2502) +++ trunk/src_plugins/puller/puller.c (revision 2503) @@ -472,7 +472,7 @@ x = the_arc->X - the_arc->Width * cos(d2r(arc_angle)) + 0.5; y = the_arc->Y + the_arc->Height * sin(d2r(arc_angle)) + 0.5; - MoveObject(LINEPOINT_TYPE, CURRENT, the_line, &(the_line->Point2), x - the_line->Point2.X, y - the_line->Point2.Y); + MoveObject(PCB_TYPE_LINE_POINT, CURRENT, the_line, &(the_line->Point2), x - the_line->Point2.X, y - the_line->Point2.Y); gui->invalidate_all(); IncrementUndoSerialNumber(); @@ -586,8 +586,8 @@ #define ARC2EXTRA(a) ((Extra *)g_hash_table_lookup (arcs, a)) #define EXTRA2LINE(e) (e->parent.line) #define EXTRA2ARC(e) (e->parent.arc) -#define EXTRA_IS_LINE(e) (e->type == LINE_TYPE) -#define EXTRA_IS_ARC(e) (e->type == ARC_TYPE) +#define EXTRA_IS_LINE(e) (e->type == PCB_TYPE_LINE) +#define EXTRA_IS_ARC(e) (e->type == PCB_TYPE_ARC) static void unlink_end(Extra * x, Extra ** e) { @@ -931,7 +931,7 @@ Extra *extra = g_slice_new0(Extra); g_hash_table_insert(lines, line, extra); extra->parent.line = line; - extra->type = LINE_TYPE; + extra->type = PCB_TYPE_LINE; return extra; } @@ -940,7 +940,7 @@ Extra *extra = g_slice_new0(Extra); g_hash_table_insert(arcs, arc, extra); extra->parent.arc = arc; - extra->type = ARC_TYPE; + extra->type = PCB_TYPE_ARC; return extra; } @@ -1191,8 +1191,8 @@ x = line->Point1.X; y = line->Point1.Y; #if 1 - MoveObject(LINEPOINT_TYPE, CURRENT, line, &(line->Point1), line->Point2.X - line->Point1.X, line->Point2.Y - line->Point1.Y); - MoveObject(LINEPOINT_TYPE, CURRENT, line, &(line->Point2), x - line->Point2.X, y - line->Point2.Y); + MoveObject(PCB_TYPE_LINE_POINT, CURRENT, line, &(line->Point1), line->Point2.X - line->Point1.X, line->Point2.Y - line->Point1.Y); + MoveObject(PCB_TYPE_LINE_POINT, CURRENT, line, &(line->Point2), x - line->Point2.X, y - line->Point2.Y); #else /* In theory, we should be using the above so that undo works. */ line->Point1.X = line->Point2.X; @@ -1627,7 +1627,7 @@ #endif LineTypePtr line = CreateNewLineOnLayer(CURRENT, x1, y1, x2, y2, sample->Thickness, sample->Clearance, sample->Flags); - AddObjectToCreateUndoList(LINE_TYPE, CURRENT, line, line); + AddObjectToCreateUndoList(PCB_TYPE_LINE, CURRENT, line, line); #if TRACE1 e = @@ -1655,7 +1655,7 @@ if (arc == 0) { arc = CreateNewArcOnLayer(CURRENT, x, y, r, r, sa, da * 2, sample->Thickness, sample->Clearance, sample->Flags); } - AddObjectToCreateUndoList(ARC_TYPE, CURRENT, arc, arc); + AddObjectToCreateUndoList(PCB_TYPE_ARC, CURRENT, arc, arc); if (!arc) longjmp(abort_buf, 1); @@ -1736,8 +1736,8 @@ fprintf(stderr, "double neg move?\n"); abort(); } - MoveObject(LINEPOINT_TYPE, CURRENT, l, &(l->Point1), -1 - l->Point1.X, -1 - l->Point1.Y); - MoveObject(LINEPOINT_TYPE, CURRENT, l, &(l->Point2), -1 - l->Point2.X, -1 - l->Point2.Y); + MoveObject(PCB_TYPE_LINE_POINT, CURRENT, l, &(l->Point1), -1 - l->Point1.X, -1 - l->Point1.Y); + MoveObject(PCB_TYPE_LINE_POINT, CURRENT, l, &(l->Point2), -1 - l->Point2.X, -1 - l->Point2.Y); #endif } @@ -2019,11 +2019,11 @@ ChangeArcAngles(CURRENT, start_arc, start_arc->StartAngle, new_delta); fix_arc_extra(start_arc, sarc_extra); - MoveObject(LINEPOINT_TYPE, CURRENT, start_line, &(start_line->Point1), + MoveObject(PCB_TYPE_LINE_POINT, CURRENT, start_line, &(start_line->Point1), sarc_extra->end.x - start_line->Point1.X, sarc_extra->end.y - start_line->Point1.Y); if (del_arc) { - MoveObject(LINEPOINT_TYPE, CURRENT, start_line, &(start_line->Point1), + MoveObject(PCB_TYPE_LINE_POINT, CURRENT, start_line, &(start_line->Point1), sarc_extra->start.x - start_line->Point1.X, sarc_extra->start.y - start_line->Point1.Y); mark_arc_for_deletion(start_arc); } @@ -2085,17 +2085,17 @@ ChangeArcAngles(CURRENT, end_arc, end_arc->StartAngle, new_delta); fix_arc_extra(end_arc, earc_extra); - MoveObject(LINEPOINT_TYPE, CURRENT, start_line, &(start_line->Point2), + MoveObject(PCB_TYPE_LINE_POINT, CURRENT, start_line, &(start_line->Point2), earc_extra->end.x - start_line->Point2.X, earc_extra->end.y - start_line->Point2.Y); if (del_arc) { - MoveObject(LINEPOINT_TYPE, CURRENT, start_line, &(start_line->Point2), + MoveObject(PCB_TYPE_LINE_POINT, CURRENT, start_line, &(start_line->Point2), earc_extra->start.x - start_line->Point2.X, earc_extra->start.y - start_line->Point2.Y); mark_arc_for_deletion(end_arc); } } else { - MoveObject(LINEPOINT_TYPE, CURRENT, start_line, &(start_line->Point2), + MoveObject(PCB_TYPE_LINE_POINT, CURRENT, start_line, &(start_line->Point2), end_line->Point2.X - start_line->Point2.X, end_line->Point2.Y - start_line->Point2.Y); } mark_line_for_deletion(end_line); @@ -2129,7 +2129,7 @@ #if TRACE1 pcb_printf("new point %#mS\n", ex, ey); #endif - MoveObject(LINEPOINT_TYPE, CURRENT, end_line, &(end_line->Point1), ex - end_line->Point1.X, ey - end_line->Point1.Y); + MoveObject(PCB_TYPE_LINE_POINT, CURRENT, end_line, &(end_line->Point1), ex - end_line->Point1.X, ey - end_line->Point1.Y); /* Step 4: Split start_line at the obstacle and insert a zero-delta arc at it. */ @@ -2142,7 +2142,7 @@ if (end_arc) earc_extra = ARC2EXTRA(end_arc); - MoveObject(LINEPOINT_TYPE, CURRENT, start_line, &(start_line->Point2), + MoveObject(PCB_TYPE_LINE_POINT, CURRENT, start_line, &(start_line->Point2), new_aextra->start.x - start_line->Point2.X, new_aextra->start.y - start_line->Point2.Y); new_line = create_line(start_line, new_aextra->end.x, new_aextra->end.y, ex, ey); Index: trunk/src_plugins/renumber/renumber.c =================================================================== --- trunk/src_plugins/renumber/renumber.c (revision 2502) +++ trunk/src_plugins/renumber/renumber.c (revision 2503) @@ -278,9 +278,9 @@ is[c_cnt] = strdup(tmps); c_cnt++; - AddObjectToChangeNameUndoList(ELEMENT_TYPE, NULL, NULL, element_list[i], NAMEONPCB_NAME(element_list[i])); + AddObjectToChangeNameUndoList(PCB_TYPE_ELEMENT, NULL, NULL, element_list[i], NAMEONPCB_NAME(element_list[i])); - ChangeObjectName(ELEMENT_TYPE, element_list[i], NULL, NULL, tmps); + ChangeObjectName(PCB_TYPE_ELEMENT, element_list[i], NULL, NULL, tmps); changed = true; /* we don't free tmps in this case because it is used */ Index: trunk/src_plugins/report/report.c =================================================================== --- trunk/src_plugins/report/report.c (revision 2502) +++ trunk/src_plugins/report/report.c (revision 2503) @@ -134,11 +134,11 @@ char *report = NULL; type = SearchScreen(x, y, REPORT_TYPES, &ptr1, &ptr2, &ptr3); - if (type == NO_TYPE) - type = SearchScreen(x, y, REPORT_TYPES | LOCKED_TYPE, &ptr1, &ptr2, &ptr3); + if (type == PCB_TYPE_NONE) + type = SearchScreen(x, y, REPORT_TYPES | PCB_TYPE_LOCKED, &ptr1, &ptr2, &ptr3); switch (type) { - case VIA_TYPE: + case PCB_TYPE_VIA: { PinTypePtr via; #ifndef NDEBUG @@ -153,7 +153,7 @@ "(X,Y) = %$mD.\n" "It is a pure hole of diameter %$mS.\n" "Name = \"%s\"." - "%s", USER_UNITMASK, via->ID, flags_to_string(via->Flags, VIA_TYPE), + "%s", USER_UNITMASK, via->ID, flags_to_string(via->Flags, PCB_TYPE_VIA), via->X, via->Y, via->DrillingHole, EMPTY(via->Name), TEST_FLAG(LOCKFLAG, via) ? "It is LOCKED.\n" : ""); else report = pcb_strdup_printf("%m+VIA ID# %ld; Flags:%s\n" @@ -163,7 +163,7 @@ "Annulus = %$mS.\n" "Solder mask hole = %$mS (gap = %$mS).\n" "Name = \"%s\"." - "%s", USER_UNITMASK, via->ID, flags_to_string(via->Flags, VIA_TYPE), + "%s", USER_UNITMASK, via->ID, flags_to_string(via->Flags, PCB_TYPE_VIA), via->X, via->Y, via->Thickness, via->DrillingHole, @@ -173,7 +173,7 @@ (via->Mask - via->Thickness) / 2, EMPTY(via->Name), TEST_FLAG(LOCKFLAG, via) ? "It is LOCKED.\n" : ""); break; } - case PIN_TYPE: + case PCB_TYPE_PIN: { PinTypePtr Pin; ElementTypePtr element; @@ -197,7 +197,7 @@ "(X,Y) = %$mD.\n" "It is a mounting hole. Drill width = %$mS.\n" "It is owned by element %$mS.\n" - "%s", USER_UNITMASK, Pin->ID, flags_to_string(Pin->Flags, PIN_TYPE), + "%s", USER_UNITMASK, Pin->ID, flags_to_string(Pin->Flags, PCB_TYPE_PIN), Pin->X, Pin->Y, Pin->DrillingHole, EMPTY(element->Name[1].TextString), TEST_FLAG(LOCKFLAG, Pin) ? "It is LOCKED.\n" : ""); else @@ -210,7 +210,7 @@ "Name = \"%s\".\n" "It is owned by element %s\n as pin number %s.\n" "%s", USER_UNITMASK, - Pin->ID, flags_to_string(Pin->Flags, PIN_TYPE), + Pin->ID, flags_to_string(Pin->Flags, PCB_TYPE_PIN), Pin->X, Pin->Y, Pin->Thickness, Pin->DrillingHole, Pin->Clearance / 2, @@ -221,7 +221,7 @@ EMPTY(element->Name[1].TextString), EMPTY(Pin->Number), TEST_FLAG(LOCKFLAG, Pin) ? "It is LOCKED.\n" : ""); break; } - case LINE_TYPE: + case PCB_TYPE_LINE: { LineTypePtr line; #ifndef NDEBUG @@ -239,7 +239,7 @@ "It is on layer %d\n" "and has name \"%s\".\n" "%s", USER_UNITMASK, - line->ID, flags_to_string(line->Flags, LINE_TYPE), + line->ID, flags_to_string(line->Flags, PCB_TYPE_LINE), line->Point1.X, line->Point1.Y, line->Point1.ID, line->Point2.X, line->Point2.Y, line->Point2.ID, line->Thickness, line->Clearance / 2, @@ -247,7 +247,7 @@ UNKNOWN(line->Number), TEST_FLAG(LOCKFLAG, line) ? "It is LOCKED.\n" : ""); break; } - case RATLINE_TYPE: + case PCB_TYPE_RATLINE: { RatTypePtr line; #ifndef NDEBUG @@ -262,12 +262,12 @@ "connects to layer group %d.\n" "SecondPoint(X,Y) = %$mD; ID = %ld; " "connects to layer group %d.\n", - USER_UNITMASK, line->ID, flags_to_string(line->Flags, LINE_TYPE), + USER_UNITMASK, line->ID, flags_to_string(line->Flags, PCB_TYPE_LINE), line->Point1.X, line->Point1.Y, line->Point1.ID, line->group1, line->Point2.X, line->Point2.Y, line->Point2.ID, line->group2); break; } - case ARC_TYPE: + case PCB_TYPE_ARC: { ArcTypePtr Arc; BoxTypePtr box; @@ -289,7 +289,7 @@ "Bounding Box is %$mD, %$mD.\n" "That makes the end points at %$mD and %$mD.\n" "It is on layer %d.\n" - "%s", USER_UNITMASK, Arc->ID, flags_to_string(Arc->Flags, ARC_TYPE), + "%s", USER_UNITMASK, Arc->ID, flags_to_string(Arc->Flags, PCB_TYPE_ARC), Arc->X, Arc->Y, Arc->Width, Arc->Thickness, Arc->Clearance / 2, Arc->StartAngle, Arc->Delta, @@ -300,7 +300,7 @@ GetLayerNumber(PCB->Data, (LayerTypePtr) ptr1), TEST_FLAG(LOCKFLAG, Arc) ? "It is LOCKED.\n" : ""); break; } - case POLYGON_TYPE: + case PCB_TYPE_POLYGON: { PolygonTypePtr Polygon; #ifndef NDEBUG @@ -318,7 +318,7 @@ " without using more memory.\n" "It has %d holes and resides on layer %d.\n" "%s", USER_UNITMASK, Polygon->ID, - flags_to_string(Polygon->Flags, POLYGON_TYPE), + flags_to_string(Polygon->Flags, PCB_TYPE_POLYGON), Polygon->BoundingBox.X1, Polygon->BoundingBox.Y1, Polygon->BoundingBox.X2, Polygon->BoundingBox.Y2, Polygon->PointN, Polygon->PointMax - Polygon->PointN, @@ -326,7 +326,7 @@ GetLayerNumber(PCB->Data, (LayerTypePtr) ptr1), TEST_FLAG(LOCKFLAG, Polygon) ? "It is LOCKED.\n" : ""); break; } - case PAD_TYPE: + case PCB_TYPE_PAD: { Coord len; PadTypePtr Pad; @@ -360,7 +360,7 @@ " as pin number %s and is on the %s\n" "side of the board.\n" "%s", USER_UNITMASK, Pad->ID, - flags_to_string(Pad->Flags, PAD_TYPE), + flags_to_string(Pad->Flags, PCB_TYPE_PAD), Pad->Point1.X, Pad->Point1.Y, Pad->Point1.ID, Pad->Point2.X, Pad->Point2.Y, Pad->Point2.ID, Pad->Thickness, len + Pad->Thickness, @@ -374,7 +374,7 @@ Pad) ? "solder (bottom)" : "component", TEST_FLAG(LOCKFLAG, Pad) ? "It is LOCKED.\n" : ""); break; } - case ELEMENT_TYPE: + case PCB_TYPE_ELEMENT: { ElementTypePtr element; #ifndef NDEBUG @@ -393,7 +393,7 @@ "Mark located at point (X,Y) = %$mD.\n" "It is on the %s side of the board.\n" "%s", USER_UNITMASK, - element->ID, flags_to_string(element->Flags, ELEMENT_TYPE), + element->ID, flags_to_string(element->Flags, PCB_TYPE_ELEMENT), element->BoundingBox.X1, element->BoundingBox.Y1, element->BoundingBox.X2, element->BoundingBox.Y2, EMPTY(element->Name[0].TextString), @@ -407,7 +407,7 @@ TEST_FLAG(LOCKFLAG, element) ? "It is LOCKED.\n" : ""); break; } - case TEXT_TYPE: + case PCB_TYPE_TEXT: #ifndef NDEBUG if (gui->shift_is_pressed()) { LayerTypePtr layer = (LayerTypePtr) ptr1; @@ -415,7 +415,7 @@ return 0; } #endif - case ELEMENTNAME_TYPE: + case PCB_TYPE_ELEMENT_NAME: { char laynum[32]; TextTypePtr text; @@ -427,7 +427,7 @@ #endif text = (TextTypePtr) ptr2; - if (type == TEXT_TYPE) + if (type == PCB_TYPE_TEXT) sprintf(laynum, "It is on layer %d.", GetLayerNumber(PCB->Data, (LayerTypePtr) ptr1)); report = pcb_strdup_printf("%m+TEXT ID# %ld; Flags:%s\n" "Located at (X,Y) = %$mD.\n" @@ -436,16 +436,16 @@ "Direction is %d.\n" "The bounding box is %$mD %$mD.\n" "%s\n" - "%s", USER_UNITMASK, text->ID, flags_to_string(text->Flags, TEXT_TYPE), + "%s", USER_UNITMASK, text->ID, flags_to_string(text->Flags, PCB_TYPE_TEXT), text->X, text->Y, SCALE_TEXT(FONT_CAPHEIGHT, text->Scale), text->TextString, text->Direction, text->BoundingBox.X1, text->BoundingBox.Y1, text->BoundingBox.X2, text->BoundingBox.Y2, - (type == TEXT_TYPE) ? laynum : "It is an element name.", TEST_FLAG(LOCKFLAG, text) ? "It is LOCKED.\n" : ""); + (type == PCB_TYPE_TEXT) ? laynum : "It is an element name.", TEST_FLAG(LOCKFLAG, text) ? "It is LOCKED.\n" : ""); break; } - case LINEPOINT_TYPE: - case POLYGONPOINT_TYPE: + case PCB_TYPE_LINE_POINT: + case PCB_TYPE_POLYGON_POINT: { PointTypePtr point = (PointTypePtr) ptr2; report = pcb_strdup_printf("%m+POINT ID# %ld.\n" @@ -452,10 +452,10 @@ "Located at (X,Y) = %$mD.\n" "It belongs to a %s on layer %d.\n", USER_UNITMASK, point->ID, point->X, point->Y, - (type == LINEPOINT_TYPE) ? "line" : "polygon", GetLayerNumber(PCB->Data, (LayerTypePtr) ptr1)); + (type == PCB_TYPE_LINE_POINT) ? "line" : "polygon", GetLayerNumber(PCB->Data, (LayerTypePtr) ptr1)); break; } - case NO_TYPE: + case PCB_TYPE_NONE: report = NULL; break; @@ -799,12 +799,12 @@ if (SeekPad(net->Entry, &conn, false)) { switch (conn.type) { - case PIN_TYPE: + case PCB_TYPE_PIN: x = ((PinType *) (conn.ptr2))->X; y = ((PinType *) (conn.ptr2))->Y; net_found = 1; break; - case PAD_TYPE: + case PCB_TYPE_PAD: x = ((PadType *) (conn.ptr2))->Point1.X; y = ((PadType *) (conn.ptr2))->Point1.Y; net_found = 1; Index: trunk/src_plugins/report/report.h =================================================================== --- trunk/src_plugins/report/report.h (revision 2502) +++ trunk/src_plugins/report/report.h (revision 2503) @@ -30,8 +30,8 @@ #include "global.h" #define REPORT_TYPES \ - (VIA_TYPE | LINE_TYPE | TEXT_TYPE | POLYGON_TYPE | ELEMENT_TYPE | \ - RATLINE_TYPE | PIN_TYPE | PAD_TYPE | ELEMENTNAME_TYPE | ARC_TYPE \ - | POLYGONPOINT_TYPE | LINEPOINT_TYPE) + (PCB_TYPE_VIA | PCB_TYPE_LINE | PCB_TYPE_TEXT | PCB_TYPE_POLYGON | PCB_TYPE_ELEMENT | \ + PCB_TYPE_RATLINE | PCB_TYPE_PIN | PCB_TYPE_PAD | PCB_TYPE_ELEMENT_NAME | PCB_TYPE_ARC \ + | PCB_TYPE_POLYGON_POINT | PCB_TYPE_LINE_POINT) #endif Index: trunk/src_plugins/toporouter/toporouter.c =================================================================== --- trunk/src_plugins/toporouter/toporouter.c (revision 2502) +++ trunk/src_plugins/toporouter/toporouter.c (revision 2503) @@ -2719,7 +2719,7 @@ CONNECTION_LOOP(net); { - if (connection->type == LINE_TYPE) { + if (connection->type == PCB_TYPE_LINE) { LineType *line = (LineType *) connection->ptr2; toporouter_bbox_t *box = toporouter_bbox_locate(r, LINE, line, connection->X, connection->Y, connection->group); cluster_join_bbox(cluster, box); @@ -2728,7 +2728,7 @@ pcb_printf("\tLINE %#mD\n", connection->X, connection->Y); #endif } - else if (connection->type == PAD_TYPE) { + else if (connection->type == PCB_TYPE_PAD) { PadType *pad = (PadType *) connection->ptr2; toporouter_bbox_t *box = toporouter_bbox_locate(r, PAD, pad, connection->X, connection->Y, connection->group); cluster_join_bbox(cluster, box); @@ -2737,7 +2737,7 @@ pcb_printf("\tPAD %#mD\n", connection->X, connection->Y); #endif } - else if (connection->type == PIN_TYPE) { + else if (connection->type == PCB_TYPE_PIN) { guint m; for (m = 0; m < groupcount(); m++) { PinType *pin = (PinType *) connection->ptr2; @@ -2749,7 +2749,7 @@ pcb_printf("\tPIN %#mD\n", connection->X, connection->Y); #endif } - else if (connection->type == VIA_TYPE) { + else if (connection->type == PCB_TYPE_VIA) { guint m; for (m = 0; m < groupcount(); m++) { PinType *pin = (PinType *) connection->ptr2; @@ -2761,7 +2761,7 @@ pcb_printf("\tVIA %#mD\n", connection->X, connection->Y); #endif } - else if (connection->type == POLYGON_TYPE) { + else if (connection->type == PCB_TYPE_POLYGON) { PolygonType *polygon = (PolygonType *) connection->ptr2; toporouter_bbox_t *box = toporouter_bbox_locate(r, POLYGON, polygon, connection->X, connection->Y, connection->group); @@ -5539,7 +5539,7 @@ thickness, clearance, MakeFlags(AUTOFLAG | (TEST_FLAG(CLEARNEWFLAG, PCB) ? CLEARLINEFLAG : 0))); if (line) { - AddObjectToCreateUndoList(LINE_TYPE, LAYER_PTR(layer), line, line); + AddObjectToCreateUndoList(PCB_TYPE_LINE, LAYER_PTR(layer), line, line); d = coord_distance((double) x0, (double) y0, (double) x1, (double) y1) / 100.; } return d; @@ -5588,7 +5588,7 @@ MakeFlags(AUTOFLAG | (TEST_FLAG(CLEARNEWFLAG, PCB) ? CLEARLINEFLAG : 0))); if (arc) { - AddObjectToCreateUndoList(ARC_TYPE, LAYER_PTR(layer), arc, arc); + AddObjectToCreateUndoList(PCB_TYPE_ARC, LAYER_PTR(layer), arc, arc); d = a->r * theta / 100.; } @@ -8205,14 +8205,14 @@ if ((via = CreateNewVia(PCB->Data, viax, viay, Settings.ViaThickness, 2 * Settings.Clearance, 0, Settings.ViaDrillingHole, NULL, NoFlags())) != NULL) { - AddObjectToCreateUndoList(VIA_TYPE, via, via, via); + AddObjectToCreateUndoList(PCB_TYPE_VIA, via, via, via); /* if (gui->shift_is_pressed ()) - ChangeObjectThermal (VIA_TYPE, via, via, via, PCB->ThermStyle);*/ + ChangeObjectThermal (PCB_TYPE_VIA, via, via, via, PCB->ThermStyle);*/ DrawVia(via); if ((line = CreateDrawnLineOnLayer(CURRENT, pad->Point1.X + 1., pad->Point1.Y + 1., viax + 1., viay + 1., Settings.LineThickness, 2 * Settings.Clearance, NoFlags()))) { - AddObjectToCreateUndoList(LINE_TYPE, CURRENT, line, line); + AddObjectToCreateUndoList(PCB_TYPE_LINE, CURRENT, line, line); DrawLine(CURRENT, line); } Index: trunk/src_plugins/vendordrill/vendor.c =================================================================== --- trunk/src_plugins/vendordrill/vendor.c (revision 2502) +++ trunk/src_plugins/vendordrill/vendor.c (revision 2503) @@ -328,7 +328,7 @@ if (via->DrillingHole != vendorDrillMap(via->DrillingHole)) { /* only change unlocked vias */ if (!TEST_FLAG(LOCKFLAG, via)) { - if (ChangeObject2ndSize(VIA_TYPE, via, NULL, NULL, vendorDrillMap(via->DrillingHole), true, false)) + if (ChangeObject2ndSize(PCB_TYPE_VIA, via, NULL, NULL, vendorDrillMap(via->DrillingHole), true, false)) changed++; else { Message(_ @@ -358,7 +358,7 @@ tot++; if (pin->DrillingHole != vendorDrillMap(pin->DrillingHole)) { if (!TEST_FLAG(LOCKFLAG, pin)) { - if (ChangeObject2ndSize(PIN_TYPE, element, pin, NULL, vendorDrillMap(pin->DrillingHole), true, false)) + if (ChangeObject2ndSize(PCB_TYPE_PIN, element, pin, NULL, vendorDrillMap(pin->DrillingHole), true, false)) changed++; else { Message(_