RS_Entity* RS_MText::clone() const{
RS_MText* t = new RS_MText(*this);
t->setOwner(isOwner());
t->initId();
t->detach();
return t;
}
/**
* Testing function.
*/
void LC_SimpleTests::slotTestInsertMText() {
RS_DEBUG->print("%s\n: begin\n", __func__);
RS_Document* d = QC_ApplicationWindow::getAppWindow()->getDocument();
if (d) {
RS_Graphic* graphic = (RS_Graphic*)d;
if (graphic==NULL) {
return;
}
RS_MText* text;
RS_MTextData textData;
textData = RS_MTextData(RS_Vector(10.0,10.0),
10.0, 100.0,
RS_MTextData::VATop,
RS_MTextData::HALeft,
RS_MTextData::LeftToRight,
RS_MTextData::Exact,
1.0,
"LibreCAD",
"iso",
0.0);
text = new RS_MText(graphic, textData);
text->setLayerToActive();
text->setPen(RS_Pen(RS_Color(255, 0, 0),
RS2::Width01,
RS2::SolidLine));
graphic->addEntity(text);
}
RS_DEBUG->print("%s\n: end\n", __func__);
}
void RS_ActionDrawMText::preparePreview() {
data->insertionPoint = *pos;
RS_MText* text = new RS_MText(preview.get(), *data);
text->update();
preview->addEntity(text);
textChanged = false;
}
void RS_ActionDrawMText::trigger() {
RS_DEBUG->print("RS_ActionDrawText::trigger()");
if (pos->valid) {
deletePreview();
RS_MText* text = new RS_MText(container, *data);
text->update();
container->addEntity(text);
if (document) {
document->startUndoCycle();
document->addUndoable(text);
document->endUndoCycle();
}
graphicView->redraw(RS2::RedrawDrawing);
textChanged = true;
setStatus(SetPos);
}
}
/**
* Creates a dimensioning line (line with one, two or no arrows and a text).
*
* @param forceAutoText Automatically reposition the text label.
*/
void RS_Dimension::updateCreateDimensionLine(const RS_Vector& p1,
const RS_Vector& p2, bool arrow1, bool arrow2, bool forceAutoText) {
// general scale (DIMSCALE)
double dimscale = getGeneralScale();
// text height (DIMTXT)
double dimtxt = getTextHeight()*dimscale;
// text distance to line (DIMGAP)
double dimgap = getDimensionLineGap()*dimscale;
// length of dimension line:
double distance = p1.distanceTo(p2);
// arrow size:
double arrowSize = getArrowSize()*dimscale;
// do we have to put the arrows outside of the line?
bool outsideArrows = (distance<arrowSize*2.5);
// arrow angles:
double arrowAngle1, arrowAngle2;
// Create dimension line:
RS_Line* dimensionLine = new RS_Line(this, RS_LineData(p1, p2));
dimensionLine->setPen(RS_Pen(RS2::FlagInvalid));
dimensionLine->setLayer(NULL);
addEntity(dimensionLine);
if (outsideArrows==false) {
arrowAngle1 = dimensionLine->getAngle2();
arrowAngle2 = dimensionLine->getAngle1();
} else {
arrowAngle1 = dimensionLine->getAngle1();
arrowAngle2 = dimensionLine->getAngle2();
// extend dimension line outside arrows
RS_Vector dir;
dir.setPolar(arrowSize*2, arrowAngle2);
dimensionLine->setStartpoint(p1 + dir);
dimensionLine->setEndpoint(p2 - dir);
}
double dimtsz=getTickSize()*dimscale;
if(dimtsz < 0.01) {
//display arrow
// Arrows:
RS_SolidData sd;
RS_Solid* arrow;
if (arrow1) {
// arrow 1
arrow = new RS_Solid(this, sd);
arrow->shapeArrow(p1,
arrowAngle1,
arrowSize);
arrow->setPen(RS_Pen(RS2::FlagInvalid));
arrow->setLayer(NULL);
addEntity(arrow);
}
if (arrow2) {
// arrow 2:
arrow = new RS_Solid(this, sd);
arrow->shapeArrow(p2,
arrowAngle2,
arrowSize);
arrow->setPen(RS_Pen(RS2::FlagInvalid));
arrow->setLayer(NULL);
addEntity(arrow);
}
}else{
//display ticks
// Arrows:
RS_Line* tick;
RS_Vector tickVector;
tickVector.setPolar(dimtsz,arrowAngle1 + M_PI*0.25); //tick is 45 degree away
if (arrow1) {
// tick 1
tick = new RS_Line(this, p1-tickVector, p1+tickVector);
tick->setPen(RS_Pen(RS2::FlagInvalid));
tick->setLayer(NULL);
addEntity(tick);
}
if (arrow2) {
// tick 2:
tick = new RS_Line(this, p2-tickVector, p2+tickVector);
tick->setPen(RS_Pen(RS2::FlagInvalid));
tick->setLayer(NULL);
addEntity(tick);
}
}
// Text label:
RS_MTextData textData;
RS_Vector textPos;
double dimAngle1 = dimensionLine->getAngle1();
double textAngle;
bool corrected=false;
if (getAlignText())
textAngle =0.0;
else
textAngle = RS_Math::makeAngleReadable(dimAngle1, true, &corrected);
if (data.middleOfText.valid && !forceAutoText) {
textPos = data.middleOfText;
} else {
textPos = dimensionLine->getMiddlePoint();
if (!getAlignText()) {
RS_Vector distV;
// rotate text so it's readable from the bottom or right (ISO)
// quadrant 1 & 4
if (corrected) {
distV.setPolar(dimgap + dimtxt/2.0, dimAngle1-M_PI/2.0);
} else {
distV.setPolar(dimgap + dimtxt/2.0, dimAngle1+M_PI/2.0);
}
// move text away from dimension line:
textPos+=distV;
}
//// the next update should still be able to adjust this
//// auto text position. leave it invalid
data.middleOfText = textPos;
}
textData = RS_MTextData(textPos,
dimtxt, 30.0,
RS_MTextData::VAMiddle,
RS_MTextData::HACenter,
RS_MTextData::LeftToRight,
RS_MTextData::Exact,
1.0,
getLabel(),
"standard",
textAngle);
RS_MText* text = new RS_MText(this, textData);
// move text to the side:
RS_Vector distH;
if (text->getUsedTextWidth()>distance) {
distH.setPolar(text->getUsedTextWidth()/2.0
+distance/2.0+dimgap, textAngle);
text->move(distH);
}
text->setPen(RS_Pen(RS2::FlagInvalid));
text->setLayer(NULL);
//horizontal text, split dimensionLine
if (getAlignText()) {
double w =text->getUsedTextWidth()/2+dimgap;
double h = text->getUsedTextHeight()/2+dimgap;
RS_Vector v1 = textPos - RS_Vector(w, h);
RS_Vector v2 = textPos + RS_Vector(w, h);
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 sol1, sol2;
int inters= 0;
do {
sol1 = RS_Information::getIntersection(dimensionLine, &(l[inters++]), true);
} while (!sol1.hasValid() && inters < 4);
if (!sol1.hasValid()) {
do {
sol2 = RS_Information::getIntersection(dimensionLine, &(l[inters++]), true);
} while (!sol2.hasValid() && inters < 4);
}
//are text intersecting dimensionLine?
if (sol1.hasValid() && sol2.hasValid()) {
//yes, split dimension line
RS_Line* dimensionLine2 = (RS_Line*)dimensionLine->clone();
v1 = sol1.get(0);
v2 = sol2.get(0);
if (p1.distanceTo(v1) < p1.distanceTo(v2)) {
dimensionLine->setEndpoint(v1);
dimensionLine2->setStartpoint(v2);
} else {
dimensionLine->setEndpoint(v2);
dimensionLine2->setStartpoint(v1);
}
addEntity(dimensionLine2);
}
}
addEntity(text);
}
/**
* Testing function.
*/
void LC_SimpleTests::slotTestDumpEntities(RS_EntityContainer* d){
int level = 0;
std::ofstream dumpFile;
if (d) {
dumpFile.open("debug_entities.html", std::ios::app);
++level;
} else {
d = QC_ApplicationWindow::getAppWindow()->getDocument();
dumpFile.open("debug_entities.html");
level = 0;
}
if (d) {
if (level==0) {
dumpFile << "<html>\n";
dumpFile << "<body>\n";
}
for(auto e: *d){
dumpFile << "<table border=\"1\">\n";
dumpFile << "<tr><td>Entity: " << e->getId()
<< "</td></tr>\n";
dumpFile
<< "<tr><td><table><tr>"
<< "<td>VIS:" << e->isVisible() << "</td>"
<< "<td>UND:" << e->isUndone() << "</td>"
<< "<td>SEL:" << e->isSelected() << "</td>"
<< "<td>TMP:" << e->getFlag(RS2::FlagTemp) << "</td>";
QString lay = "NULL";
if (e->getLayer()) {
lay = e->getLayer()->getName();
}
dumpFile
<< "<td>Layer: " << lay.toLatin1().data() << "</td>"
<< "<td>Width: " << (int)e->getPen(false).getWidth() << "</td>"
<< "<td>Parent: " << e->getParent()->getId() << "</td>"
<< "</tr></table>";
dumpFile
<< "<tr><td>\n";
switch (e->rtti()) {
case RS2::EntityPoint: {
RS_Point* p = (RS_Point*)e;
dumpFile
<< "<table><tr><td>"
<< "<b>Point:</b>"
<< "</td></tr>";
dumpFile
<< "<tr>"
<< "<td>"
<< p->getPos()
<< "</td>"
<< "</tr></table>";
}
break;
case RS2::EntityLine: {
RS_Line* l = (RS_Line*)e;
dumpFile
<< "<table><tr><td>"
<< "<b>Line:</b>"
<< "</td></tr>";
dumpFile
<< "<tr>"
<< "<td>"
<< l->getStartpoint()
<< "</td>"
<< "<td>"
<< l->getEndpoint()
<< "</td>"
<< "</tr></table>";
}
break;
case RS2::EntityArc: {
RS_Arc* a = (RS_Arc*)e;
dumpFile
<< "<table><tr><td>"
<< "<b>Arc:</b>"
<< "</td></tr>";
dumpFile
<< "<tr>"
<< "<td>Center: "
<< a->getCenter()
<< "</td>"
<< "<td>Radius: "
<< a->getRadius()
<< "</td>"
<< "<td>Angle 1: "
<< a->getAngle1()
<< "</td>"
<< "<td>Angle 2: "
<< a->getAngle2()
<< "</td>"
<< "<td>Startpoint: "
<< a->getStartpoint()
<< "</td>"
<< "<td>Endpoint: "
<< a->getEndpoint()
<< "</td>"
<< "<td>reversed: "
<< (int)a->isReversed()
<< "</td>"
<< "</tr></table>";
}
break;
case RS2::EntityCircle: {
RS_Circle* c = (RS_Circle*)e;
dumpFile
<< "<table><tr><td>"
<< "<b>Circle:</b>"
<< "</td></tr>";
dumpFile
<< "<tr>"
<< "<td>Center: "
<< c->getCenter()
<< "</td>"
<< "<td>Radius: "
<< c->getRadius()
<< "</td>"
<< "</tr></table>";
}
break;
case RS2::EntityDimAligned: {
RS_DimAligned* d = (RS_DimAligned*)e;
dumpFile
<< "<table><tr><td>"
<< "<b>Dimension / Aligned:</b>"
<< "</td></tr>";
dumpFile
<< "<tr>"
<< "<td>"
<< d->getDefinitionPoint()
<< "</td>"
<< "<td>"
<< d->getExtensionPoint1()
<< "</td>"
<< "<td>"
<< d->getExtensionPoint2()
<< "</td>"
<< "<td>Text: "
<< d->getText().toLatin1().data()
<< "</td>"
<< "<td>Label: "
<< d->getLabel().toLatin1().data()
<< "</td>"
<< "</tr></table>";
}
break;
case RS2::EntityDimLinear: {
RS_DimLinear* d = (RS_DimLinear*)e;
dumpFile
<< "<table><tr><td>"
<< "<b>Dimension / Linear:</b>"
<< "</td></tr>";
dumpFile
<< "<tr>"
<< "<td>"
<< d->getDefinitionPoint()
<< "</td>"
<< "<td>"
<< d->getExtensionPoint1()
<< "</td>"
<< "<td>"
<< d->getExtensionPoint2()
<< "</td>"
<< "<td>Text: "
<< d->getText().toLatin1().data()
<< "</td>"
<< "<td>Label: "
<< d->getLabel().toLatin1().data()
<< "</td>"
<< "</tr></table>";
}
break;
case RS2::EntityInsert: {
RS_Insert* i = (RS_Insert*)e;
dumpFile
<< "<table><tr><td>"
<< "<b>Insert:</b>"
<< "</td></tr>";
dumpFile
<< "<tr>"
<< "<td>Insertion point:"
<< i->getInsertionPoint()
<< "</td>"
<< "</tr></table>";
}
break;
case RS2::EntityMText: {
RS_MText* t = (RS_MText*)e;
dumpFile
<< "<table><tr><td>"
<< "<b>Text:</b>"
<< "</td></tr>";
dumpFile
<< "<tr>"
<< "<td>Text:"
<< t->getText().toLatin1().data()
<< "</td>"
<< "<td>Height:"
<< t->getHeight()
<< "</td>"
<< "</tr></table>";
}
break;
case RS2::EntityText: {
RS_Text* t = (RS_Text*)e;
dumpFile
<< "<table><tr><td>"
<< "<b>Text:</b>"
<< "</td></tr>";
dumpFile
<< "<tr>"
<< "<td>Text:"
<< t->getText().toLatin1().data()
<< "</td>"
<< "<td>Height:"
<< t->getHeight()
<< "</td>"
<< "</tr></table>";
}
break;
case RS2::EntityHatch: {
RS_Hatch* h = (RS_Hatch*)e;
dumpFile
<< "<table><tr><td>"
<< "<b>Hatch:</b>"
<< "</td></tr>";
dumpFile
<< "<tr>"
<< "<td>Pattern:"
<< h->getPattern().toLatin1().data()
<< "</td>"
<< "<td>Scale:"
<< h->getScale()
<< "</td>"
<< "<td>Solid:"
<< (int)h->isSolid()
<< "</td>"
<< "</tr></table>";
}
break;
default:
dumpFile
<< "<tr><td>"
<< "<b>Unknown Entity: " << e->rtti() << "</b>"
<< "</td></tr>";
break;
}
if (e->isContainer() || e->rtti()==RS2::EntityHatch) {
RS_EntityContainer* ec = (RS_EntityContainer*)e;
dumpFile << "<table><tr><td valign=\"top\"> Contents:</td><td>\n";
dumpFile.close();
slotTestDumpEntities(ec);
dumpFile.open("debug_entities.html", std::ios::app);
dumpFile << "</td></tr></table>\n";
}
dumpFile
<< "</td></tr>"
<< "</table>\n"
<< "<br><br>";
}
if (level==0) {
dumpFile << "</body>\n";
dumpFile << "</html>\n";
} else {
level--;
}
}
RS_DEBUG->print("%s\n: end\n", __func__);
}
/**
* Updates the sub entities of this dimension. Called when the
* dimension or the position, alignment, .. changes.
*
* @param autoText Automatically reposition the text label
*/
void RS_DimRadial::updateDim(bool autoText) {
RS_DEBUG->print("RS_DimRadial::update");
clear();
if (isUndone()) {
return;
}
// dimension line:
//updateCreateDimensionLine(data.definitionPoint, edata.definitionPoint,
//false, true);
// general scale (DIMSCALE)
double dimscale = getGeneralScale();
RS_Vector p1 = data.definitionPoint;
RS_Vector p2 = edata.definitionPoint;
double angle = p1.angleTo(p2);
// text height (DIMTXT)
double dimtxt = getTextHeight()*dimscale;
// text distance to line (DIMGAP)
double dimgap = getDimensionLineGap()*dimscale;
// arrow size:
double arrowSize = getArrowSize()*dimscale;
// length of dimension line:
double length = p1.distanceTo(p2);
RS_Pen pen(getDimensionLineColor(),
getDimensionLineWidth(),
RS2::LineByBlock);
RS_MTextData textData;
textData = RS_MTextData(RS_Vector(0.0,0.0),
dimtxt, 30.0,
RS_MTextData::VAMiddle,
RS_MTextData::HACenter,
RS_MTextData::LeftToRight,
RS_MTextData::Exact,
1.0,
getLabel(),
getTextStyle(),
// "standard",
0.0);
RS_MText* text = new RS_MText(this, textData);
double textWidth = text->getSize().x;
// do we have to put the arrow / text outside of the arc?
bool outsideArrow = (length<arrowSize*2+textWidth);
double arrowAngle;
if (outsideArrow) {
length += arrowSize*2 + textWidth;
arrowAngle = angle+M_PI;
} else {
arrowAngle = angle;
}
// create arrow:
RS_SolidData sd;
RS_Solid* arrow;
arrow = new RS_Solid(this, sd);
arrow->shapeArrow(p2,
arrowAngle,
arrowSize);
// arrow->setPen(RS_Pen(RS2::FlagInvalid));
arrow->setPen(pen);
arrow->setLayer(NULL);
addEntity(arrow);
RS_Vector p3;
p3.setPolar(length, angle);
p3 += p1;
// Create dimension line:
RS_Line* dimensionLine = new RS_Line(this, RS_LineData(p1, p3));
dimensionLine->setPen(pen);
// dimensionLine->setPen(RS_Pen(RS2::FlagInvalid));
dimensionLine->setLayer(NULL);
addEntity(dimensionLine);
RS_Vector distV;
double textAngle;
// rotate text so it's readable from the bottom or right (ISO)
// quadrant 1 & 4
if (angle>M_PI_2*3.0+0.001 ||
angle<M_PI_2+0.001) {
distV.setPolar(dimgap + dimtxt/2.0, angle+M_PI_2);
textAngle = angle;
}
// quadrant 2 & 3
else {
distV.setPolar(dimgap + dimtxt/2.0, angle-M_PI_2);
textAngle = angle+M_PI;
}
// move text label:
RS_Vector textPos;
if (data.middleOfText.valid && !autoText) {
textPos = data.middleOfText;
} else {
if (outsideArrow) {
textPos.setPolar(length-textWidth/2.0-arrowSize, angle);
} else {
textPos.setPolar(length/2.0, angle);
}
textPos+=p1;
// move text away from dimension line:
textPos += distV;
data.middleOfText = textPos;
}
text->rotate(RS_Vector(0.0,0.0), textAngle);
text->move(textPos);
text->setPen(RS_Pen(getTextColor(), RS2::WidthByBlock, RS2::SolidLine));
// text->setPen(RS_Pen(RS2::FlagInvalid));
text->setLayer(NULL);
addEntity(text);
calculateBorders();
}
void Plugin_Entity::updateData(QHash<int, QVariant> *data){
if (entity == NULL) return;
RS_Entity *ec= entity;
if(hasContainer && dpi!=NULL) {
ec = entity->clone();
}
QHash<int, QVariant> hash = *data;
QString str;
RS_Vector vec;
RS_Pen epen = ec->getPen();
// double num;
if (hash.contains(DPI::LAYER)) {
str = (hash.take(DPI::LAYER)).toString();
ec->setLayer(str);
}
if (hash.contains(DPI::LTYPE)) {
str = (hash.take(DPI::LTYPE)).toString();
epen.setLineType( Converter.str2lt(str) );
}
if (hash.contains(DPI::LWIDTH)) {
str = (hash.take(DPI::LWIDTH)).toString();
epen.setWidth( Converter.str2lw(str) );
}
if (hash.contains(DPI::COLOR)) {
QColor color = hash.take(DPI::COLOR).value<QColor>();
epen.setColor(color);
}
ec->setPen(epen);
RS2::EntityType et = ec->rtti();
switch (et) {
//atomicEntity
case RS2::EntityLine: {
vec = static_cast<RS_Line*>(ec)->getStartpoint();
if (hash.contains(DPI::STARTX)) {
vec.x = (hash.take(DPI::STARTX)).toDouble();
}
if (hash.contains(DPI::STARTY)) {
vec.y = (hash.take(DPI::STARTY)).toDouble();
}
static_cast<RS_Line*>(ec)->setStartpoint(vec);
vec = static_cast<RS_Line*>(ec)->getEndpoint();
if (hash.contains(DPI::ENDX)) {
vec.x = (hash.take(DPI::ENDX)).toDouble();
}
if (hash.contains(DPI::ENDY)) {
vec.y = (hash.take(DPI::ENDY)).toDouble();
}
static_cast<RS_Line*>(ec)->setEndpoint(vec);
break;}
case RS2::EntityPoint: {
vec = static_cast<RS_Point*>(ec)->getPos();
if (hash.contains(DPI::STARTX)) {
vec.x = (hash.take(DPI::STARTX)).toDouble();
}
if (hash.contains(DPI::STARTY)) {
vec.y = (hash.take(DPI::STARTY)).toDouble();
}
static_cast<RS_Point*>(ec)->setPos(vec);
break; }
case RS2::EntityArc: {
RS_Arc *arc = static_cast<RS_Arc*>(ec);
vec = arc->getCenter();
if (hash.contains(DPI::STARTX)) {
vec.x = (hash.take(DPI::STARTX)).toDouble();
}
if (hash.contains(DPI::STARTY)) {
vec.y = (hash.take(DPI::STARTY)).toDouble();
}
arc->setCenter(vec);
if (hash.contains(DPI::RADIUS)) {
arc->setRadius( (hash.take(DPI::RADIUS)).toDouble() );
}
if (hash.contains(DPI::STARTANGLE)) {
arc->setAngle1( (hash.take(DPI::STARTANGLE)).toDouble() );
vec.y = (hash.take(DPI::STARTANGLE)).toDouble();
}
if (hash.contains(DPI::ENDANGLE)) {
arc->setAngle2( (hash.take(DPI::ENDANGLE)).toDouble() );
}
break;}
case RS2::EntityCircle: {
RS_Circle *cir = static_cast<RS_Circle*>(ec);
vec = cir->getCenter();
if (hash.contains(DPI::STARTX)) {
vec.x = (hash.take(DPI::STARTX)).toDouble();
}
if (hash.contains(DPI::STARTY)) {
vec.y = (hash.take(DPI::STARTY)).toDouble();
}
cir->setCenter(vec);
if (hash.contains(DPI::RADIUS)) {
cir->setRadius( (hash.take(DPI::RADIUS)).toDouble() );
}
break;}
case RS2::EntityEllipse: {
RS_Ellipse *ellipse = static_cast<RS_Ellipse*>(ec);
vec = ellipse->getCenter();
if (hash.contains(DPI::STARTX)) {
vec.x = (hash.take(DPI::STARTX)).toDouble();
}
if (hash.contains(DPI::STARTY)) {
vec.y = (hash.take(DPI::STARTY)).toDouble();
}
ellipse->setCenter(vec);
vec = ellipse->getMajorP();
if (hash.contains(DPI::ENDX)) {
vec.x = (hash.take(DPI::ENDX)).toDouble();
}
if (hash.contains(DPI::ENDY)) {
vec.y = (hash.take(DPI::ENDY)).toDouble();
}
ellipse->setMajorP(vec);
if (hash.contains(DPI::STARTANGLE)) {
ellipse->setAngle1((hash.take(DPI::STARTANGLE)).toDouble());
}
if (hash.contains(DPI::ENDANGLE)) {
ellipse->setAngle2((hash.take(DPI::ENDANGLE)).toDouble());
}
if (hash.contains(DPI::HEIGHT)) {
ellipse->setRatio((hash.take(DPI::HEIGHT)).toDouble());
}
if (hash.contains(DPI::REVERSED)) {
ellipse->setReversed( (hash.take(DPI::REVERSED)).toBool());
}
break;}
case RS2::EntitySolid: //TODO
//Only used in dimensions ?
break;
case RS2::EntityConstructionLine:
//Unused ?
break;
case RS2::EntityImage: {
RS_Image *img = static_cast<RS_Image*>(ec);
vec = img->getInsertionPoint();
if (hash.contains(DPI::STARTX)) {
vec.x = (hash.take(DPI::STARTX)).toDouble();
}
if (hash.contains(DPI::STARTY)) {
vec.y = (hash.take(DPI::STARTY)).toDouble();
}
img->setInsertionPoint(vec);
if (hash.contains(DPI::BLKNAME)) {
img->setFile( (hash.take(DPI::BLKNAME)).toString() );
}
vec = img->getUVector();
RS_Vector vec2 = img->getVVector();
RS_Vector vec3(img->getWidth(),img->getHeight());
if (hash.contains(DPI::ENDX)) {
vec.x = (hash.take(DPI::ENDX)).toDouble();
}
if (hash.contains(DPI::ENDY)) {
vec.y = (hash.take(DPI::ENDY)).toDouble();
}
if (hash.contains(DPI::VVECTORX)) {
vec2.x = (hash.take(DPI::VVECTORX)).toDouble();
}
if (hash.contains(DPI::VVECTORY)) {
vec2.y = (hash.take(DPI::VVECTORY)).toDouble();
}
if (hash.contains(DPI::SIZEU)) {
vec3.x = (hash.take(DPI::SIZEU)).toDouble();
}
if (hash.contains(DPI::SIZEV)) {
vec3.y = (hash.take(DPI::SIZEV)).toDouble();
}
img->updateData(vec3, vec, vec2);
break;}
case RS2::EntityOverlayBox:
//Unused ?
break;
//EntityContainer
case RS2::EntityInsert: {
break;}
case RS2::EntityMText: {
RS_MText *txt = static_cast<RS_MText*>(ec);
bool move = false;
vec = txt->getInsertionPoint();
if (hash.contains(DPI::STARTX)) {
vec.x = (hash.take(DPI::STARTX)).toDouble() - vec.x;
move = true;
} else vec.x = 0;
if (hash.contains(DPI::STARTY)) {
vec.y = (hash.take(DPI::STARTY)).toDouble() - vec.y;
move = true;
} else vec.y = 0;
if (move)
txt->move(vec);
if (hash.contains(DPI::TEXTCONTENT)) {
txt->setText( (hash.take(DPI::TEXTCONTENT)).toString() );
}
if (hash.contains(DPI::STARTANGLE)) {
txt->setAngle( (hash.take(DPI::STARTANGLE)).toDouble() );
}
if (hash.contains(DPI::HEIGHT)) {
txt->setHeight( (hash.take(DPI::HEIGHT)).toDouble() );
}
break;}
case RS2::EntityText: {
RS_Text *txt = static_cast<RS_Text*>(ec);
bool move = false;
vec = txt->getInsertionPoint();
if (hash.contains(DPI::STARTX)) {
vec.x = (hash.take(DPI::STARTX)).toDouble() - vec.x;
move = true;
} else vec.x = 0;
if (hash.contains(DPI::STARTY)) {
vec.y = (hash.take(DPI::STARTY)).toDouble() - vec.y;
move = true;
} else vec.y = 0;
if (move)
txt->move(vec);
if (hash.contains(DPI::TEXTCONTENT)) {
txt->setText( (hash.take(DPI::TEXTCONTENT)).toString() );
}
if (hash.contains(DPI::STARTANGLE)) {
txt->setAngle( (hash.take(DPI::STARTANGLE)).toDouble() );
}
if (hash.contains(DPI::HEIGHT)) {
txt->setHeight( (hash.take(DPI::HEIGHT)).toDouble() );
}
break;}
case RS2::EntityHatch:
break;
case RS2::EntitySpline:
break;
case RS2::EntityPolyline: {
RS_Polyline *pl = static_cast<RS_Polyline*>(ec);
if (hash.take(DPI::CLOSEPOLY).toBool()) {
pl->setClosed(true);
}else{
pl->setClosed(false);
}
break;}
case RS2::EntityVertex:
break;
case RS2::EntityDimAligned:
break;
case RS2::EntityDimLinear:
break;
case RS2::EntityDimRadial:
break;
case RS2::EntityDimDiametric:
break;
case RS2::EntityDimAngular:
break;
case RS2::EntityDimLeader:
break;
case RS2::EntityUnknown:
default:
break;
}
ec->update();
if(hasContainer && dpi!=NULL)
this->dpi->updateEntity(entity, ec);
}
/**
* Updates the Inserts (letters) of this text. Called when the
* text or it's data, position, alignment, .. changes.
* This method also updates the usedTextWidth / usedTextHeight property.
*/
void RS_MText::update() {
RS_DEBUG->print("RS_Text::update");
clear();
if (isUndone()) {
return;
}
usedTextWidth = 0.0;
usedTextHeight = 0.0;
RS_Font* font = RS_FONTLIST->requestFont(data.style);
if (font==NULL) {
return;
}
RS_Vector letterPos = RS_Vector(0.0, -9.0);
RS_Vector letterSpace = RS_Vector(font->getLetterSpacing(), 0.0);
RS_Vector space = RS_Vector(font->getWordSpacing(), 0.0);
int lineCounter = 0;
// Every single text line gets stored in this entity container
// so we can move the whole line around easely:
RS_EntityContainer* oneLine = new RS_EntityContainer(this);
// First every text line is created with
// alignement: top left
// angle: 0
// height: 9.0
// Rotation, scaling and centering is done later
// For every letter:
for (int i=0; i<(int)data.text.length(); ++i) {
bool handled = false;
switch (data.text.at(i).unicode()) {
case 0x0A:
// line feed:
updateAddLine(oneLine, lineCounter++);
oneLine = new RS_EntityContainer(this);
letterPos = RS_Vector(0.0, -9.0);
break;
case 0x20:
// Space:
letterPos+=space;
break;
case 0x5C: {
// code (e.g. \S, \P, ..)
i++;
int ch = data.text.at(i).unicode();
switch (ch) {
case 'P':
updateAddLine(oneLine, lineCounter++);
oneLine = new RS_EntityContainer(this);
letterPos = RS_Vector(0.0, -9.0);
handled = true;
break;
case 'f':
case 'F':
//font change
// \f{symbol} changes font to symbol
// \f{} sets font to standard
{
i++;
if(data.text.at(i).unicode()!='{') {
i--;
continue;
}
int j=data.text.indexOf('}',i);
if(j>i){
//
QString fontName;
if(j==i+1)
fontName="standard";
else
fontName=data.text.mid(i+1,j-i-1);
RS_Font* fontNew = RS_FONTLIST->requestFont(
fontName
);
if(fontNew != NULL) {
font=fontNew;
}
if(font==NULL) font = RS_FONTLIST->requestFont("standard");
i=j;
}
}
continue;
case 'S': {
QString up;
QString dw;
//letterPos += letterSpace;
// get upper string:
i++;
while (data.text.at(i).unicode()!='^' &&
//data.text.at(i).unicode()!='/' &&
data.text.at(i).unicode()!='\\' &&
//data.text.at(i).unicode()!='#' &&
i<(int)data.text.length()) {
up += data.text.at(i);
i++;
}
i++;
if (data.text.at(i-1).unicode()=='^' &&
data.text.at(i).unicode()==' ') {
i++;
}
// get lower string:
while (data.text.at(i).unicode()!=';' &&
i<(int)data.text.length()) {
dw += data.text.at(i);
i++;
}
// add texts:
RS_MText* upper =
new RS_MText(
oneLine,
RS_MTextData(letterPos + RS_Vector(0.0,9.0),
4.0, 100.0, RS_MTextData::VATop, RS_MTextData::HALeft,
RS_MTextData::LeftToRight, RS_MTextData::Exact,
1.0, up, data.style,
0.0, RS2::Update));
upper->setLayer(NULL);
upper->setPen(RS_Pen(RS2::FlagInvalid));
oneLine->addEntity(upper);
RS_MText* lower =
new RS_MText(
oneLine,
RS_MTextData(letterPos+RS_Vector(0.0,4.0),
4.0, 100.0, RS_MTextData::VATop, RS_MTextData::HALeft,
RS_MTextData::LeftToRight, RS_MTextData::Exact,
1.0, dw, data.style,
0.0, RS2::Update));
lower->setLayer(NULL);
lower->setPen(RS_Pen(RS2::FlagInvalid));
oneLine->addEntity(lower);
// move cursor:
upper->calculateBorders();
lower->calculateBorders();
double w1 = upper->getSize().x;
double w2 = lower->getSize().x;
if (w1>w2) {
letterPos += RS_Vector(w1, 0.0);
} else {
letterPos += RS_Vector(w2, 0.0);
}
letterPos += letterSpace;
}
handled = true;
break;
default:
i--;
break;
}
}
//if char is not handled continue in default: statement
if (handled)
break;
default: {
// One Letter:
QString letterText = QString(data.text.at(i));
if (font->findLetter(letterText) == NULL) {
RS_DEBUG->print("RS_Text::update: missing font for letter( %s ), replaced it with QChar(0xfffd)",qPrintable(letterText));
letterText = QChar(0xfffd);
}
// if (font->findLetter(QString(data.text.at(i))) != NULL) {
RS_DEBUG->print("RS_Text::update: insert a "
"letter at pos: %f/%f", letterPos.x, letterPos.y);
RS_InsertData d(letterText,
letterPos,
RS_Vector(1.0, 1.0),
0.0,
1,1, RS_Vector(0.0,0.0),
font->getLetterList(), RS2::NoUpdate);
RS_Insert* letter = new RS_Insert(this, d);
RS_Vector letterWidth;
letter->setPen(RS_Pen(RS2::FlagInvalid));
letter->setLayer(NULL);
letter->update();
letter->forcedCalculateBorders();
// until 2.0.4.5:
//letterWidth = RS_Vector(letter->getSize().x, 0.0);
// from 2.0.4.6:
letterWidth = RS_Vector(letter->getMax().x-letterPos.x, 0.0);
if (letterWidth.x < 0)
letterWidth.x = -letterSpace.x;
oneLine->addEntity(letter);
// next letter position:
letterPos += letterWidth;
letterPos += letterSpace;
// }
}
break;
}
}
double tt = updateAddLine(oneLine, lineCounter);
if (data.valign == RS_MTextData::VABottom) {
RS_Vector ot = RS_Vector(0.0,-tt).rotate(data.angle);
RS_EntityContainer::move(ot);
}
usedTextHeight -= data.height*data.lineSpacingFactor*5.0/3.0
- data.height;
forcedCalculateBorders();
RS_DEBUG->print("RS_Text::update: OK");
}
/**
* Creates a dimensioning line (line with one, two or no arrows and a text).
*
* @param forceAutoText Automatically reposition the text label.
*/
void RS_Dimension::updateCreateDimensionLine(const RS_Vector& p1,
const RS_Vector& p2, bool arrow1, bool arrow2, bool forceAutoText) {
// general scale (DIMSCALE)
double dimscale = getGeneralScale();
// text height (DIMTXT)
double dimtxt = getTextHeight()*dimscale;
// text distance to line (DIMGAP)
double dimgap = getDimensionLineGap()*dimscale;
// length of dimension line:
double distance = p1.distanceTo(p2);
// arrow size:
double arrowSize = getArrowSize()*dimscale;
// do we have to put the arrows outside of the line?
bool outsideArrows = (distance<arrowSize*2.5);
// arrow angles:
double arrowAngle1, arrowAngle2;
RS_Pen pen(getDimensionLineColor(),
getDimensionLineWidth(),
RS2::LineByBlock);
// Create dimension line:
RS_Line* dimensionLine = new RS_Line{this, p1, p2};
dimensionLine->setPen(pen);
// dimensionLine->setPen(RS_Pen(RS2::FlagInvalid));
dimensionLine->setLayer(nullptr);
addEntity(dimensionLine);
if (outsideArrows==false) {
arrowAngle1 = dimensionLine->getAngle2();
arrowAngle2 = dimensionLine->getAngle1();
} else {
arrowAngle1 = dimensionLine->getAngle1();
arrowAngle2 = dimensionLine->getAngle2();
// extend dimension line outside arrows
RS_Vector dir = RS_Vector::polar(arrowSize*2, arrowAngle2);
dimensionLine->setStartpoint(p1 + dir);
dimensionLine->setEndpoint(p2 - dir);
}
double dimtsz=getTickSize()*dimscale;
if(dimtsz < 0.01) {
//display arrow
// Arrows:
RS_SolidData sd;
RS_Solid* arrow;
if (arrow1) {
// arrow 1
arrow = new RS_Solid(this, sd);
arrow->shapeArrow(p1,
arrowAngle1,
arrowSize);
// arrow->setPen(RS_Pen(RS2::FlagInvalid));
arrow->setPen(pen);
arrow->setLayer(nullptr);
addEntity(arrow);
}
if (arrow2) {
// arrow 2:
arrow = new RS_Solid(this, sd);
arrow->shapeArrow(p2,
arrowAngle2,
arrowSize);
// arrow->setPen(RS_Pen(RS2::FlagInvalid));
arrow->setPen(pen);
arrow->setLayer(nullptr);
addEntity(arrow);
}
}else{
//display ticks
// Arrows:
RS_Line* tick;
RS_Vector tickVector = RS_Vector::polar(dimtsz,arrowAngle1 + M_PI*0.25); //tick is 45 degree away
if (arrow1) {
// tick 1
tick = new RS_Line(this, p1-tickVector, p1+tickVector);
tick->setPen(pen);
// tick->setPen(RS_Pen(RS2::FlagInvalid));
tick->setLayer(nullptr);
addEntity(tick);
}
if (arrow2) {
// tick 2:
tick = new RS_Line(this, p2-tickVector, p2+tickVector);
tick->setPen(pen);
// tick->setPen(RS_Pen(RS2::FlagInvalid));
tick->setLayer(nullptr);
addEntity(tick);
}
}
// Text label:
RS_MTextData textData;
RS_Vector textPos;
double dimAngle1 = dimensionLine->getAngle1();
double textAngle;
bool corrected=false;
if (getAlignText())
textAngle =0.0;
else
textAngle = RS_Math::makeAngleReadable(dimAngle1, true, &corrected);
if (data.middleOfText.valid && !forceAutoText) {
textPos = data.middleOfText;
} else {
textPos = dimensionLine->getMiddlePoint();
if (!getAlignText()) {
// rotate text so it's readable from the bottom or right (ISO)
// quadrant 1 & 4
double const a = corrected?-M_PI_2:M_PI_2;
RS_Vector distV = RS_Vector::polar(dimgap + dimtxt/2.0, dimAngle1+a);
// move text away from dimension line:
textPos+=distV;
}
//// the next update should still be able to adjust this
//// auto text position. leave it invalid
data.middleOfText = textPos;
}
textData = RS_MTextData(textPos,
dimtxt, 30.0,
RS_MTextData::VAMiddle,
RS_MTextData::HACenter,
RS_MTextData::LeftToRight,
RS_MTextData::Exact,
1.0,
getLabel(),
getTextStyle(),
// "standard",
textAngle);
RS_MText* text = new RS_MText(this, textData);
// move text to the side:
RS_Vector distH;
if (text->getUsedTextWidth()>distance) {
distH.setPolar(text->getUsedTextWidth()/2.0
+distance/2.0+dimgap, textAngle);
text->move(distH);
}
text->setPen(RS_Pen(getTextColor(), RS2::WidthByBlock, RS2::SolidLine));
// text->setPen(RS_Pen(RS2::FlagInvalid));
text->setLayer(nullptr);
//horizontal text, split dimensionLine
if (getAlignText()) {
double w =text->getUsedTextWidth()/2+dimgap;
double h = text->getUsedTextHeight()/2+dimgap;
RS_Vector v1 = textPos - RS_Vector{w, h};
RS_Vector v2 = textPos + RS_Vector{w, h};
RS_EntityContainer c;
c.addRectangle(v1, v2);
RS_VectorSolutions sol1;
for(RS_Entity* e: c) {
sol1.push_back(
RS_Information::getIntersection(dimensionLine, e, true)
);
}
//are text intersecting dimensionLine?
if (sol1.size()>1) {
//yes, split dimension line
RS_Line* dimensionLine2 =
static_cast<RS_Line*>(dimensionLine->clone());
v1 = sol1.get(0);
v2 = sol1.get(1);
if (p1.distanceTo(v1) < p1.distanceTo(v2)) {
dimensionLine->setEndpoint(v1);
dimensionLine2->setStartpoint(v2);
} else {
dimensionLine->setEndpoint(v2);
dimensionLine2->setStartpoint(v1);
}
addEntity(dimensionLine2);
}
}
addEntity(text);
}