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 *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;
}
void GVSearchListBox::DrawItem(LPDRAWITEMSTRUCT lpdis)
{
std::lock_guard<std::recursive_mutex> l(mutex_);
switch (lpdis->itemAction)
{
case ODA_DRAWENTIRE:
{
if (lpdis->itemState & ODS_SELECTED)
{
DrawSelected(lpdis);
}
else
{
DrawEntire(lpdis);
}
}
break;
case ODA_SELECT:
{
if (lpdis->itemState & ODS_SELECTED)
{
DrawSelected(lpdis);
}
else
{
DrawEntire(lpdis);
}
}
break;
default:
break;
}
RECT rect(lpdis->rcItem);
HPEN hpen = CreatePen(PS_SOLID, 1, RGB(248, 248, 248));
HBRUSH hbrush = CreateSolidBrush(RGB(248, 248, 248));
SelectObject(lpdis->hDC, hpen);
SelectObject(lpdis->hDC, hbrush);
Rectangle(lpdis->hDC, rect.left + 12, rect.bottom - 1, rect.right - 12, rect.bottom);
DeleteObject(hpen);
DeleteObject(hbrush);
DrawAvatar(lpdis);
DrawMessage(lpdis);
DrawVia(lpdis);
}
void
DrawObject (int type, void *ptr1, void *ptr2)
{
switch (type)
{
case VIA_TYPE:
if (PCB->ViaOn)
DrawVia ((PinType *) ptr2);
break;
case LINE_TYPE:
if (((LayerType *) ptr1)->On)
DrawLine ((LayerType *) ptr1, (LineType *) ptr2);
break;
case ARC_TYPE:
if (((LayerType *) ptr1)->On)
DrawArc ((LayerType *) ptr1, (ArcType *) ptr2);
break;
case TEXT_TYPE:
if (((LayerType *) ptr1)->On)
DrawText ((LayerType *) ptr1, (TextType *) ptr2);
break;
case POLYGON_TYPE:
if (((LayerType *) ptr1)->On)
DrawPolygon ((LayerType *) ptr1, (PolygonType *) ptr2);
break;
case ELEMENT_TYPE:
if (PCB->ElementOn &&
(FRONT ((ElementType *) ptr2) || PCB->InvisibleObjectsOn))
DrawElement ((ElementType *) ptr2);
break;
case RATLINE_TYPE:
if (PCB->RatOn)
DrawRat ((RatType *) ptr2);
break;
case PIN_TYPE:
if (PCB->PinOn)
DrawPin ((PinType *) ptr2);
break;
case PAD_TYPE:
if (PCB->PinOn)
DrawPad ((PadType *) ptr2);
break;
case ELEMENTNAME_TYPE:
if (PCB->ElementOn &&
(FRONT ((ElementType *) ptr2) || PCB->InvisibleObjectsOn))
DrawElementName ((ElementType *) ptr1);
break;
}
}
/* ---------------------------------------------------------------------------
* copies a via
*/
static void *
CopyVia (PinType *Via)
{
PinType *via;
via = CreateNewVia (PCB->Data, Via->X + DeltaX, Via->Y + DeltaY,
Via->Thickness, Via->Clearance, Via->Mask,
Via->DrillingHole, Via->Name,
MaskFlags (Via->Flags, NOCOPY_FLAGS));
if (!via)
return (via);
DrawVia (via);
AddObjectToCreateUndoList (VIA_TYPE, via, via, via);
return (via);
}
static int
moveline_callback (const BoxType * b, void *cl)
{
struct via_info *i = (struct via_info *) cl;
PinTypePtr via;
if ((via =
CreateNewVia (PCB->Data, i->X, i->Y,
Settings.ViaThickness, 2 * Settings.Keepaway,
NOFLAG, Settings.ViaDrillingHole, NULL,
NoFlags ())) != NULL)
{
AddObjectToCreateUndoList (VIA_TYPE, via, via, via);
DrawVia (via);
}
longjmp (i->env, 1);
}
/* ---------------------------------------------------------------------------
* moves a via
*/
static void *
MoveVia (PinTypePtr Via)
{
r_delete_entry (PCB->Data->via_tree, (BoxType *)Via);
RestoreToPolygon (PCB->Data, VIA_TYPE, 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);
if (PCB->ViaOn)
{
DrawVia (Via);
Draw ();
}
return (Via);
}
void *ChangeViaThermal( PinTypePtr Via )
{
int ecx;
int edx;
AddObjectToClearPolyUndoList( 1, (void*)Via, (void*)Via, (void*)Via, 0 );
RestoreToPolygon( &PCB->ID, 1, PCB->SilkActive == 0 ? *(int*)(PCB + 8716) + ( LayerStack[0] * 92 ) + 76 : PCB->Data + ( ( PCB->Data->LayerN + ( Settings.ShowSolderSide == 0 ) ) * 92 ) + 76, (void*)Via );
AddObjectToFlagUndoList( 1, (void*)Via, (void*)Via, (void*)Via );
if ( Delta == 0 )
{
}
else
{
}
AddObjectToClearPolyUndoList( 1, (void*)Via, (void*)Via, (void*)Via, 1 );
ClearFromPolygon( &PCB->Data, 1, PCB->Data[5].name_tree[0] + ( LayerStack[0] * 92 ) + 76, (void*)Via );
DrawVia( Via, 0 );
return (void*)Via;
}
void GVSearchListBox::DrawEntire(LPDRAWITEMSTRUCT lpdis)
{
RECT rect(lpdis->rcItem);
HPEN hpen = CreatePen(PS_SOLID, 1, RGB(255, 255, 255));
HBRUSH hbrush = CreateSolidBrush(RGB(255, 255, 255));
SelectObject(lpdis->hDC, hpen);
SelectObject(lpdis->hDC, hbrush);
Rectangle(lpdis->hDC, rect.left, rect.top, rect.right, rect.bottom);
DeleteObject(hpen);
DeleteObject(hbrush);
DrawAvatar(lpdis);
DrawMessage(lpdis);
DrawVia(lpdis);
}
void *ChangeVia2ndSize( PinTypePtr Via )
{
int eax;
int ebx;
int esi;
BDimension value = Absolute;
if ( value + -400 > 0x9894f0 || ( !( ( Via->Flags.f & 8 ) & 255 ) && Via->Thickness + -399 <= value ) || Via->DrillingHole == value )
{
}
AddObjectTo2ndSizeUndoList( 1, (void*)Via, (void*)Via, (void*)Via );
EraseVia( Via );
Via->DrillingHole = value;
if ( ( Via->Flags.f/*.1_1of4*/ & 8 ) & 255 )
{
RestoreToPolygon( &PCB->Data, 1, (void*)Via, (void*)Via );
AddObjectToSizeUndoList( 1, (void*)Via, (void*)Via, (void*)Via );
Via->Thickness = value;
ClearFromPolygon( &PCB->Data, 1, (void*)Via, (void*)Via );
}
DrawVia( Via, 0 );
return (void*)Via;
}
Boolean ChangeHole( PinTypePtr Via )
{
EraseVia( Via );
AddObjectToFlagUndoList( 1, (void*)Via, (void*)Via, (void*)Via );
Via->Flags.f ^= 8;
if ( ( (unsigned char)( Via->Flags.f ^ 8 ) & 8 ) & 255 )
{
RestoreToPolygon( &PCB->Data, 1, (void*)Via, (void*)Via );
AddObjectToSizeUndoList( 1, (void*)Via, (void*)Via, (void*)Via );
Via->Mask = Via->DrillingHole;
Via->Thickness = Via->DrillingHole;
ClearFromPolygon( &PCB->Data, 1, (void*)Via, (void*)Via );
}
else
{
AddObjectTo2ndSizeUndoList( 1, (void*)Via, (void*)Via, (void*)Via );
Via->DrillingHole = Via->Thickness + -400;
}
DrawVia( Via, 0 );
Draw( );
return 1;
}
bool
SelectObjectByName (int Type, char *Pattern, bool Flag)
{
bool changed = false;
#if defined(HAVE_REGCOMP)
#define REGEXEC(arg) (regexec_match_all(&compiled, (arg)))
int result;
regex_t compiled;
/* compile the regular expression */
result = regcomp (&compiled, Pattern, REG_EXTENDED | REG_ICASE);
if (result)
{
char errorstring[128];
regerror (result, &compiled, errorstring, 128);
Message (_("regexp error: %s\n"), errorstring);
regfree (&compiled);
return (false);
}
#else
#define REGEXEC(arg) (re_exec((arg)) == 1)
char *compiled;
/* compile the regular expression */
if ((compiled = re_comp (Pattern)) != NULL)
{
Message (_("re_comp error: %s\n"), compiled);
return (false);
}
#endif
/* loop over all visible objects with names */
if (Type & TEXT_TYPE)
ALLTEXT_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, text)
&& TEXT_IS_VISIBLE (PCB, layer, text)
&& text->TextString
&& REGEXEC (text->TextString)
&& TEST_FLAG (SELECTEDFLAG, text) != Flag)
{
AddObjectToFlagUndoList (TEXT_TYPE, layer, text, text);
ASSIGN_FLAG (SELECTEDFLAG, Flag, text);
DrawText (layer, text, 0);
changed = true;
}
}
ENDALL_LOOP;
if (PCB->ElementOn && (Type & ELEMENT_TYPE))
ELEMENT_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, element)
&& ((TEST_FLAG (ONSOLDERFLAG, element) != 0) == SWAP_IDENT
|| PCB->InvisibleObjectsOn)
&& TEST_FLAG (SELECTEDFLAG, element) != Flag)
{
String name = ELEMENT_NAME (PCB, element);
if (name && REGEXEC (name))
{
AddObjectToFlagUndoList (ELEMENT_TYPE, element, element, element);
ASSIGN_FLAG (SELECTEDFLAG, Flag, element);
PIN_LOOP (element);
{
AddObjectToFlagUndoList (PIN_TYPE, element, pin, pin);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pin);
}
END_LOOP;
PAD_LOOP (element);
{
AddObjectToFlagUndoList (PAD_TYPE, element, pad, pad);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pad);
}
END_LOOP;
ELEMENTTEXT_LOOP (element);
{
AddObjectToFlagUndoList (ELEMENTNAME_TYPE, element, text, text);
ASSIGN_FLAG (SELECTEDFLAG, Flag, text);
}
END_LOOP;
DrawElementName (element, 0);
DrawElement (element, 0);
changed = true;
}
}
}
END_LOOP;
if (PCB->PinOn && (Type & PIN_TYPE))
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);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pin);
DrawPin (pin, 0);
changed = true;
}
}
ENDALL_LOOP;
if (PCB->PinOn && (Type & PAD_TYPE))
ALLPAD_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, element)
&& ((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);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pad);
DrawPad (pad, 0);
changed = true;
}
}
ENDALL_LOOP;
if (PCB->ViaOn && (Type & VIA_TYPE))
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);
ASSIGN_FLAG (SELECTEDFLAG, Flag, via);
DrawVia (via, 0);
changed = true;
}
}
END_LOOP;
#if defined(HAVE_REGCOMP)
#if !defined(sgi)
regfree (&compiled);
#endif
#endif
if (changed)
{
IncrementUndoSerialNumber ();
Draw ();
}
return (changed);
}
/* ----------------------------------------------------------------------
* selects/unselects all objects which were found during a connection scan
* Flag determines if they are to be selected or unselected
* returns true if the state of any object has changed
*
* text objects and elements cannot be selected by this routine
*/
bool
SelectConnection (bool Flag)
{
bool changed = false;
if (PCB->RatOn)
RAT_LOOP (PCB->Data);
{
if (TEST_FLAG (FOUNDFLAG, line))
{
AddObjectToFlagUndoList (RATLINE_TYPE, line, line, line);
ASSIGN_FLAG (SELECTEDFLAG, Flag, line);
DrawRat (line, 0);
changed = true;
}
}
END_LOOP;
VISIBLELINE_LOOP (PCB->Data);
{
if (TEST_FLAG (FOUNDFLAG, line) && !TEST_FLAG (LOCKFLAG, line))
{
AddObjectToFlagUndoList (LINE_TYPE, layer, line, line);
ASSIGN_FLAG (SELECTEDFLAG, Flag, line);
DrawLine (layer, line, 0);
changed = true;
}
}
ENDALL_LOOP;
VISIBLEARC_LOOP (PCB->Data);
{
if (TEST_FLAG (FOUNDFLAG, arc) && !TEST_FLAG (LOCKFLAG, arc))
{
AddObjectToFlagUndoList (ARC_TYPE, layer, arc, arc);
ASSIGN_FLAG (SELECTEDFLAG, Flag, arc);
DrawArc (layer, arc, 0);
changed = true;
}
}
ENDALL_LOOP;
VISIBLEPOLYGON_LOOP (PCB->Data);
{
if (TEST_FLAG (FOUNDFLAG, polygon) && !TEST_FLAG (LOCKFLAG, polygon))
{
AddObjectToFlagUndoList (POLYGON_TYPE, layer, polygon, polygon);
ASSIGN_FLAG (SELECTEDFLAG, Flag, polygon);
DrawPolygon (layer, polygon, 0);
changed = true;
}
}
ENDALL_LOOP;
if (PCB->PinOn && PCB->ElementOn)
{
ALLPIN_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, element) && TEST_FLAG (FOUNDFLAG, pin))
{
AddObjectToFlagUndoList (PIN_TYPE, element, pin, pin);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pin);
DrawPin (pin, 0);
changed = true;
}
}
ENDALL_LOOP;
ALLPAD_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, element) && TEST_FLAG (FOUNDFLAG, pad))
{
AddObjectToFlagUndoList (PAD_TYPE, element, pad, pad);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pad);
DrawPad (pad, 0);
changed = true;
}
}
ENDALL_LOOP;
}
if (PCB->ViaOn)
VIA_LOOP (PCB->Data);
{
if (TEST_FLAG (FOUNDFLAG, via) && !TEST_FLAG (LOCKFLAG, via))
{
AddObjectToFlagUndoList (VIA_TYPE, via, via, via);
ASSIGN_FLAG (SELECTEDFLAG, Flag, via);
DrawVia (via, 0);
changed = true;
}
}
END_LOOP;
Draw ();
return (changed);
}
/* ----------------------------------------------------------------------
* selects/unselects all visible objects within the passed box
* Flag determines if the block is to be selected or unselected
* returns true if the state of any object has changed
*/
bool
SelectBlock (BoxTypePtr Box, bool Flag)
{
bool changed = false;
if (PCB->RatOn || !Flag)
RAT_LOOP (PCB->Data);
{
if (LINE_IN_BOX ((LineTypePtr) line, Box) &&
!TEST_FLAG (LOCKFLAG, line) && TEST_FLAG (SELECTEDFLAG, line) != Flag)
{
AddObjectToFlagUndoList (RATLINE_TYPE, line, line, line);
ASSIGN_FLAG (SELECTEDFLAG, Flag, line);
if (PCB->RatOn)
DrawRat (line, 0);
changed = true;
}
}
END_LOOP;
/* check layers */
LAYER_LOOP(PCB->Data, max_copper_layer + 2);
{
if (layer == & PCB->Data->SILKLAYER)
{
if (! (PCB->ElementOn || !Flag))
continue;
}
else if (layer == & PCB->Data->BACKSILKLAYER)
{
if (! (PCB->InvisibleObjectsOn || !Flag))
continue;
}
else
if (! (layer->On || !Flag))
continue;
LINE_LOOP (layer);
{
if (LINE_IN_BOX (line, Box)
&& !TEST_FLAG (LOCKFLAG, line)
&& TEST_FLAG (SELECTEDFLAG, line) != Flag)
{
AddObjectToFlagUndoList (LINE_TYPE, layer, line, line);
ASSIGN_FLAG (SELECTEDFLAG, Flag, line);
if (layer->On)
DrawLine (layer, line, 0);
changed = true;
}
}
END_LOOP;
ARC_LOOP (layer);
{
if (ARC_IN_BOX (arc, Box)
&& !TEST_FLAG (LOCKFLAG, arc)
&& TEST_FLAG (SELECTEDFLAG, arc) != Flag)
{
AddObjectToFlagUndoList (ARC_TYPE, layer, arc, arc);
ASSIGN_FLAG (SELECTEDFLAG, Flag, arc);
if (layer->On)
DrawArc (layer, arc, 0);
changed = true;
}
}
END_LOOP;
TEXT_LOOP (layer);
{
if (!Flag || TEXT_IS_VISIBLE(PCB, layer, text))
{
if (TEXT_IN_BOX (text, Box)
&& !TEST_FLAG (LOCKFLAG, text)
&& TEST_FLAG (SELECTEDFLAG, text) != Flag)
{
AddObjectToFlagUndoList (TEXT_TYPE, layer, text, text);
ASSIGN_FLAG (SELECTEDFLAG, Flag, text);
if (TEXT_IS_VISIBLE(PCB, layer, text))
DrawText (layer, text, 0);
changed = true;
}
}
}
END_LOOP;
POLYGON_LOOP (layer);
{
if (POLYGON_IN_BOX (polygon, Box)
&& !TEST_FLAG (LOCKFLAG, polygon)
&& TEST_FLAG (SELECTEDFLAG, polygon) != Flag)
{
AddObjectToFlagUndoList (POLYGON_TYPE, layer, polygon, polygon);
ASSIGN_FLAG (SELECTEDFLAG, Flag, polygon);
if (layer->On)
DrawPolygon (layer, polygon, 0);
changed = true;
}
}
END_LOOP;
}
END_LOOP;
/* elements */
ELEMENT_LOOP (PCB->Data);
{
{
bool gotElement = false;
if ((PCB->ElementOn || !Flag)
&& !TEST_FLAG (LOCKFLAG, element)
&& ((TEST_FLAG (ONSOLDERFLAG, element) != 0) == SWAP_IDENT
|| PCB->InvisibleObjectsOn))
{
if (BOX_IN_BOX
(&ELEMENT_TEXT (PCB, element).BoundingBox, Box)
&& !TEST_FLAG (LOCKFLAG, &ELEMENT_TEXT (PCB, element))
&& TEST_FLAG (SELECTEDFLAG,
&ELEMENT_TEXT (PCB, element)) != Flag)
{
/* select all names of element */
ELEMENTTEXT_LOOP (element);
{
AddObjectToFlagUndoList (ELEMENTNAME_TYPE,
element, text, text);
ASSIGN_FLAG (SELECTEDFLAG, Flag, text);
}
END_LOOP;
if (PCB->ElementOn)
DrawElementName (element, 0);
changed = true;
}
if ((PCB->PinOn || !Flag) && ELEMENT_IN_BOX (element, Box))
if (TEST_FLAG (SELECTEDFLAG, element) != Flag)
{
AddObjectToFlagUndoList (ELEMENT_TYPE,
element, element, element);
ASSIGN_FLAG (SELECTEDFLAG, Flag, element);
PIN_LOOP (element);
{
if (TEST_FLAG (SELECTEDFLAG, pin) != Flag)
{
AddObjectToFlagUndoList (PIN_TYPE, element, pin, pin);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pin);
if (PCB->PinOn)
DrawPin (pin, 0);
changed = true;
}
}
END_LOOP;
PAD_LOOP (element);
{
if (TEST_FLAG (SELECTEDFLAG, pad) != Flag)
{
AddObjectToFlagUndoList (PAD_TYPE, element, pad, pad);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pad);
if (PCB->PinOn)
DrawPad (pad, 0);
changed = true;
}
}
END_LOOP;
if (PCB->PinOn)
DrawElement (element, 0);
changed = true;
gotElement = true;
}
}
if ((PCB->PinOn || !Flag) && !TEST_FLAG (LOCKFLAG, element) && !gotElement)
{
PIN_LOOP (element);
{
if ((VIA_OR_PIN_IN_BOX (pin, Box)
&& TEST_FLAG (SELECTEDFLAG, pin) != Flag))
{
AddObjectToFlagUndoList (PIN_TYPE, element, pin, pin);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pin);
if (PCB->PinOn)
DrawPin (pin, 0);
changed = true;
}
}
END_LOOP;
PAD_LOOP (element);
{
if (PAD_IN_BOX (pad, Box)
&& TEST_FLAG (SELECTEDFLAG, pad) != Flag)
{
AddObjectToFlagUndoList (PAD_TYPE, element, pad, pad);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pad);
if (PCB->PinOn)
DrawPad (pad, 0);
changed = true;
}
}
END_LOOP;
}
}
}
END_LOOP;
/* end with vias */
if (PCB->ViaOn || !Flag)
VIA_LOOP (PCB->Data);
{
if (VIA_OR_PIN_IN_BOX (via, Box)
&& !TEST_FLAG (LOCKFLAG, via)
&& TEST_FLAG (SELECTEDFLAG, via) != Flag)
{
AddObjectToFlagUndoList (VIA_TYPE, via, via, via);
ASSIGN_FLAG (SELECTEDFLAG, Flag, via);
if (PCB->ViaOn)
DrawVia (via, 0);
changed = true;
}
}
END_LOOP;
if (changed)
{
Draw ();
IncrementUndoSerialNumber ();
}
return (changed);
}
/* ---------------------------------------------------------------------------
* toggles the selection of any kind of object
* the different types are defined by search.h
*/
bool
SelectObject (void)
{
void *ptr1, *ptr2, *ptr3;
LayerTypePtr layer;
int type;
bool changed = true;
type = SearchScreen (Crosshair.X, Crosshair.Y, SELECT_TYPES,
&ptr1, &ptr2, &ptr3);
if (type == NO_TYPE || TEST_FLAG (LOCKFLAG, (PinTypePtr) ptr2))
return (false);
switch (type)
{
case VIA_TYPE:
AddObjectToFlagUndoList (VIA_TYPE, ptr1, ptr1, ptr1);
TOGGLE_FLAG (SELECTEDFLAG, (PinTypePtr) ptr1);
DrawVia ((PinTypePtr) ptr1, 0);
break;
case LINE_TYPE:
{
LineType *line = (LineTypePtr) ptr2;
layer = (LayerTypePtr) ptr1;
AddObjectToFlagUndoList (LINE_TYPE, ptr1, ptr2, ptr2);
TOGGLE_FLAG (SELECTEDFLAG, line);
DrawLine (layer, line, 0);
break;
}
case RATLINE_TYPE:
{
RatTypePtr rat = (RatTypePtr) ptr2;
AddObjectToFlagUndoList (RATLINE_TYPE, ptr1, ptr1, ptr1);
TOGGLE_FLAG (SELECTEDFLAG, rat);
DrawRat (rat, 0);
break;
}
case ARC_TYPE:
{
ArcType *arc = (ArcTypePtr) ptr2;
layer = (LayerTypePtr) ptr1;
AddObjectToFlagUndoList (ARC_TYPE, ptr1, ptr2, ptr2);
TOGGLE_FLAG (SELECTEDFLAG, arc);
DrawArc (layer, arc, 0);
break;
}
case TEXT_TYPE:
{
TextType *text = (TextTypePtr) ptr2;
layer = (LayerTypePtr) ptr1;
AddObjectToFlagUndoList (TEXT_TYPE, ptr1, ptr2, ptr2);
TOGGLE_FLAG (SELECTEDFLAG, text);
DrawText (layer, text, 0);
break;
}
case POLYGON_TYPE:
{
PolygonType *poly = (PolygonTypePtr) ptr2;
layer = (LayerTypePtr) ptr1;
AddObjectToFlagUndoList (POLYGON_TYPE, ptr1, ptr2, ptr2);
TOGGLE_FLAG (SELECTEDFLAG, poly);
DrawPolygon (layer, poly, 0);
/* changing memory order no longer effects draw order */
break;
}
case PIN_TYPE:
AddObjectToFlagUndoList (PIN_TYPE, ptr1, ptr2, ptr2);
TOGGLE_FLAG (SELECTEDFLAG, (PinTypePtr) ptr2);
DrawPin ((PinTypePtr) ptr2, 0);
break;
case PAD_TYPE:
AddObjectToFlagUndoList (PAD_TYPE, ptr1, ptr2, ptr2);
TOGGLE_FLAG (SELECTEDFLAG, (PadTypePtr) ptr2);
DrawPad ((PadTypePtr) ptr2, 0);
break;
case ELEMENTNAME_TYPE:
{
ElementTypePtr element = (ElementTypePtr) ptr1;
/* select all names of the element */
ELEMENTTEXT_LOOP (element);
{
AddObjectToFlagUndoList (ELEMENTNAME_TYPE, element, text, text);
TOGGLE_FLAG (SELECTEDFLAG, text);
}
END_LOOP;
DrawElementName (element, 0);
break;
}
case ELEMENT_TYPE:
{
ElementTypePtr element = (ElementTypePtr) ptr1;
/* select all pins and names of the element */
PIN_LOOP (element);
{
AddObjectToFlagUndoList (PIN_TYPE, element, pin, pin);
TOGGLE_FLAG (SELECTEDFLAG, pin);
}
END_LOOP;
PAD_LOOP (element);
{
AddObjectToFlagUndoList (PAD_TYPE, element, pad, pad);
TOGGLE_FLAG (SELECTEDFLAG, pad);
}
END_LOOP;
ELEMENTTEXT_LOOP (element);
{
AddObjectToFlagUndoList (ELEMENTNAME_TYPE, element, text, text);
TOGGLE_FLAG (SELECTEDFLAG, text);
}
END_LOOP;
AddObjectToFlagUndoList (ELEMENT_TYPE, element, element, element);
TOGGLE_FLAG (SELECTEDFLAG, element);
if (PCB->ElementOn &&
((TEST_FLAG (ONSOLDERFLAG, element) != 0) == SWAP_IDENT ||
PCB->InvisibleObjectsOn))
if (PCB->ElementOn)
{
DrawElementName (element, 0);
DrawElementPackage (element, 0);
}
if (PCB->PinOn)
DrawElementPinsAndPads (element, 0);
break;
}
}
Draw ();
IncrementUndoSerialNumber ();
return (changed);
}
