static void
draw_element_package (ElementType *element)
{
/* set color and draw lines, arcs, text and pins */
if (doing_pinout || doing_assy)
gui->graphics->set_color (Output.fgGC, PCB->ElementColor);
else if (TEST_FLAG (SELECTEDFLAG, element))
gui->graphics->set_color (Output.fgGC, PCB->ElementSelectedColor);
else if (FRONT (element))
gui->graphics->set_color (Output.fgGC, PCB->ElementColor);
else
gui->graphics->set_color (Output.fgGC, PCB->InvisibleObjectsColor);
/* draw lines, arcs, text and pins */
ELEMENTLINE_LOOP (element);
{
gui->graphics->draw_pcb_line (Output.fgGC, line);
}
END_LOOP;
ARC_LOOP (element);
{
gui->graphics->draw_pcb_arc (Output.fgGC, arc);
}
END_LOOP;
}
void
FreeRotateElementLowLevel (DataType *Data, ElementType *Element,
Coord X, Coord Y,
double cosa, double sina, Angle angle)
{
/* solder side objects need a different orientation */
/* the text subroutine decides by itself if the direction
* is to be corrected
*/
#if 0
ELEMENTTEXT_LOOP (Element);
{
if (Data && Data->name_tree[n])
r_delete_entry (Data->name_tree[n], (BoxType *)text);
RotateTextLowLevel (text, X, Y, Number);
}
END_LOOP;
#endif
ELEMENTLINE_LOOP (Element);
{
free_rotate (&line->Point1.X, &line->Point1.Y, X, Y, cosa, sina);
free_rotate (&line->Point2.X, &line->Point2.Y, X, Y, cosa, sina);
SetLineBoundingBox (line);
}
END_LOOP;
PIN_LOOP (Element);
{
/* 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);
free_rotate (&pin->X, &pin->Y, X, Y, cosa, sina);
SetPinBoundingBox (pin);
}
END_LOOP;
PAD_LOOP (Element);
{
/* pre-delete the pads before their coordinates change */
if (Data)
r_delete_entry (Data->pad_tree, (BoxType *)pad);
RestoreToPolygon (Data, PAD_TYPE, 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);
}
END_LOOP;
ARC_LOOP (Element);
{
free_rotate (&arc->X, &arc->Y, X, Y, cosa, sina);
arc->StartAngle = NormalizeAngle (arc->StartAngle + angle);
}
END_LOOP;
free_rotate (&Element->MarkX, &Element->MarkY, X, Y, cosa, sina);
SetElementBoundingBox (Data, Element, &PCB->Font);
ClearFromPolygon (Data, ELEMENT_TYPE, Element, Element);
}
/* ---------------------------------------------------------------------------
* mirrors the coordinates of an element
* an additional offset is passed
*/
void
MirrorElementCoordinates (DataTypePtr Data, ElementTypePtr Element,
Coord yoff)
{
r_delete_element (Data, Element);
ELEMENTLINE_LOOP (Element);
{
line->Point1.X = SWAP_X (line->Point1.X);
line->Point1.Y = SWAP_Y (line->Point1.Y) + yoff;
line->Point2.X = SWAP_X (line->Point2.X);
line->Point2.Y = SWAP_Y (line->Point2.Y) + yoff;
}
END_LOOP;
PIN_LOOP (Element);
{
RestoreToPolygon (Data, PIN_TYPE, Element, pin);
pin->X = SWAP_X (pin->X);
pin->Y = SWAP_Y (pin->Y) + yoff;
}
END_LOOP;
PAD_LOOP (Element);
{
RestoreToPolygon (Data, PAD_TYPE, 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);
pad->Point2.Y = SWAP_Y (pad->Point2.Y) + yoff;
TOGGLE_FLAG (ONSOLDERFLAG, pad);
}
END_LOOP;
ARC_LOOP (Element);
{
arc->X = SWAP_X (arc->X);
arc->Y = SWAP_Y (arc->Y) + yoff;
arc->StartAngle = SWAP_ANGLE (arc->StartAngle);
arc->Delta = SWAP_DELTA (arc->Delta);
}
END_LOOP;
ELEMENTTEXT_LOOP (Element);
{
text->X = SWAP_X (text->X);
text->Y = SWAP_Y (text->Y) + yoff;
TOGGLE_FLAG (ONSOLDERFLAG, text);
}
END_LOOP;
Element->MarkX = SWAP_X (Element->MarkX);
Element->MarkY = SWAP_Y (Element->MarkY) + yoff;
/* now toggle the solder-side flag */
TOGGLE_FLAG (ONSOLDERFLAG, Element);
/* this inserts all of the rtree data too */
SetElementBoundingBox (Data, Element, &PCB->Font);
ClearFromPolygon (Data, ELEMENT_TYPE, Element, Element);
}
/* ---------------------------------------------------------------------------
* draws the package of an element
*/
void
DrawElementPackage (ElementType *Element)
{
ELEMENTLINE_LOOP (Element);
{
DrawLine (NULL, line);
}
END_LOOP;
ARC_LOOP (Element);
{
DrawArc (NULL, arc);
}
END_LOOP;
}
/* ---------------------------------------------------------------------------
* erases an element
*/
void
EraseElement (ElementType *Element)
{
ELEMENTLINE_LOOP (Element);
{
EraseLine (line);
}
END_LOOP;
ARC_LOOP (Element);
{
EraseArc (arc);
}
END_LOOP;
EraseElementName (Element);
EraseElementPinsAndPads (Element);
}
/* ---------------------------------------------------------------------------
* moves a element by +-X and +-Y
*/
void
MoveElementLowLevel (DataTypePtr Data, ElementTypePtr Element,
Coord DX, Coord DY)
{
if (Data)
r_delete_entry (Data->element_tree, (BoxType *)Element);
ELEMENTLINE_LOOP (Element);
{
MOVE_LINE_LOWLEVEL (line, DX, DY);
}
END_LOOP;
PIN_LOOP (Element);
{
if (Data)
{
r_delete_entry (Data->pin_tree, (BoxType *)pin);
RestoreToPolygon (Data, PIN_TYPE, 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);
}
}
END_LOOP;
PAD_LOOP (Element);
{
if (Data)
{
r_delete_entry (Data->pad_tree, (BoxType *)pad);
RestoreToPolygon (Data, PAD_TYPE, 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);
}
}
END_LOOP;
ARC_LOOP (Element);
{
MOVE_ARC_LOWLEVEL (arc, DX, DY);
}
END_LOOP;
ELEMENTTEXT_LOOP (Element);
{
if (Data && Data->name_tree[n])
r_delete_entry (PCB->Data->name_tree[n], (BoxType *)text);
MOVE_TEXT_LOWLEVEL (text, DX, DY);
if (Data && Data->name_tree[n])
r_insert_entry (PCB->Data->name_tree[n], (BoxType *)text, 0);
}
END_LOOP;
MOVE_BOX_LOWLEVEL (&Element->BoundingBox, DX, DY);
MOVE_BOX_LOWLEVEL (&Element->VBox, DX, DY);
MOVE (Element->MarkX, Element->MarkY, DX, DY);
if (Data)
r_insert_entry (Data->element_tree, (BoxType *)Element, 0);
}
/* ---------------------------------------------------------------------------
* searches for a object by it's unique ID. It doesn't matter if
* the object is visible or not. The search is performed on a PCB, a
* 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.
*/
int
SearchObjectByID (DataTypePtr Base,
void **Result1, void **Result2, void **Result3, int ID,
int type)
{
if (type == LINE_TYPE || type == LINEPOINT_TYPE)
{
ALLLINE_LOOP (Base);
{
if (line->ID == ID)
{
*Result1 = (void *) layer;
*Result2 = *Result3 = (void *) line;
return (LINE_TYPE);
}
if (line->Point1.ID == ID)
{
*Result1 = (void *) layer;
*Result2 = (void *) line;
*Result3 = (void *) &line->Point1;
return (LINEPOINT_TYPE);
}
if (line->Point2.ID == ID)
{
*Result1 = (void *) layer;
*Result2 = (void *) line;
*Result3 = (void *) &line->Point2;
return (LINEPOINT_TYPE);
}
}
ENDALL_LOOP;
}
if (type == ARC_TYPE)
{
ALLARC_LOOP (Base);
{
if (arc->ID == ID)
{
*Result1 = (void *) layer;
*Result2 = *Result3 = (void *) arc;
return (ARC_TYPE);
}
}
ENDALL_LOOP;
}
if (type == TEXT_TYPE)
{
ALLTEXT_LOOP (Base);
{
if (text->ID == ID)
{
*Result1 = (void *) layer;
*Result2 = *Result3 = (void *) text;
return (TEXT_TYPE);
}
}
ENDALL_LOOP;
}
if (type == POLYGON_TYPE || type == POLYGONPOINT_TYPE)
{
ALLPOLYGON_LOOP (Base);
{
if (polygon->ID == ID)
{
*Result1 = (void *) layer;
*Result2 = *Result3 = (void *) polygon;
return (POLYGON_TYPE);
}
if (type == POLYGONPOINT_TYPE)
POLYGONPOINT_LOOP (polygon);
{
if (point->ID == ID)
{
*Result1 = (void *) layer;
*Result2 = (void *) polygon;
*Result3 = (void *) point;
return (POLYGONPOINT_TYPE);
}
}
END_LOOP;
}
ENDALL_LOOP;
}
if (type == VIA_TYPE)
{
VIA_LOOP (Base);
{
if (via->ID == ID)
{
*Result1 = *Result2 = *Result3 = (void *) via;
return (VIA_TYPE);
}
}
END_LOOP;
}
if (type == RATLINE_TYPE || type == LINEPOINT_TYPE)
{
RAT_LOOP (Base);
{
if (line->ID == ID)
{
*Result1 = *Result2 = *Result3 = (void *) line;
return (RATLINE_TYPE);
}
if (line->Point1.ID == ID)
{
*Result1 = (void *) NULL;
*Result2 = (void *) line;
*Result3 = (void *) &line->Point1;
return (LINEPOINT_TYPE);
}
if (line->Point2.ID == ID)
{
*Result1 = (void *) NULL;
*Result2 = (void *) line;
*Result3 = (void *) &line->Point2;
return (LINEPOINT_TYPE);
}
}
END_LOOP;
}
if (type == ELEMENT_TYPE || type == PAD_TYPE || type == PIN_TYPE
|| type == ELEMENTLINE_TYPE || type == ELEMENTNAME_TYPE
|| type == ELEMENTARC_TYPE)
/* check pins and elementnames too */
ELEMENT_LOOP (Base);
{
if (element->ID == ID)
{
*Result1 = *Result2 = *Result3 = (void *) element;
return (ELEMENT_TYPE);
}
if (type == ELEMENTLINE_TYPE)
ELEMENTLINE_LOOP (element);
{
if (line->ID == ID)
{
*Result1 = (void *) element;
*Result2 = *Result3 = (void *) line;
return (ELEMENTLINE_TYPE);
}
}
END_LOOP;
if (type == ELEMENTARC_TYPE)
ARC_LOOP (element);
{
if (arc->ID == ID)
{
*Result1 = (void *) element;
*Result2 = *Result3 = (void *) arc;
return (ELEMENTARC_TYPE);
}
}
END_LOOP;
if (type == ELEMENTNAME_TYPE)
ELEMENTTEXT_LOOP (element);
{
if (text->ID == ID)
{
*Result1 = (void *) element;
*Result2 = *Result3 = (void *) text;
return (ELEMENTNAME_TYPE);
}
}
END_LOOP;
if (type == PIN_TYPE)
PIN_LOOP (element);
{
if (pin->ID == ID)
{
*Result1 = (void *) element;
*Result2 = *Result3 = (void *) pin;
return (PIN_TYPE);
}
}
END_LOOP;
if (type == PAD_TYPE)
PAD_LOOP (element);
{
if (pad->ID == ID)
{
*Result1 = (void *) element;
*Result2 = *Result3 = (void *) pad;
return (PAD_TYPE);
}
}
END_LOOP;
}
END_LOOP;
Message ("hace: Internal error, search for ID %d failed\n", ID);
return (NO_TYPE);
}
/* ---------------------------------------------------------------------------
* draws the elements of a loaded circuit which is to be merged in
*/
static void
XORDrawElement (ElementTypePtr Element, LocationType DX, LocationType DY)
{
/* if no silkscreen, draw the bounding box */
if (Element->ArcN == 0 && Element->LineN == 0)
{
gui->draw_line (Crosshair.GC,
DX + Element->BoundingBox.X1,
DY + Element->BoundingBox.Y1,
DX + Element->BoundingBox.X1,
DY + Element->BoundingBox.Y2);
gui->draw_line (Crosshair.GC,
DX + Element->BoundingBox.X1,
DY + Element->BoundingBox.Y2,
DX + Element->BoundingBox.X2,
DY + Element->BoundingBox.Y2);
gui->draw_line (Crosshair.GC,
DX + Element->BoundingBox.X2,
DY + Element->BoundingBox.Y2,
DX + Element->BoundingBox.X2,
DY + Element->BoundingBox.Y1);
gui->draw_line (Crosshair.GC,
DX + Element->BoundingBox.X2,
DY + Element->BoundingBox.Y1,
DX + Element->BoundingBox.X1,
DY + Element->BoundingBox.Y1);
}
else
{
ELEMENTLINE_LOOP (Element);
{
gui->draw_line (Crosshair.GC,
DX + line->Point1.X,
DY + line->Point1.Y,
DX + line->Point2.X, DY + line->Point2.Y);
}
END_LOOP;
/* arc coordinates and angles have to be converted to X11 notation */
ARC_LOOP (Element);
{
gui->draw_arc (Crosshair.GC,
DX + arc->X,
DY + arc->Y,
arc->Width, arc->Height, arc->StartAngle, arc->Delta);
}
END_LOOP;
}
/* pin coordinates and angles have to be converted to X11 notation */
PIN_LOOP (Element);
{
gui->draw_arc (Crosshair.GC,
DX + pin->X,
DY + pin->Y,
pin->Thickness / 2, pin->Thickness / 2, 0, 360);
}
END_LOOP;
/* pads */
PAD_LOOP (Element);
{
if ((TEST_FLAG (ONSOLDERFLAG, pad) != 0) ==
Settings.ShowSolderSide || PCB->InvisibleObjectsOn)
{
if (pad->Point1.X == pad->Point2.X
|| pad->Point1.Y == pad->Point2.Y)
{
int minx, miny, maxx, maxy;
minx = DX + MIN (pad->Point1.X, pad->Point2.X) - pad->Thickness/2;
maxx = DX + MAX (pad->Point1.X, pad->Point2.X) + pad->Thickness/2;
miny = DY + MIN (pad->Point1.Y, pad->Point2.Y) - pad->Thickness/2;
maxy = DY + MAX (pad->Point1.Y, pad->Point2.Y) + pad->Thickness/2;
gui->draw_line (Crosshair.GC, minx, miny, maxx, miny);
gui->draw_line (Crosshair.GC, minx, miny, minx, maxy);
gui->draw_line (Crosshair.GC, maxx, miny, maxx, maxy);
gui->draw_line (Crosshair.GC, minx, maxy, maxx, maxy);
}
else
{
/* FIXME: draw outlines, not centerlines. */
gui->draw_line (Crosshair.GC,
DX + pad->Point1.X, DY + pad->Point1.Y,
DX + pad->Point2.X, DY + pad->Point2.Y);
}
}
}
END_LOOP;
/* mark */
gui->draw_line (Crosshair.GC,
Element->MarkX + DX - EMARK_SIZE,
Element->MarkY + DY,
Element->MarkX + DX, Element->MarkY + DY - EMARK_SIZE);
gui->draw_line (Crosshair.GC,
Element->MarkX + DX + EMARK_SIZE,
Element->MarkY + DY,
Element->MarkX + DX, Element->MarkY + DY - EMARK_SIZE);
gui->draw_line (Crosshair.GC,
Element->MarkX + DX - EMARK_SIZE,
Element->MarkY + DY,
Element->MarkX + DX, Element->MarkY + DY + EMARK_SIZE);
gui->draw_line (Crosshair.GC,
Element->MarkX + DX + EMARK_SIZE,
Element->MarkY + DY,
Element->MarkX + DX, Element->MarkY + DY + EMARK_SIZE);
}
/* ---------------------------------------------------------------------------
* copies data from one element to another and creates the destination
* if necessary
*/
ElementType *
CopyElementLowLevel (DataType *Data, ElementType *Src,
bool uniqueName, Coord dx, Coord dy, int mask_flags)
{
int i;
ElementType *Dest;
/* both coordinates and flags are the same */
Dest = CreateNewElement (Data, &PCB->Font,
MaskFlags (Src->Flags, mask_flags),
DESCRIPTION_NAME (Src), NAMEONPCB_NAME (Src),
VALUE_NAME (Src), DESCRIPTION_TEXT (Src).X + dx,
DESCRIPTION_TEXT (Src).Y + dy,
DESCRIPTION_TEXT (Src).Direction,
DESCRIPTION_TEXT (Src).Scale,
MaskFlags (DESCRIPTION_TEXT (Src).Flags,
mask_flags), uniqueName);
/* abort on error */
if (!Dest)
return (Dest);
ELEMENTLINE_LOOP (Src);
{
CreateNewLineInElement (Dest, line->Point1.X + dx,
line->Point1.Y + dy, line->Point2.X + dx,
line->Point2.Y + dy, line->Thickness);
}
END_LOOP;
PIN_LOOP (Src);
{
CreateNewPin (Dest, pin->X + dx, pin->Y + dy, pin->Thickness,
pin->Clearance, pin->Mask, pin->DrillingHole,
pin->Name, pin->Number, MaskFlags (pin->Flags, mask_flags));
}
END_LOOP;
PAD_LOOP (Src);
{
CreateNewPad (Dest, pad->Point1.X + dx, pad->Point1.Y + dy,
pad->Point2.X + dx, pad->Point2.Y + dy, pad->Thickness,
pad->Clearance, pad->Mask, pad->Name, pad->Number,
MaskFlags (pad->Flags, mask_flags));
}
END_LOOP;
ARC_LOOP (Src);
{
CreateNewArcInElement (Dest, arc->X + dx, arc->Y + dy, arc->Width,
arc->Height, arc->StartAngle, arc->Delta,
arc->Thickness);
}
END_LOOP;
for (i=0; i<Src->Attributes.Number; i++)
CreateNewAttribute (& Dest->Attributes,
Src->Attributes.List[i].name,
Src->Attributes.List[i].value);
Dest->MarkX = Src->MarkX + dx;
Dest->MarkY = Src->MarkY + dy;
SetElementBoundingBox (Data, Dest, &PCB->Font);
return (Dest);
}
static void
pinout_set_data (GhidPinoutPreview * pinout, ElementType * element)
{
gint tx, ty, x_min = 0, y_min = 0;
if (element == NULL)
{
FreeElementMemory (&pinout->element);
pinout->w_pixels = 0;
pinout->h_pixels = 0;
return;
}
/*
* copy element data
* enable output of pin and padnames
* move element to a 5% offset from zero position
* set all package lines/arcs to zero width
*/
CopyElementLowLevel (NULL, &pinout->element, element, FALSE, 0, 0);
PIN_LOOP (&pinout->element);
{
tx = abs (pinout->element.Pin[0].X - pin->X);
ty = abs (pinout->element.Pin[0].Y - pin->Y);
if (x_min == 0 || (tx != 0 && tx < x_min))
x_min = tx;
if (y_min == 0 || (ty != 0 && ty < y_min))
y_min = ty;
SET_FLAG (DISPLAYNAMEFLAG, pin);
}
END_LOOP;
PAD_LOOP (&pinout->element);
{
tx = abs (pinout->element.Pad[0].Point1.X - pad->Point1.X);
ty = abs (pinout->element.Pad[0].Point1.Y - pad->Point1.Y);
if (x_min == 0 || (tx != 0 && tx < x_min))
x_min = tx;
if (y_min == 0 || (ty != 0 && ty < y_min))
y_min = ty;
SET_FLAG (DISPLAYNAMEFLAG, pad);
}
END_LOOP;
MoveElementLowLevel (NULL, &pinout->element,
Settings.PinoutOffsetX -
pinout->element.BoundingBox.X1,
Settings.PinoutOffsetY -
pinout->element.BoundingBox.Y1);
if (!pinout_zoom_fit (pinout, 2))
pinout_zoom_fit (pinout, 3);
ELEMENTLINE_LOOP (&pinout->element);
{
line->Thickness = 0;
}
END_LOOP;
ARC_LOOP (&pinout->element);
{
/*
* for whatever reason setting a thickness of 0 causes the arcs to
* not display so pick 1 which does display but is still quite
* thin.
*/
arc->Thickness = 1;
}
END_LOOP;
}
/*---------------------------------------------------------------------------
*
* break buffer element into pieces
*/
bool
SmashBufferElement (BufferType *Buffer)
{
ElementType *element;
Cardinal group;
LayerType *clayer, *slayer;
if (Buffer->Data->ElementN != 1)
{
Message (_("Error! Buffer doesn't contain a single element\n"));
return (false);
}
/*
* At this point the buffer should contain just a single element.
* Now we detach the single element from the buffer and then clear the
* buffer, ready to receive the smashed elements. As a result of detaching
* it the single element is orphaned from the buffer and thus will not be
* free()'d by FreeDataMemory (called via ClearBuffer). This leaves it
* around for us to smash bits off it. It then becomes our responsibility,
* however, to free the single element when we're finished with it.
*/
element = Buffer->Data->Element->data;
Buffer->Data->Element = NULL;
Buffer->Data->ElementN = 0;
ClearBuffer (Buffer);
ELEMENTLINE_LOOP (element);
{
CreateNewLineOnLayer (&Buffer->Data->SILKLAYER,
line->Point1.X, line->Point1.Y,
line->Point2.X, line->Point2.Y,
line->Thickness, 0, NoFlags ());
if (line)
line->Number = STRDUP (NAMEONPCB_NAME (element));
}
END_LOOP;
ARC_LOOP (element);
{
CreateNewArcOnLayer (&Buffer->Data->SILKLAYER,
arc->X, arc->Y, arc->Width, arc->Height, arc->StartAngle,
arc->Delta, arc->Thickness, 0, NoFlags ());
}
END_LOOP;
PIN_LOOP (element);
{
FlagType f = NoFlags ();
AddFlags (f, VIAFLAG);
if (TEST_FLAG (HOLEFLAG, pin))
AddFlags (f, HOLEFLAG);
CreateNewVia (Buffer->Data, pin->X, pin->Y,
pin->Thickness, pin->Clearance, pin->Mask,
pin->DrillingHole, pin->Number, f);
}
END_LOOP;
group =
GetLayerGroupNumberByNumber (SWAP_IDENT ? solder_silk_layer :
component_silk_layer);
clayer = &Buffer->Data->Layer[PCB->LayerGroups.Entries[group][0]];
group =
GetLayerGroupNumberByNumber (SWAP_IDENT ? component_silk_layer :
solder_silk_layer);
slayer = &Buffer->Data->Layer[PCB->LayerGroups.Entries[group][0]];
PAD_LOOP (element);
{
LineType *line;
line = CreateNewLineOnLayer (TEST_FLAG (ONSOLDERFLAG, pad) ? slayer : clayer,
pad->Point1.X, pad->Point1.Y,
pad->Point2.X, pad->Point2.Y,
pad->Thickness, pad->Clearance, NoFlags ());
if (line)
line->Number = STRDUP (pad->Number);
}
END_LOOP;
FreeElementMemory (element);
g_slice_free (ElementType, element);
return (true);
}
/* ---------------------------------------------------------------------------
* draws the elements of a loaded circuit which is to be merged in
*/
static void
XORDrawElement (ElementTypePtr Element, Coord DX, Coord DY)
{
/* if no silkscreen, draw the bounding box */
if (Element->ArcN == 0 && Element->LineN == 0)
{
gui->draw_line (Crosshair.GC,
DX + Element->BoundingBox.X1,
DY + Element->BoundingBox.Y1,
DX + Element->BoundingBox.X1,
DY + Element->BoundingBox.Y2);
gui->draw_line (Crosshair.GC,
DX + Element->BoundingBox.X1,
DY + Element->BoundingBox.Y2,
DX + Element->BoundingBox.X2,
DY + Element->BoundingBox.Y2);
gui->draw_line (Crosshair.GC,
DX + Element->BoundingBox.X2,
DY + Element->BoundingBox.Y2,
DX + Element->BoundingBox.X2,
DY + Element->BoundingBox.Y1);
gui->draw_line (Crosshair.GC,
DX + Element->BoundingBox.X2,
DY + Element->BoundingBox.Y1,
DX + Element->BoundingBox.X1,
DY + Element->BoundingBox.Y1);
}
else
{
ELEMENTLINE_LOOP (Element);
{
gui->draw_line (Crosshair.GC,
DX + line->Point1.X,
DY + line->Point1.Y,
DX + line->Point2.X, DY + line->Point2.Y);
}
END_LOOP;
/* arc coordinates and angles have to be converted to X11 notation */
ARC_LOOP (Element);
{
gui->draw_arc (Crosshair.GC,
DX + arc->X,
DY + arc->Y,
arc->Width, arc->Height, arc->StartAngle, arc->Delta);
}
END_LOOP;
}
/* pin coordinates and angles have to be converted to X11 notation */
PIN_LOOP (Element);
{
thindraw_moved_pv (pin, DX, DY);
}
END_LOOP;
/* pads */
PAD_LOOP (Element);
{
if (PCB->InvisibleObjectsOn ||
(TEST_FLAG (ONSOLDERFLAG, pad) != 0) == Settings.ShowSolderSide)
{
/* Make a copy of the pad structure, moved to the correct position */
PadType moved_pad = *pad;
moved_pad.Point1.X += DX;
moved_pad.Point1.Y += DY;
moved_pad.Point2.X += DX;
moved_pad.Point2.Y += DY;
gui->thindraw_pcb_pad (Crosshair.GC, &moved_pad, false, false);
}
}
END_LOOP;
/* mark */
gui->draw_line (Crosshair.GC,
Element->MarkX + DX - EMARK_SIZE,
Element->MarkY + DY,
Element->MarkX + DX, Element->MarkY + DY - EMARK_SIZE);
gui->draw_line (Crosshair.GC,
Element->MarkX + DX + EMARK_SIZE,
Element->MarkY + DY,
Element->MarkX + DX, Element->MarkY + DY - EMARK_SIZE);
gui->draw_line (Crosshair.GC,
Element->MarkX + DX - EMARK_SIZE,
Element->MarkY + DY,
Element->MarkX + DX, Element->MarkY + DY + EMARK_SIZE);
gui->draw_line (Crosshair.GC,
Element->MarkX + DX + EMARK_SIZE,
Element->MarkY + DY,
Element->MarkX + DX, Element->MarkY + DY + EMARK_SIZE);
}
