/**
* Slightly optimized drawing for polylines.
*/
void RS_Polyline::draw(RS_Painter* painter,RS_GraphicView* view, double& /*patternOffset*/) {
if (view==NULL) {
return;
}
// draw first entity and set correct pen:
RS_Entity* e = firstEntity(RS2::ResolveNone);
// We get the pen from the entitycontainer and apply it to the
// first line so that subsequent line are draw in the right color
//prevent segfault if polyline is empty
if (e != NULL) {
RS_Pen p=this->getPen(true);
e->setPen(p);
double patternOffset=0.;
view->drawEntity(painter, e, patternOffset);
e = nextEntity(RS2::ResolveNone);
while(e!=NULL) {
view->drawEntityPlain(painter, e, patternOffset);
e = nextEntity(RS2::ResolveNone);
//RS_DEBUG->print("offset: %f\nlength was: %f", offset, e->getLength());
}
}
}
/**
* Slightly optimized drawing for polylines.
*/
void RS_Polyline::draw(RS_Painter* painter,RS_GraphicView* view,
double /*patternOffset*/) {
if (view==NULL) {
return;
}
// draw first entity and set correct pen:
RS_Entity* e = firstEntity(RS2::ResolveNone);
// We get the pen from the entitycontainer and apply it to the
// first line so that subsequent line are draw in the right color
RS_Pen p=this->getPen(true);
//prevent segfault if polyline is empty
if (e != NULL) {
e->setPen(p);
view->drawEntity(painter, e);
// draw subsequent entities with same pen:
for (RS_Entity* e=nextEntity(RS2::ResolveNone);
e!=NULL;
e = nextEntity(RS2::ResolveNone)) {
view->drawEntityPlain(painter, e);
}
}
}
/**
* Returns the next entity or container or \p NULL if the last entity
* returned by \p next() was the last entity in the container.
*/
RS_Entity* RS_EntityContainer::nextEntity(RS2::ResolveLevel level) {
switch (level) {
case RS2::ResolveNone:
return entities.next();
break;
case RS2::ResolveAllButInserts: {
RS_Entity* e=NULL;
if (subContainer!=NULL) {
e = subContainer->nextEntity(level);
if (e!=NULL) {
return e;
} else {
e = entities.next();
}
} else {
e = entities.next();
}
if (e!=NULL && e->isContainer() && e->rtti()!=RS2::EntityInsert) {
subContainer = (RS_EntityContainer*)e;
e = ((RS_EntityContainer*)e)->firstEntity(level);
// emtpy container:
if (e==NULL) {
subContainer = NULL;
e = nextEntity(level);
}
}
return e;
}
break;
case RS2::ResolveAll: {
RS_Entity* e=NULL;
if (subContainer!=NULL) {
e = subContainer->nextEntity(level);
if (e!=NULL) {
return e;
} else {
e = entities.next();
}
} else {
e = entities.next();
}
if (e!=NULL && e->isContainer()) {
subContainer = (RS_EntityContainer*)e;
e = ((RS_EntityContainer*)e)->firstEntity(level);
// emtpy container:
if (e==NULL) {
subContainer = NULL;
e = nextEntity(level);
}
}
return e;
}
break;
}
return NULL;
}
/**
* Returns the first entity or NULL if this graphic is empty.
* @param level
*/
RS_Entity* RS_EntityContainer::firstEntity(RS2::ResolveLevel level) {
RS_Entity* e = NULL;
entIdx = -1;
switch (level) {
case RS2::ResolveNone:
if (!entities.isEmpty()) {
entIdx = 0;
return entities.first();
}
break;
case RS2::ResolveAllButInserts: {
subContainer=NULL;
if (!entities.isEmpty()) {
entIdx = 0;
e = entities.first();
}
if (e!=NULL && e->isContainer() && e->rtti()!=RS2::EntityInsert) {
subContainer = (RS_EntityContainer*)e;
e = ((RS_EntityContainer*)e)->firstEntity(level);
// emtpy container:
if (e==NULL) {
subContainer = NULL;
e = nextEntity(level);
}
}
return e;
}
break;
case RS2::ResolveAll: {
subContainer=NULL;
if (!entities.isEmpty()) {
entIdx = 0;
e = entities.first();
}
if (e!=NULL && e->isContainer()) {
subContainer = (RS_EntityContainer*)e;
e = ((RS_EntityContainer*)e)->firstEntity(level);
// emtpy container:
if (e==NULL) {
subContainer = NULL;
e = nextEntity(level);
}
}
return e;
}
break;
}
return NULL;
}
/**
* @return The point which is closest to 'coord'
* (one of the vertexes)
*/
RS_Vector RS_EntityContainer::getNearestEndpoint(const RS_Vector& coord,
double* dist) {
double minDist = RS_MAXDOUBLE; // minimum measured distance
double curDist; // currently measured distance
RS_Vector closestPoint(false); // closest found endpoint
RS_Vector point; // endpoint found
//RS_PtrListIterator<RS_Entity> it = createIterator();
//RS_Entity* en;
//while ( (en = it.current()) != NULL ) {
// ++it;
for (RS_Entity* en = firstEntity();
en != NULL;
en = nextEntity()) {
if (en->isVisible()) {
point = en->getNearestEndpoint(coord, &curDist);
if (point.valid && curDist<minDist) {
closestPoint = point;
minDist = curDist;
if (dist!=NULL) {
*dist = curDist;
}
}
}
}
return closestPoint;
}
/**
* Implementation of update. Updates the arrow.
*/
void RS_Leader::update() {
// find and delete arrow:
for (RS_Entity* e=firstEntity(); e!=NULL; e=nextEntity()) {
if (e->rtti()==RS2::EntitySolid) {
removeEntity(e);
break;
}
}
if (isUndone()) {
return;
}
RS_Entity* fe = firstEntity();
if (fe!=NULL && fe->isAtomic()) {
RS_Vector p1 = ((RS_AtomicEntity*)fe)->getStartpoint();
RS_Vector p2 = ((RS_AtomicEntity*)fe)->getEndpoint();
// first entity must be the line which gets the arrow:
if (hasArrowHead()) {
RS_Solid* s = new RS_Solid(this, RS_SolidData());
s->shapeArrow(p1,
p2.angleTo(p1),
getGraphicVariableDouble("$DIMASZ", 2.5)* getGraphicVariableDouble("$DIMSCALE", 1.0));
s->setPen(RS_Pen(RS2::FlagInvalid));
s->setLayer(NULL);
RS_EntityContainer::addEntity(s);
}
}
calculateBorders();
}
RS_Vector RS_EntityContainer::getNearestSelectedRef(const RS_Vector& coord,
double* dist) {
double minDist = RS_MAXDOUBLE; // minimum measured distance
double curDist; // currently measured distance
RS_Vector closestPoint(false); // closest found endpoint
RS_Vector point; // endpoint found
for (RS_Entity* en = firstEntity();
en != NULL;
en = nextEntity()) {
if (en->isVisible() && en->isSelected() && !en->isParentSelected()) {
point = en->getNearestSelectedRef(coord, &curDist);
if (point.valid && curDist<minDist) {
closestPoint = point;
minDist = curDist;
if (dist!=NULL) {
*dist = curDist;
}
}
}
}
return closestPoint;
}
/**
* Detaches shallow copies and creates deep copies of all subentities.
* This is called after cloning entity containers.
*/
void RS_EntityContainer::detach() {
QList<RS_Entity*> tmp;
bool autoDel = isOwner();
RS_DEBUG->print("RS_EntityContainer::detach: autoDel: %d",
(int)autoDel);
setOwner(false);
// make deep copies of all entities:
for (RS_Entity* e=firstEntity();
e!=NULL;
e=nextEntity()) {
if (!e->getFlag(RS2::FlagTemp)) {
tmp.append(e->clone());
}
}
// clear shared pointers:
entities.clear();
setOwner(autoDel);
// point to new deep copies:
for (int i = 0; i < tmp.size(); ++i) {
RS_Entity* e = tmp.at(i);
entities.append(e);
e->reparent(this);
}
}
/**
* Detaches shallow copies and creates deep copies of all subentities.
* This is called after cloning entity containers.
*/
void RS_EntityContainer::detach() {
RS_PtrList<RS_Entity> tmp;
bool autoDel = entities.autoDelete();
entities.setAutoDelete(false);
// make deep copies of all entities:
for (RS_Entity* e=firstEntity();
e!=NULL;
e=nextEntity()) {
if (!e->getFlag(RS2::FlagTemp)) {
tmp.append(e->clone());
}
}
// clear shared pointers:
entities.clear();
entities.setAutoDelete(autoDel);
// point to new deep copies:
for (RS_Entity* e=tmp.first();
e!=NULL;
e=tmp.next()) {
entities.append(e);
e->reparent(this);
}
}
void RS_EntityContainer::mirror(RS_Vector axisPoint1, RS_Vector axisPoint2) {
if (axisPoint1.distanceTo(axisPoint2)>1.0e-6) {
for (RS_Entity* e=firstEntity(RS2::ResolveNone);
e!=NULL;
e=nextEntity(RS2::ResolveNone)) {
e->mirror(axisPoint1, axisPoint2);
}
}
}
/**
* Selects all entities within the given area.
*
* @param select True to select, False to deselect the entities.
*/
void RS_EntityContainer::selectWindow(RS_Vector v1, RS_Vector v2,
bool select, bool cross) {
bool included;
for (RS_Entity* e=firstEntity(RS2::ResolveNone);
e!=NULL;
e=nextEntity(RS2::ResolveNone)) {
included = false;
if (e->isVisible()) {
if (e->isInWindow(v1, v2)) {
//e->setSelected(select);
included = true;
} else if (cross==true) {
RS_Line l[] =
{
RS_Line(NULL, RS_LineData(v1, RS_Vector(v2.x, v1.y))),
RS_Line(NULL, RS_LineData(RS_Vector(v2.x, v1.y), v2)),
RS_Line(NULL, RS_LineData(v2, RS_Vector(v1.x, v2.y))),
RS_Line(NULL, RS_LineData(RS_Vector(v1.x, v2.y), v1))
};
RS_VectorSolutions sol;
if (e->isContainer()) {
RS_EntityContainer* ec = (RS_EntityContainer*)e;
for (RS_Entity* se=ec->firstEntity(RS2::ResolveAll);
se!=NULL && included==false;
se=ec->nextEntity(RS2::ResolveAll)) {
for (int i=0; i<4; ++i) {
sol = RS_Information::getIntersection(
se, &l[i], true);
if (sol.hasValid()) {
included = true;
break;
}
}
}
} else {
for (int i=0; i<4; ++i) {
sol = RS_Information::getIntersection(e, &l[i], true);
if (sol.hasValid()) {
included = true;
break;
}
}
}
}
}
if (included) {
e->setSelected(select);
}
}
}
/**
* Slightly optimized drawing for polylines.
*/
void RS_Polyline::draw(RS_Painter* painter, RS_GraphicView* view,
double /*patternOffset*/) {
if (painter==NULL || view==NULL) {
return;
}
// draw first entity and set correct pen:
RS_Entity* e = firstEntity(RS2::ResolveNone);
view->drawEntity(e);
// draw subsequent entities with same pen:
for (RS_Entity* e=nextEntity(RS2::ResolveNone);
e!=NULL;
e = nextEntity(RS2::ResolveNone)) {
view->drawEntityPlain(e);
}
}
void RS_EntityContainer::move(RS_Vector offset) {
for (RS_Entity* e=firstEntity(RS2::ResolveNone);
e!=NULL;
e=nextEntity(RS2::ResolveNone)) {
e->move(offset);
}
if (autoUpdateBorders) {
calculateBorders();
}
}
void RS_EntityContainer::reparent(RS_EntityContainer* parent) {
RS_Entity::reparent(parent);
// All sub-entities:
for (RS_Entity* e=firstEntity(RS2::ResolveNone);
e!=NULL;
e=nextEntity(RS2::ResolveNone)) {
e->reparent(parent);
}
}
void RS_EntityContainer::rotate(RS_Vector center, double angle) {
for (RS_Entity* e=firstEntity(RS2::ResolveNone);
e!=NULL;
e=nextEntity(RS2::ResolveNone)) {
e->rotate(center, angle);
}
if (autoUpdateBorders) {
calculateBorders();
}
}
/**
* Counts all entities (leaves of the tree).
*/
unsigned long int RS_EntityContainer::countDeep() {
unsigned long int c=0;
for (RS_Entity* t=firstEntity(RS2::ResolveNone);
t!=NULL;
t=nextEntity(RS2::ResolveNone)) {
c+=t->countDeep();
}
return c;
}
bool RS_EntityContainer::hasEndpointsWithinWindow(RS_Vector v1, RS_Vector v2) {
for (RS_Entity* e=firstEntity(RS2::ResolveNone);
e!=NULL;
e=nextEntity(RS2::ResolveNone)) {
if (e->hasEndpointsWithinWindow(v1, v2)) {
return true;
}
}
return false;
}
void discardTag(const char *tagname, FILE *in)
{
char entity[WORD_SIZE];
int istag;
while((istag = nextEntity(entity, in)) != -1)
{
if(istag == 1 && strcmp(tagname, entity) == 0)
break;
}
}
void RS_EntityContainer::scale(RS_Vector center, RS_Vector factor) {
if (fabs(factor.x)>RS_TOLERANCE && fabs(factor.y)>RS_TOLERANCE) {
for (RS_Entity* e=firstEntity(RS2::ResolveNone);
e!=NULL;
e=nextEntity(RS2::ResolveNone)) {
e->scale(center, factor);
}
}
if (autoUpdateBorders) {
calculateBorders();
}
}
void RS_EntityContainer::setVisible(bool v) {
RS_DEBUG->print("RS_EntityContainer::setVisible: %d", v);
RS_Entity::setVisible(v);
// All sub-entities:
for (RS_Entity* e=firstEntity(RS2::ResolveNone);
e!=NULL;
e=nextEntity(RS2::ResolveNone)) {
RS_DEBUG->print("RS_EntityContainer::setVisible: subentity: %d", v);
e->setVisible(v);
}
}
void RS_EntityContainer::moveSelectedRef(const RS_Vector& ref,
const RS_Vector& offset) {
for (RS_Entity* e=firstEntity(RS2::ResolveNone);
e!=NULL;
e=nextEntity(RS2::ResolveNone)) {
e->moveSelectedRef(ref, offset);
}
if (autoUpdateBorders) {
calculateBorders();
}
}
void RS_ActionBlocksSave::trigger() {
RS_DEBUG->print("save block to file");
QC_ApplicationWindow* appWindow = QC_ApplicationWindow::getAppWindow();
if(!appWindow) {
finish(false);
return;
}
RS_BlockList* bList = appWindow->getBlockWidget() -> getBlockList();
if (bList) {
auto b=bList->getActive();
if(b) {
RS_Graphic g(nullptr);
g.setOwner(false);
g.clearLayers();
// g.addLayer(b->getLayer());
for (RS_Entity* e=b->firstEntity(RS2::ResolveNone);
e;
e = b->nextEntity(RS2::ResolveNone)) {
g.addEntity(e);
if (e->rtti() == RS2::EntityInsert) {
RS_Insert *in = static_cast<RS_Insert *>(e);
g.addBlock(in->getBlockForInsert());
addBlock(in,&g);
}
// std::cout<<__FILE__<<" : "<<__func__<<" : line: "<<__LINE__<<" : "<<e->rtti()<<std::endl;
// g.addLayer(e->getLayer());
// std::cout<<__FILE__<<" : "<<__func__<<" : line: "<<__LINE__<<" : "<<e->rtti()<<std::endl;
}
// std::cout<<__FILE__<<" : "<<__func__<<" : line: "<<__LINE__<<std::endl;
// std::cout<<"add layer name="<<qPrintable(b->getLayer()->getName())<<std::endl;
RS2::FormatType t = RS2::FormatDXFRW;
QG_FileDialog dlg(appWindow->getMDIWindow(),0, QG_FileDialog::BlockFile);
QString const& fn = dlg.getSaveFile(&t);
QApplication::setOverrideCursor( QCursor(Qt::WaitCursor) );
// g.setModified(true);
g.saveAs(fn, t);
QApplication::restoreOverrideCursor();
} else {
if (RS_DIALOGFACTORY) {
RS_DIALOGFACTORY->commandMessage(tr("No block activated to save"));
}
}
} else {
RS_DEBUG->print(RS_Debug::D_WARNING,
"RS_ActionBlocksSave::trigger(): blockList is NULL");
}
finish(false);
}
void RS_Spline::draw(RS_Painter* painter, RS_GraphicView* view, double& /*patternOffset*/) {
if (painter==nullptr || view==nullptr) {
return;
}
RS_Entity* e=firstEntity(RS2::ResolveNone);
if (e) {
RS_Pen p=this->getPen(true);
e->setPen(p);
double patternOffset(0.0);
view->drawEntity(painter, e, patternOffset);
//RS_DEBUG->print("offset: %f\nlength was: %f", offset, e->getLength());
e = nextEntity(RS2::ResolveNone);
while(e) {
view->drawEntityPlain(painter, e, patternOffset);
e = nextEntity(RS2::ResolveNone);
//RS_DEBUG->print("offset: %f\nlength was: %f", offset, e->getLength());
}
}
}
void RS_EntityContainer::draw(RS_Painter* painter, RS_GraphicView* view,
double /*patternOffset*/) {
if (painter==NULL || view==NULL) {
return;
}
for (RS_Entity* e=firstEntity(RS2::ResolveNone);
e!=NULL;
e = nextEntity(RS2::ResolveNone)) {
view->drawEntity(e);
}
}
/**
* Counts the selected entities in this container.
*/
unsigned long int RS_EntityContainer::countSelected() {
unsigned long int c=0;
for (RS_Entity* t=firstEntity(RS2::ResolveNone);
t!=NULL;
t=nextEntity(RS2::ResolveNone)) {
if (t->isSelected()) {
c++;
}
}
return c;
}
RS_VectorSolutions RS_Polyline::getRefPoints() {
RS_VectorSolutions ret({data.startpoint});
for (RS_Entity* e=firstEntity(RS2::ResolveNone);
e!=NULL;
e = nextEntity(RS2::ResolveNone)) {
if (e->isAtomic()) {
ret.push_back(((RS_AtomicEntity*)e)->getEndpoint());
}
}
ret.push_back( data.endpoint);
return ret;
}
/**
* Validates the hatch.
*/
bool RS_Hatch::validate() {
bool ret = true;
// loops:
for (RS_Entity* l=firstEntity(RS2::ResolveNone);
l!=NULL;
l=nextEntity(RS2::ResolveNone)) {
if (l->rtti()==RS2::EntityContainer) {
RS_EntityContainer* loop = (RS_EntityContainer*)l;
ret = loop->optimizeContours() && ret;
}
}
return ret;
}
/**
* Selects this entity.
*/
bool RS_EntityContainer::setSelected(bool select) {
// This entity's select:
if (RS_Entity::setSelected(select)) {
// All sub-entity's select:
for (RS_Entity* e=firstEntity(RS2::ResolveNone);
e!=NULL;
e=nextEntity(RS2::ResolveNone)) {
if (e->isVisible()) {
e->setSelected(select);
}
}
return true;
} else {
return false;
}
}
/**
* Counts the entities on the given layer.
*/
unsigned long int RS_Graphic::countLayerEntities(RS_Layer* layer) {
int c=0;
if (layer!=NULL) {
for (RS_Entity* t=firstEntity(RS2::ResolveNone);
t!=NULL;
t=nextEntity(RS2::ResolveNone)) {
if (t->getLayer()!=NULL &&
t->getLayer()->getName()==layer->getName()) {
c+=t->countDeep();
}
}
}
return c;
}
/**
* Recalculates the borders of this entity container.
*/
void RS_EntityContainer::calculateBorders() {
RS_DEBUG->print("RS_EntityContainer::calculateBorders");
resetBorders();
for (RS_Entity* e=firstEntity(RS2::ResolveNone);
e!=NULL;
e=nextEntity(RS2::ResolveNone)) {
RS_Layer* layer = e->getLayer();
RS_DEBUG->print("RS_EntityContainer::calculateBorders: "
"isVisible: %d", (int)e->isVisible());
if (e->isVisible() && (layer==NULL || !layer->isFrozen())) {
e->calculateBorders();
adjustBorders(e);
}
}
RS_DEBUG->print("RS_EntityContainer::calculateBorders: size 1: %f,%f",
getSize().x, getSize().y);
// needed for correcting corrupt data (PLANS.dxf)
if (minV.x>maxV.x || minV.x>RS_MAXDOUBLE || maxV.x>RS_MAXDOUBLE
|| minV.x<RS_MINDOUBLE || maxV.x<RS_MINDOUBLE) {
minV.x = 0.0;
maxV.x = 0.0;
}
if (minV.y>maxV.y || minV.y>RS_MAXDOUBLE || maxV.y>RS_MAXDOUBLE
|| minV.y<RS_MINDOUBLE || maxV.y<RS_MINDOUBLE) {
minV.y = 0.0;
maxV.y = 0.0;
}
RS_DEBUG->print("RS_EntityCotnainer::calculateBorders: size: %f,%f",
getSize().x, getSize().y);
//RS_DEBUG->print(" borders: %f/%f %f/%f", minV.x, minV.y, maxV.x, maxV.y);
//printf("borders: %lf/%lf %lf/%lf\n", minV.x, minV.y, maxV.x, maxV.y);
//RS_Entity::calculateBorders();
}
