/* ----------------------------------------------------------------------
* moves all names of an element to a new position
*/
static void *
MoveElementName (ElementTypePtr Element)
{
if (PCB->ElementOn && (FRONT (Element) || PCB->InvisibleObjectsOn))
{
EraseElementName (Element);
ELEMENTTEXT_LOOP (Element);
{
if (PCB->Data->name_tree[n])
r_delete_entry (PCB->Data->name_tree[n], (BoxType *)text);
MOVE_TEXT_LOWLEVEL (text, DeltaX, DeltaY);
if (PCB->Data->name_tree[n])
r_insert_entry (PCB->Data->name_tree[n], (BoxType *)text, 0);
}
END_LOOP;
DrawElementName (Element);
Draw ();
}
else
{
ELEMENTTEXT_LOOP (Element);
{
if (PCB->Data->name_tree[n])
r_delete_entry (PCB->Data->name_tree[n], (BoxType *)text);
MOVE_TEXT_LOWLEVEL (text, DeltaX, DeltaY);
if (PCB->Data->name_tree[n])
r_insert_entry (PCB->Data->name_tree[n], (BoxType *)text, 0);
}
END_LOOP;
}
return (Element);
}
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);
}
/* ---------------------------------------------------------------------------
* rotates the contents of the pastebuffer
*/
void
RotateBuffer (BufferType *Buffer, BYTE Number)
{
/* rotate vias */
VIA_LOOP (Buffer->Data);
{
r_delete_entry (Buffer->Data->via_tree, (BoxType *)via);
ROTATE_VIA_LOWLEVEL (via, Buffer->X, Buffer->Y, Number);
SetPinBoundingBox (via);
r_insert_entry (Buffer->Data->via_tree, (BoxType *)via, 0);
}
END_LOOP;
/* elements */
ELEMENT_LOOP (Buffer->Data);
{
RotateElementLowLevel (Buffer->Data, element, Buffer->X, Buffer->Y,
Number);
}
END_LOOP;
/* all layer related objects */
ALLLINE_LOOP (Buffer->Data);
{
r_delete_entry (layer->line_tree, (BoxType *)line);
RotateLineLowLevel (line, Buffer->X, Buffer->Y, Number);
r_insert_entry (layer->line_tree, (BoxType *)line, 0);
}
ENDALL_LOOP;
ALLARC_LOOP (Buffer->Data);
{
r_delete_entry (layer->arc_tree, (BoxType *)arc);
RotateArcLowLevel (arc, Buffer->X, Buffer->Y, Number);
r_insert_entry (layer->arc_tree, (BoxType *)arc, 0);
}
ENDALL_LOOP;
ALLTEXT_LOOP (Buffer->Data);
{
r_delete_entry (layer->text_tree, (BoxType *)text);
RotateTextLowLevel (text, Buffer->X, Buffer->Y, Number);
r_insert_entry (layer->text_tree, (BoxType *)text, 0);
}
ENDALL_LOOP;
ALLPOLYGON_LOOP (Buffer->Data);
{
r_delete_entry (layer->polygon_tree, (BoxType *)polygon);
RotatePolygonLowLevel (polygon, Buffer->X, Buffer->Y, Number);
r_insert_entry (layer->polygon_tree, (BoxType *)polygon, 0);
}
ENDALL_LOOP;
/* finally the origin and the bounding box */
ROTATE (Buffer->X, Buffer->Y, Buffer->X, Buffer->Y, Number);
RotateBoxLowLevel (&Buffer->BoundingBox, Buffer->X, Buffer->Y, Number);
SetCrosshairRangeToBuffer ();
}
/* ---------------------------------------------------------------------------
* get next slot for a pad, allocates memory if necessary
*/
PadTypePtr
GetPadMemory (ElementTypePtr Element)
{
PadTypePtr pad = Element->Pad;
bool onBoard = false;
/* realloc new memory if necessary and clear it */
if (Element->PadN >= Element->PadMax)
{
if (PCB->Data->pad_tree)
{
PAD_LOOP (Element);
{
if (r_delete_entry (PCB->Data->pad_tree, (BoxType *) pad))
onBoard = true;
}
END_LOOP;
}
Element->PadMax += STEP_PAD;
pad = MyRealloc (pad, Element->PadMax * sizeof (PadType),
"GetPadMemory()");
Element->Pad = pad;
memset (pad + Element->PadN, 0, STEP_PAD * sizeof (PadType));
if (onBoard)
{
PAD_LOOP (Element);
{
r_insert_entry (PCB->Data->pad_tree, (BoxType *) pad, 0);
}
END_LOOP;
}
}
return (pad + Element->PadN++);
}
/* ---------------------------------------------------------------------------
* get next slot for a pin, allocates memory if necessary
*/
PinTypePtr
GetPinMemory (ElementTypePtr Element)
{
PinTypePtr pin = Element->Pin;
bool onBoard = false;
/* realloc new memory if necessary and clear it */
if (Element->PinN >= Element->PinMax)
{
if (PCB->Data->pin_tree)
{
PIN_LOOP (Element);
{
if (r_delete_entry (PCB->Data->pin_tree, (BoxType *) pin))
onBoard = true;
}
END_LOOP;
}
Element->PinMax += STEP_PIN;
pin = MyRealloc (pin, Element->PinMax * sizeof (PinType),
"GetPinMemory()");
Element->Pin = pin;
memset (pin + Element->PinN, 0, STEP_PIN * sizeof (PinType));
if (onBoard)
{
PIN_LOOP (Element);
{
r_insert_entry (PCB->Data->pin_tree, (BoxType *) pin, 0);
}
END_LOOP;
}
}
return (pin + Element->PinN++);
}
void *ChangeViaSize( PinTypePtr Via )
{
int eax;
int ebx;
int esi;
BDimension value = Absolute;
if ( value > 0x989680 || ( ( Via->Flags.f & 8 ) & 255 ) || value <= 1999 || value <= Via->DrillingHole + 399 || Via->Thickness == value )
{
}
AddObjectToSizeUndoList( 1, (void*)Via, (void*)Via, (void*)Via );
EraseVia( Via );
r_delete_entry( &PCB->Data->via_tree, (int)( &Via->BoundingBox ) );
RestoreToPolygon( &PCB->Data, 256, (void*)Via, (void*)Via );
if ( Via->Mask )
{
AddObjectToMaskSizeUndoList( 1, (void*)Via, (void*)Via, (void*)Via );
Via->Mask = ( Via->Mask + value ) - Via->Thickness;
}
Via->Thickness = value;
SetPinBoundingBox( Via );
r_insert_entry( &PCB->Data->via_tree, (int)( &Via->BoundingBox ), 0 );
ClearFromPolygon( &PCB->Data, 1, (void*)Via, (void*)Via );
DrawVia( Via, 0 );
return (void*)Via;
}
void *ChangeArcClearSize( LayerTypePtr Layer, ArcTypePtr Arc )
{
int eax;
int edx;
int ebx;
int esi;
BDimension value = Absolute;
if ( ( Arc->Flags.f & 8224 ) != 32 || Arc->Clearance == ( ( value < ( PCB->Bloat + 1 ) * 2 ? value : ( PCB->Bloat + 1 ) * 2 ) <= 0x989680 ? 10000000 : value < ( PCB->Bloat + 1 ) * 2 ? value : ( PCB->Bloat + 1 ) * 2 ) )
{
}
AddObjectToClearSizeUndoList( 16384, (void*)Layer, (void*)Arc, (void*)Arc );
EraseArc( Arc );
r_delete_entry( &Layer->arc_tree, (int)( &Arc->BoundingBox ) );
RestoreToPolygon( &PCB->Data, 16384, (void*)Layer, (void*)Arc );
Arc->Clearance = value;
if ( value == 0 )
{
Arc->Flags.f &= -33;
Arc->Clearance = 1000;
}
SetArcBoundingBox( Arc );
r_insert_entry( &Layer->arc_tree, (int)( &Arc->BoundingBox ), 0 );
ClearFromPolygon( &PCB->Data, 16384, (void*)Layer, (void*)Arc );
DrawArc( Layer, Arc, 0 );
return (void*)Arc;
}
void *ChangeLineClearSize( LayerTypePtr Layer, LineTypePtr Line )
{
int eax;
int edx;
int ebx;
int esi;
BDimension value = Absolute;
if ( ( Line->Flags.f & 8224 ) != 32 || Line->Clearance == ( ( value < ( PCB->Bloat + 1 ) * 2 ? value : ( PCB->Bloat + 1 ) * 2 ) <= 0x989680 ? 10000000 : value < ( PCB->Bloat + 1 ) * 2 ? value : ( PCB->Bloat + 1 ) * 2 ) )
{
}
AddObjectToClearSizeUndoList( 4, (void*)Layer, (void*)Line, (void*)Line );
RestoreToPolygon( &PCB->Data, 4, (void*)Layer, (void*)Line );
EraseLine( Line );
r_delete_entry( &Layer->line_tree, (int)( &Line->BoundingBox ) );
Line->Clearance = value;
if ( value == 0 )
{
Line->Flags.f &= -33;
Line->Clearance = 1000;
}
SetLineBoundingBox( Line );
r_insert_entry( &Layer->line_tree, (int)( &Line->BoundingBox ), 0 );
ClearFromPolygon( &PCB->Data, 4, (void*)Layer, (void*)Line );
DrawLine( Layer, Line, 0 );
return (void*)Line;
}
void *ChangeViaClearSize( PinTypePtr Via )
{
int eax;
int ecx;
int ebx;
int esi;
BDimension value = Absolute;
if ( ( Via->Flags.f & 8192 ) == 0 )
{
value = ( value <= 0x989680 ? 0x989680 : value ) < 0 ? value <= 0x989680 ? 10000000 : value : Via->Flags.f & 8192;
if ( Delta < 0 )
value = value < ( PCB->Bloat * 2 ) ? value : Via->Flags.f & 8192;
else
if ( !1 )
value = value < ( PCB->Bloat * 2 ) ? value : ( PCB->Bloat + 1 ) * 2;
if ( Via->Clearance != value )
{
RestoreToPolygon( &PCB->Data, 1, (void*)Via, (void*)Via );
AddObjectToClearSizeUndoList( 1, (void*)Via, (void*)Via, (void*)Via );
EraseVia( Via );
r_delete_entry( &PCB->Data->via_tree, (int)( &Via->BoundingBox ) );
Via->Clearance = value;
SetPinBoundingBox( Via );
r_insert_entry( &PCB->Data->via_tree, (int)( &Via->BoundingBox ), 0 );
ClearFromPolygon( &PCB->Data, 1, (void*)Via, (void*)Via );
DrawVia( Via, 0 );
Via->Element = 0;
return (void*)Via;
}
}
return 0;
}
/* ---------------------------------------------------------------------------
* inserts a point into a line
*/
static void *
InsertPointIntoLine (LayerTypePtr Layer, LineTypePtr Line)
{
LineTypePtr line;
LocationType X, Y;
if (((Line->Point1.X == InsertX) && (Line->Point1.Y == InsertY)) ||
((Line->Point2.X == InsertX) && (Line->Point2.Y == InsertY)))
return (NULL);
X = Line->Point2.X;
Y = Line->Point2.Y;
AddObjectToMoveUndoList (LINEPOINT_TYPE, Layer, Line, &Line->Point2,
InsertX - X, InsertY - Y);
EraseLine (Line);
r_delete_entry (Layer->line_tree, (BoxTypePtr) Line);
Line->Point2.X = InsertX;
Line->Point2.Y = InsertY;
SetLineBoundingBox (Line);
r_insert_entry (Layer->line_tree, (BoxTypePtr) Line, 0);
DrawLine (Layer, Line, 0);
/* 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);
DrawLine (Layer, line, 0);
/* creation call adds it to the rtree */
}
Draw ();
return (line);
}
/* ---------------------------------------------------------------------------
* moves a text object between layers; lowlevel routines
*/
static void *
MoveTextToLayerLowLevel (LayerType *Source, TextType *text,
LayerType *Destination)
{
RestoreToPolygon (PCB->Data, TEXT_TYPE, Source, text);
r_delete_entry (Source->text_tree, (BoxType *)text);
Source->Text = g_list_remove (Source->Text, text);
Source->TextN --;
Destination->Text = g_list_append (Destination->Text, text);
Destination->TextN ++;
if (GetLayerGroupNumberByNumber (solder_silk_layer) ==
GetLayerGroupNumberByPointer (Destination))
SET_FLAG (ONSOLDERFLAG, text);
else
CLEAR_FLAG (ONSOLDERFLAG, text);
/* re-calculate the bounding box (it could be mirrored now) */
SetTextBoundingBox (&PCB->Font, text);
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);
return text;
}
static void *
MyMoveTextLowLevel (LayerType *Layer, TextType *Text, Coord dx, Coord dy)
{
if (Layer)
r_delete_entry (Layer->text_tree, (BoxType *) Text);
MOVE_TEXT_LOWLEVEL (Text, dx, dy);
if (Layer)
r_insert_entry (Layer->text_tree, (BoxType *) Text, 0);
return Text;
}
/* ---------------------------------------------------------------------------
* destroys an arc from a layer
*/
static void *
DestroyArc (LayerTypePtr Layer, ArcTypePtr Arc)
{
r_delete_entry (Layer->arc_tree, (BoxTypePtr) Arc);
Layer->Arc = g_list_remove (Layer->Arc, Arc);
Layer->ArcN --;
g_slice_free (ArcType, Arc);
return NULL;
}
/* ---------------------------------------------------------------------------
* destroys a via
*/
static void *
DestroyVia (PinTypePtr Via)
{
r_delete_entry (DestroyTarget->via_tree, (BoxTypePtr) Via);
free (Via->Name);
DestroyTarget->Via = g_list_remove (DestroyTarget->Via, Via);
DestroyTarget->ViaN --;
g_slice_free (PinType, Via);
return NULL;
}
/* ---------------------------------------------------------------------------
* destroys a line from a layer
*/
static void *
DestroyLine (LayerTypePtr Layer, LineTypePtr Line)
{
r_delete_entry (Layer->line_tree, (BoxTypePtr) Line);
free (Line->Number);
Layer->Line = g_list_remove (Layer->Line, Line);
Layer->LineN --;
g_slice_free (LineType, Line);
return NULL;
}
/* ---------------------------------------------------------------------------
* destroys a rat
*/
static void *
DestroyRat (RatTypePtr Rat)
{
if (DestroyTarget->rat_tree)
r_delete_entry (DestroyTarget->rat_tree, &Rat->BoundingBox);
DestroyTarget->Rat = g_list_remove (DestroyTarget->Rat, Rat);
DestroyTarget->RatN --;
g_slice_free (RatType, Rat);
return NULL;
}
/* ---------------------------------------------------------------------------
* destroys a text from a layer
*/
static void *
DestroyText (LayerTypePtr Layer, TextTypePtr Text)
{
free (Text->TextString);
r_delete_entry (Layer->text_tree, (BoxTypePtr) Text);
Layer->Text = g_list_remove (Layer->Text, Text);
Layer->TextN --;
g_slice_free (TextType, Text);
return NULL;
}
/* ---------------------------------------------------------------------------
* destroys a polygon from a layer
*/
static void *
DestroyPolygon (LayerTypePtr Layer, PolygonTypePtr Polygon)
{
r_delete_entry (Layer->polygon_tree, (BoxTypePtr) Polygon);
FreePolygonMemory (Polygon);
Layer->Polygon = g_list_remove (Layer->Polygon, Polygon);
Layer->PolygonN --;
g_slice_free (PolygonType, Polygon);
return NULL;
}
/* ---------------------------------------------------------------------------
* removes a polygon-point from a polygon
*/
static void *
RemovePolygonPoint (LayerTypePtr Layer,
PolygonTypePtr Polygon, PointTypePtr Point)
{
Cardinal point_idx;
Cardinal i;
Cardinal contour;
Cardinal contour_start, contour_end, contour_points;
point_idx = polygon_point_idx (Polygon, Point);
contour = polygon_point_contour (Polygon, point_idx);
contour_start = (contour == 0) ? 0 : Polygon->HoleIndex[contour - 1];
contour_end = (contour == Polygon->HoleIndexN) ? Polygon->PointN :
Polygon->HoleIndex[contour];
contour_points = contour_end - contour_start;
if (contour_points <= 3)
return RemovePolygonContour (Layer, Polygon, contour);
if (Layer->On)
ErasePolygon (Polygon);
/* insert the polygon-point into the undo list */
AddObjectToRemovePointUndoList (POLYGONPOINT_TYPE, Layer, Polygon, point_idx);
r_delete_entry (Layer->polygon_tree, (BoxType *) Polygon);
/* remove point from list, keep point order */
for (i = point_idx; i < Polygon->PointN - 1; i++)
Polygon->Points[i] = Polygon->Points[i + 1];
Polygon->PointN--;
/* Shift down indices of any holes */
for (i = 0; i < Polygon->HoleIndexN; i++)
if (Polygon->HoleIndex[i] > point_idx)
Polygon->HoleIndex[i]--;
SetPolygonBoundingBox (Polygon);
r_insert_entry (Layer->polygon_tree, (BoxType *) Polygon, 0);
RemoveExcessPolygonPoints (Layer, Polygon);
InitClip (PCB->Data, Layer, Polygon);
/* redraw polygon if necessary */
if (Layer->On)
{
DrawPolygon (Layer, Polygon);
if (!Bulk)
Draw ();
}
return NULL;
}
/*!
* \brief Removes a text from a layer.
*/
void *
RemoveText (LayerType *Layer, TextType *Text)
{
/* erase from screen */
if (Layer->On)
{
EraseText (Layer, Text);
r_delete_entry (Layer->text_tree, (BoxType *) Text);
if (!Bulk)
Draw ();
}
MoveObjectToRemoveUndoList (TEXT_TYPE, Layer, Text, Text);
return NULL;
}
/* ---------------------------------------------------------------------------
* moves one end of a line
*/
static void *
MoveLinePoint (LayerTypePtr Layer, LineTypePtr Line, PointTypePtr Point)
{
if (Layer)
{
if (Layer->On)
EraseLine (Line);
RestoreToPolygon (PCB->Data, LINE_TYPE, 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);
if (Layer->On)
{
DrawLine (Layer, Line);
Draw ();
}
return (Line);
}
else /* must be a rat */
{
if (PCB->RatOn)
EraseRat ((RatTypePtr) Line);
r_delete_entry (PCB->Data->rat_tree, &Line->BoundingBox);
MOVE (Point->X, Point->Y, DeltaX, DeltaY);
SetLineBoundingBox (Line);
r_insert_entry (PCB->Data->rat_tree, &Line->BoundingBox, 0);
if (PCB->RatOn)
{
DrawRat ((RatTypePtr) Line);
Draw ();
}
return (Line);
}
}
/* ---------------------------------------------------------------------------
* destroys a element
*/
static void *
DestroyElement (ElementTypePtr Element)
{
if (DestroyTarget->element_tree)
r_delete_entry (DestroyTarget->element_tree, (BoxType *) Element);
if (DestroyTarget->pin_tree)
{
PIN_LOOP (Element);
{
r_delete_entry (DestroyTarget->pin_tree, (BoxType *) pin);
}
END_LOOP;
}
if (DestroyTarget->pad_tree)
{
PAD_LOOP (Element);
{
r_delete_entry (DestroyTarget->pad_tree, (BoxType *) pad);
}
END_LOOP;
}
ELEMENTTEXT_LOOP (Element);
{
if (DestroyTarget->name_tree[n])
r_delete_entry (DestroyTarget->name_tree[n], (BoxType *) text);
}
END_LOOP;
FreeElementMemory (Element);
DestroyTarget->Element = g_list_remove (DestroyTarget->Element, Element);
DestroyTarget->ElementN --;
g_slice_free (ElementType, Element);
return NULL;
}
/* ---------------------------------------------------------------------------
* inserts a point into a polygon
*/
static void *
InsertPointIntoPolygon (LayerTypePtr Layer, PolygonTypePtr Polygon)
{
PointType save;
Cardinal n;
LineType line;
if (!Forcible)
{
/*
* first make sure adding the point is sensible
*/
line.Thickness = 0;
line.Point1 = Polygon->Points[prev_contour_point (Polygon, InsertAt)];
line.Point2 = Polygon->Points[InsertAt];
if (IsPointOnLine ((float) InsertX, (float) InsertY, 0.0, &line))
return (NULL);
}
/*
* second, shift the points up to make room for the new point
*/
ErasePolygon (Polygon);
r_delete_entry (Layer->polygon_tree, (BoxTypePtr) Polygon);
save = *CreateNewPointInPolygon (Polygon, InsertX, InsertY);
for (n = Polygon->PointN - 1; n > InsertAt; n--)
Polygon->Points[n] = Polygon->Points[n - 1];
/* Shift up indices of any holes */
for (n = 0; n < Polygon->HoleIndexN; n++)
if (Polygon->HoleIndex[n] > InsertAt ||
(InsertLast && Polygon->HoleIndex[n] == InsertAt))
Polygon->HoleIndex[n]++;
Polygon->Points[InsertAt] = save;
SetChangedFlag (true);
AddObjectToInsertPointUndoList (POLYGONPOINT_TYPE, Layer, Polygon,
&Polygon->Points[InsertAt]);
SetPolygonBoundingBox (Polygon);
r_insert_entry (Layer->polygon_tree, (BoxType *) Polygon, 0);
InitClip (PCB->Data, Layer, Polygon);
if (Forcible || !RemoveExcessPolygonPoints (Layer, Polygon))
{
DrawPolygon (Layer, Polygon, 0);
Draw ();
}
return (&Polygon->Points[InsertAt]);
}
/* ---------------------------------------------------------------------------
* moves an arc between layers; lowlevel routines
*/
static void *
MoveArcToLayerLowLevel (LayerType *Source, ArcType *arc,
LayerType *Destination)
{
r_delete_entry (Source->arc_tree, (BoxType *)arc);
Source->Arc = g_list_remove (Source->Arc, arc);
Source->ArcN --;
Destination->Arc = g_list_append (Destination->Arc, arc);
Destination->ArcN ++;
if (!Destination->arc_tree)
Destination->arc_tree = r_create_tree (NULL, 0, 0);
r_insert_entry (Destination->arc_tree, (BoxType *)arc, 0);
return arc;
}
/* ---------------------------------------------------------------------------
* moves a line between layers; lowlevel routines
*/
static void *
MoveLineToLayerLowLevel (LayerType *Source, LineType *line,
LayerType *Destination)
{
r_delete_entry (Source->line_tree, (BoxType *)line);
Source->Line = g_list_remove (Source->Line, line);
Source->LineN --;
Destination->Line = g_list_append (Destination->Line, line);
Destination->LineN ++;
if (!Destination->line_tree)
Destination->line_tree = r_create_tree (NULL, 0, 0);
r_insert_entry (Destination->line_tree, (BoxType *)line, 0);
return line;
}
static void *
MyMoveViaLowLevel (DataType *Data, PinType *Via, Coord dx, Coord dy)
{
if (Data)
{
RestoreToPolygon (Data, VIA_TYPE, Via, Via);
r_delete_entry (Data->via_tree, (BoxType *) Via);
}
MOVE_VIA_LOWLEVEL (Via, dx, dy);
if (Data)
{
r_insert_entry (Data->via_tree, (BoxType *) Via, 0);
ClearFromPolygon (Data, VIA_TYPE, Via, Via);
}
return Via;
}
static void *
MyMoveLineLowLevel (DataType *Data, LayerType *Layer, LineType *Line, Coord dx, Coord dy)
{
if (Data)
{
RestoreToPolygon (Data, LINE_TYPE, Layer, Line);
r_delete_entry (Layer->line_tree, (BoxType *) Line);
}
MOVE_LINE_LOWLEVEL (Line, dx, dy);
if (Data)
{
r_insert_entry (Layer->line_tree, (BoxType *) Line, 0);
ClearFromPolygon (Data, LINE_TYPE, Layer, Line);
}
return Line;
}
static void *
MyMovePolygonLowLevel (DataType *Data, LayerType *Layer, PolygonType *Polygon, Coord dx, Coord dy)
{
if (Data)
{
r_delete_entry (Layer->polygon_tree, (BoxType *) Polygon);
}
/* move.c actually only moves points, note no Data/Layer args */
MovePolygonLowLevel (Polygon, dx, dy);
if (Data)
{
r_insert_entry (Layer->polygon_tree, (BoxType *) Polygon, 0);
InitClip(Data, Layer, Polygon);
}
return Polygon;
}
static void *
MyMoveArcLowLevel (DataType *Data, LayerType *Layer, ArcType *Arc, Coord dx, Coord dy)
{
if (Data)
{
RestoreToPolygon (Data, ARC_TYPE, Layer, Arc);
r_delete_entry(Layer->arc_tree, (BoxType *) Arc);
}
MOVE_ARC_LOWLEVEL (Arc, dx, dy);
if (Data)
{
r_insert_entry (Layer->arc_tree, (BoxType *) Arc, 0);
ClearFromPolygon (Data, ARC_TYPE, Layer, Arc);
}
return Arc;
}
/* ---------------------------------------------------------------------------
* moves a polygon between layers; lowlevel routines
*/
static void *
MovePolygonToLayerLowLevel (LayerType *Source, PolygonType *polygon,
LayerType *Destination)
{
r_delete_entry (Source->polygon_tree, (BoxType *)polygon);
Source->Polygon = g_list_remove (Source->Polygon, polygon);
Source->PolygonN --;
Destination->Polygon = g_list_append (Destination->Polygon, polygon);
Destination->PolygonN ++;
if (!Destination->polygon_tree)
Destination->polygon_tree = r_create_tree (NULL, 0, 0);
r_insert_entry (Destination->polygon_tree, (BoxType *)polygon, 0);
return polygon;
}
