/* ---------------------------------------------------------------------------
* 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;
}
/* ---------------------------------------------------------------------------
* free memory used by data struct
*/
void
FreeDataMemory (DataType *data)
{
LayerType *layer;
int i;
if (data == NULL)
return;
VIA_LOOP (data);
{
free (via->Name);
}
END_LOOP;
g_list_free_full (data->Via, (GDestroyNotify)FreeVia);
ELEMENT_LOOP (data);
{
FreeElementMemory (element);
}
END_LOOP;
g_list_free_full (data->Element, (GDestroyNotify)FreeElement);
g_list_free_full (data->Rat, (GDestroyNotify)FreeRat);
for (layer = data->Layer, i = 0; i < MAX_LAYER + 2; layer++, i++)
{
FreeAttributeListMemory (&layer->Attributes);
TEXT_LOOP (layer);
{
free (text->TextString);
}
END_LOOP;
if (layer->Name)
free (layer->Name);
LINE_LOOP (layer);
{
if (line->Number)
free (line->Number);
}
END_LOOP;
g_list_free_full (layer->Line, (GDestroyNotify)FreeLine);
g_list_free_full (layer->Arc, (GDestroyNotify)FreeArc);
g_list_free_full (layer->Text, (GDestroyNotify)FreeText);
POLYGON_LOOP (layer);
{
FreePolygonMemory (polygon);
}
END_LOOP;
g_list_free_full (layer->Polygon, (GDestroyNotify)FreePolygon);
if (layer->line_tree)
r_destroy_tree (&layer->line_tree);
if (layer->arc_tree)
r_destroy_tree (&layer->arc_tree);
if (layer->text_tree)
r_destroy_tree (&layer->text_tree);
if (layer->polygon_tree)
r_destroy_tree (&layer->polygon_tree);
}
if (data->element_tree)
r_destroy_tree (&data->element_tree);
for (i = 0; i < MAX_ELEMENTNAMES; i++)
if (data->name_tree[i])
r_destroy_tree (&data->name_tree[i]);
if (data->via_tree)
r_destroy_tree (&data->via_tree);
if (data->pin_tree)
r_destroy_tree (&data->pin_tree);
if (data->pad_tree)
r_destroy_tree (&data->pad_tree);
if (data->rat_tree)
r_destroy_tree (&data->rat_tree);
/* clear struct */
memset (data, 0, sizeof (DataType));
}
/* ---------------------------------------------------------------------------
* copies data from one element to another and creates the destination
* if necessary
*/
ElementType *
CopyElementLowLevel (DataType *Data, ElementType *Dest,
ElementType *Src, bool uniqueName, Coord dx,
Coord dy)
{
int i;
/* release old memory if necessary */
if (Dest)
FreeElementMemory (Dest);
/* both coordinates and flags are the same */
Dest = CreateNewElement (Data, Dest, &PCB->Font,
MaskFlags (Src->Flags, FOUNDFLAG),
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,
FOUNDFLAG), 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, FOUNDFLAG));
}
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, FOUNDFLAG));
}
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);
}
/* ---------------------------------------------------------------------------
* free memory used by data struct
*/
void
FreeDataMemory (DataTypePtr Data)
{
LayerTypePtr layer;
int i;
if (Data)
{
VIA_LOOP (Data);
{
MYFREE (via->Name);
}
END_LOOP;
ELEMENT_LOOP (Data);
{
FreeElementMemory (element);
}
END_LOOP;
for (layer = Data->Layer, i = 0; i < MAX_LAYER + 2; layer++, i++)
{
FreeAttributeListMemory (&layer->Attributes);
TEXT_LOOP (layer);
{
MYFREE (text->TextString);
}
END_LOOP;
if (layer->Name)
MYFREE (layer->Name);
LINE_LOOP (layer);
{
if (line->Number)
MYFREE (line->Number);
}
END_LOOP;
MYFREE (layer->Line);
MYFREE (layer->Arc);
MYFREE (layer->Text);
POLYGON_LOOP (layer);
{
FreePolygonMemory (polygon);
}
END_LOOP;
MYFREE (layer->Polygon);
if (layer->line_tree)
r_destroy_tree (&layer->line_tree);
if (layer->arc_tree)
r_destroy_tree (&layer->arc_tree);
if (layer->text_tree)
r_destroy_tree (&layer->text_tree);
if (layer->polygon_tree)
r_destroy_tree (&layer->polygon_tree);
}
if (Data->element_tree)
r_destroy_tree (&Data->element_tree);
for (i = 0; i < MAX_ELEMENTNAMES; i++)
if (Data->name_tree[i])
r_destroy_tree (&Data->name_tree[i]);
if (Data->via_tree)
r_destroy_tree (&Data->via_tree);
if (Data->pin_tree)
r_destroy_tree (&Data->pin_tree);
if (Data->pad_tree)
r_destroy_tree (&Data->pad_tree);
if (Data->rat_tree)
r_destroy_tree (&Data->rat_tree);
/* clear struct */
memset (Data, 0, sizeof (DataType));
}
else
{
fprintf (stderr, "Warning: Tried to FreeDataMemory(null)\n");
}
}
