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); }