//-----------------------------------------------------------------------------
// Purpose: This blob has too few elements. Add this many elements by stacking
// them on top of existing elements and allowing them to disperse themselves
// into the blob.
//-----------------------------------------------------------------------------
void CNPC_Blob::AddNewElements( int iNumElements )
{
int i;
// Keep track of how many elements we had when we came into this function.
// Since the new elements copy their origins from existing elements, we only want
// to copy origins from elements that existed before we came into this function.
// Otherwise, the more elements we create while in this function, the more likely it
// becomes that several of them will stack on the same origin.
int iInitialElements = m_iNumElements;
for( i = 0 ; i < iNumElements ; i++ )
{
CBlobElement *pElement = CreateNewElement();
if( pElement != NULL )
{
// Copy the origin of some element that is not me. This will make the expansion
// of the group easier on the eye, since this element will spawn inside of some
// other element, and then be pushed out by the blob's repel rules.
int iCopyElement = random->RandomInt( 0, iInitialElements - 1 );
pElement->SetAbsOrigin( m_Elements[iCopyElement]->GetAbsOrigin() );
}
}
}
//-----------------------------------------------------------------------------
// Create, initialize, and distribute all blob elements
//-----------------------------------------------------------------------------
void CNPC_Blob::InitializeElements()
{
// Squirt all of the elements out into a circle
int i;
QAngle angDistributor( 0, 0, 0 );
int iNumElements = blob_numelements.GetInt();
float step = 360.0f / ((float)iNumElements);
for( i = 0 ; i < iNumElements ; i++ )
{
Vector vecDir;
Vector vecDest;
AngleVectors( angDistributor, &vecDir, NULL, NULL );
vecDest = WorldSpaceCenter() + vecDir * 64.0f;
CBlobElement *pElement = CreateNewElement();
if( !pElement )
{
Msg("Blob could not create all elements!!\n");
return;
}
trace_t tr;
UTIL_TraceLine( vecDest, vecDest + Vector (0, 0, MIN_COORD_FLOAT), MASK_SHOT, pElement, COLLISION_GROUP_NONE, &tr );
pElement->SetAbsOrigin( tr.endpos + Vector( 0, 0, 1 ) );
angDistributor.y += step;
}
CBaseEntity *pEntity = gEntList.FindEntityByClassname( NULL, "info_target" );
for( i = 0 ; i < BLOB_MAX_AVOID_ORIGINS ; i++ )
{
if( pEntity )
{
if( pEntity->NameMatches("avoid") )
{
m_vecAvoidOrigin[ i ] = pEntity->GetAbsOrigin();
m_flAvoidRadiusSqr = Square( 120.0f );
m_iNumAvoidOrigins++;
}
pEntity = gEntList.FindEntityByClassname( pEntity, "info_target" );
}
else
{
break;
}
}
Msg("%d avoid origins\n", m_iNumAvoidOrigins );
RecomputeIdealElementDist();
}
//~~ wxFileName CreateCopy(wxFileName parentPath) [AdeAttribute] ~~
wxFileName aFileName = CreateNewElement(parentPath);
wxFileConfig theConfig(wxEmptyString,wxEmptyString,aFileName.GetFullPath());
wxString suffix;
if (aFileName.GetPath() == myFileName.GetPath())
suffix = wxS("_copied");
theConfig.Write(wxS("Astade/Name"), myConfig->Read(wxS("Astade/Name")) + suffix);
theConfig.Write(wxS("Astade/Type"), myConfig->Read(wxS("Astade/Type")));
theConfig.Write(wxS("Astade/CodingType"), myConfig->Read(wxS("Astade/CodingType")));
theConfig.Write(wxS("Astade/Description"), myConfig->Read(wxS("Astade/Description")));
theConfig.Write(wxS("Astade/Static"), myConfig->Read(wxS("Astade/Static")));
theConfig.Write(wxS("Astade/Const"), myConfig->Read(wxS("Astade/Const")));
theConfig.Write(wxS("Astade/Default"), myConfig->Read(wxS("Astade/Default")));
AdeRevisionControlBase* theRevisionControl = AdeRevisionControlBase::GetRevisionControlObject(); //additional code for version control.
if (theRevisionControl->IsAddSupported())
theRevisionControl->Add(aFileName);
return aFileName;
void Account::OpenFile(QString filename)
{
qDebug() << "Opening account...";
GetAccountWidget()->UnselectAll();
m_list.clear();
QDomDocument doc("AccountManagerFile");
QFile file(filename);
if (!file.open(QIODevice::ReadOnly))
return;
if (!doc.setContent(&file))
{
file.close();
QMessageBox::critical(0, "Erreur", "Impossible d'ouvrir le fichier car ce n'est pas un format compatible avec Account Manager.");
return;
}
file.close();
QDomElement root = doc.documentElement();
if(root.isNull() || root.tagName() != "AccountManagerFile")
{
//Incorrect file
QMessageBox::critical(0, "Erreur", "Impossible d'ouvrir le fichier car ce n'est pas un format compatible avec Account Manager.");
return;
}
QDomElement infoEle = root.firstChildElement("Info");
{
QDomElement accEle = infoEle.firstChildElement("Account");
SetName(accEle.attribute("name", "Compte"));
QDomElement verEle = infoEle.firstChildElement("Version");
qDebug() << " File engine version : " << Version::LoadVersionInfo(verEle);
qDebug() << " Current Engine : " << Version::GetEngineVersion();
}
QDomElement setEle = root.firstChildElement("Settings");
GetAccountOptions()->OpenFile(setEle, doc);
QDomElement uiEle = root.firstChildElement("UI");
GetAccountWidget()->GetAccountSettings()->OpenFile(uiEle, doc);
qDebug() << " Begin loading elements...";
QDomElement elementsEle = root.firstChildElement("Elements");
QDomNode elementNode = elementsEle.firstChild();
while(!elementNode.isNull())
{
QDomElement elementEle = elementNode.toElement();
if(!elementEle.isNull())
{
CreateNewElement(elementEle.tagName(), m_list.size(), false);
m_list.at(m_list.size() - 1)->OpenFile(elementEle, doc);
}
elementNode = elementNode.nextSibling();
}
qDebug() << " Loaded elements.";
GetAccountWidget()->update();
RequestBackgroundCalculator();
SetLastPath(filename);
qDebug() << "Opened.";
}
/* ---------------------------------------------------------------------------
* 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);
}
/*---------------------------------------------------------------------------
*
* convert buffer contents into an element
*/
bool
ConvertBufferToElement (BufferType *Buffer)
{
ElementType *Element;
Cardinal group;
Cardinal pin_n = 1;
bool hasParts = false, crooked = false;
int onsolder;
bool warned = false;
if (Buffer->Data->pcb == 0)
Buffer->Data->pcb = PCB;
Element = CreateNewElement (PCB->Data, &PCB->Font, NoFlags (),
NULL, NULL, NULL, PASTEBUFFER->X,
PASTEBUFFER->Y, 0, 100,
MakeFlags (SWAP_IDENT ? ONSOLDERFLAG : NOFLAG),
false);
if (!Element)
return (false);
VIA_LOOP (Buffer->Data);
{
char num[8];
if (via->Mask < via->Thickness)
via->Mask = via->Thickness + 2 * MASKFRAME;
if (via->Name)
CreateNewPin (Element, via->X, via->Y, via->Thickness,
via->Clearance, via->Mask, via->DrillingHole,
NULL, via->Name, MaskFlags (via->Flags,
VIAFLAG | NOCOPY_FLAGS |
SELECTEDFLAG | WARNFLAG));
else
{
sprintf (num, "%d", pin_n++);
CreateNewPin (Element, via->X, via->Y, via->Thickness,
via->Clearance, via->Mask, via->DrillingHole,
NULL, num, MaskFlags (via->Flags,
VIAFLAG | NOCOPY_FLAGS | SELECTEDFLAG
| WARNFLAG));
}
hasParts = true;
}
END_LOOP;
for (onsolder = 0; onsolder < 2; onsolder ++)
{
int silk_layer;
int onsolderflag;
if ((!onsolder) == (!SWAP_IDENT))
{
silk_layer = component_silk_layer;
onsolderflag = NOFLAG;
}
else
{
silk_layer = solder_silk_layer;
onsolderflag = ONSOLDERFLAG;
}
#define MAYBE_WARN() \
if (onsolder && !hasParts && !warned) \
{ \
warned = true; \
Message \
(_("Warning: All of the pads are on the opposite\n" \
"side from the component - that's probably not what\n" \
"you wanted\n")); \
} \
/* get the component-side SM pads */
group = GetLayerGroupNumberByNumber (silk_layer);
GROUP_LOOP (Buffer->Data, group);
{
char num[8];
LINE_LOOP (layer);
{
sprintf (num, "%d", pin_n++);
CreateNewPad (Element, line->Point1.X,
line->Point1.Y, line->Point2.X,
line->Point2.Y, line->Thickness,
line->Clearance,
line->Thickness + line->Clearance, NULL,
line->Number ? line->Number : num,
MakeFlags (onsolderflag));
MAYBE_WARN();
hasParts = true;
}
END_LOOP;
POLYGON_LOOP (layer);
{
Coord x1, y1, x2, y2, w, h, t;
if (! polygon_is_rectangle (polygon))
{
crooked = true;
continue;
}
w = polygon->Points[2].X - polygon->Points[0].X;
h = polygon->Points[1].Y - polygon->Points[0].Y;
t = (w < h) ? w : h;
x1 = polygon->Points[0].X + t/2;
y1 = polygon->Points[0].Y + t/2;
x2 = x1 + (w-t);
y2 = y1 + (h-t);
sprintf (num, "%d", pin_n++);
CreateNewPad (Element,
x1, y1, x2, y2, t,
2 * Settings.Keepaway,
t + Settings.Keepaway,
NULL, num,
MakeFlags (SQUAREFLAG | onsolderflag));
MAYBE_WARN();
hasParts = true;
}
END_LOOP;
}
END_LOOP;
}
/* now add the silkscreen. NOTE: elements must have pads or pins too */
LINE_LOOP (&Buffer->Data->SILKLAYER);
{
if (line->Number && !NAMEONPCB_NAME (Element))
NAMEONPCB_NAME (Element) = strdup (line->Number);
CreateNewLineInElement (Element, line->Point1.X,
line->Point1.Y, line->Point2.X,
line->Point2.Y, line->Thickness);
hasParts = true;
}
END_LOOP;
ARC_LOOP (&Buffer->Data->SILKLAYER);
{
CreateNewArcInElement (Element, arc->X, arc->Y, arc->Width,
arc->Height, arc->StartAngle, arc->Delta,
arc->Thickness);
hasParts = true;
}
END_LOOP;
if (!hasParts)
{
DestroyObject (PCB->Data, ELEMENT_TYPE, Element, Element, Element);
Message (_("There was nothing to convert!\n"
"Elements must have some silk, pads or pins.\n"));
return (false);
}
if (crooked)
Message (_("There were polygons that can't be made into pins!\n"
"So they were not included in the element\n"));
Element->MarkX = Buffer->X;
Element->MarkY = Buffer->Y;
if (SWAP_IDENT)
SET_FLAG (ONSOLDERFLAG, Element);
SetElementBoundingBox (PCB->Data, Element, &PCB->Font);
ClearBuffer (Buffer);
MoveObjectToBuffer (Buffer->Data, PCB->Data, ELEMENT_TYPE, Element, Element,
Element);
SetBufferBoundingBox (Buffer);
return (true);
}
