void RS_ActionDrawText::preparePreview() {
data.insertionPoint = pos;
RS_Text* text = new RS_Text(preview, data);
text->update();
preview->addEntity(text);
textChanged = false;
}
RS_Entity* RS_Text::clone() const{
RS_Text* t = new RS_Text(*this);
t->setOwner(isOwner());
t->initId();
t->detach();
return t;
}
void RS_ActionDrawText::trigger() {
RS_DEBUG->print("RS_ActionDrawText::trigger()");
if (pos.valid) {
deletePreview();
clearPreview();
deleteSnapper();
RS_Text* text = new RS_Text(container, data);
text->update();
container->addEntity(text);
if (document) {
document->startUndoCycle();
document->addUndoable(text);
document->endUndoCycle();
}
graphicView->drawEntity(text);
textChanged = true;
setStatus(SetPos);
}
}
void RS_ActionDrawText::preparePreview() {
clearPreview();
data.insertionPoint = RS_Vector(0.0,0.0);
RS_Text* text = new RS_Text(preview, data);
text->update();
//text->setVisible(false);
preview->addEntity(text);
textChanged = false;
}
void RS_ActionDrawText::preparePreview() {
if (data->halign == RS_TextData::HAFit || data->halign == RS_TextData::HAAligned) {
if (secPos.valid) {
RS_Line* text = new RS_Line(pos, secPos);
preview->addEntity(text);
}
} else {
data->insertionPoint = pos;
RS_Text* text = new RS_Text(preview.get(), *data);
text->update();
preview->addEntity(text);
}
textChanged = false;
}
void RS_ActionDrawText::trigger() {
RS_DEBUG->print("RS_ActionDrawText::trigger()");
if (pos.valid) {
deletePreview();
RS_Text* text = new RS_Text(container, *data);
text->update();
container->addEntity(text);
if (document) {
document->startUndoCycle();
document->addUndoable(text);
document->endUndoCycle();
}
graphicView->redraw(RS2::RedrawDrawing);
textChanged = true;
secPos = RS_Vector(false);
setStatus(SetPos);
}
}
void DL_Jww::CreateMoji(DL_CreationInterface* creationInterface, CDataMoji& DMoji)
{
string lName = HEX[DMoji.m_nGLayer > ArraySize(HEX)-1 ? ArraySize(HEX)-1: DMoji.m_nGLayer] + "-" +
HEX[DMoji.m_nLayer > ArraySize(HEX)-1 ? ArraySize(HEX)-1: DMoji.m_nLayer];
// add layer
creationInterface->addLayer(DL_LayerData(lName,0));
int width;
if(DMoji.m_nPenWidth > 26)
width = 0;
else
width = DMoji.m_nPenWidth;
int color = colTable[DMoji.m_nPenColor > ArraySize(colTable)-1 ? ArraySize(colTable)-1 : DMoji.m_nPenColor];
attrib = DL_Attributes(values[8], // layer
color, // color
width, // width
lTable[DMoji.m_nPenStyle > ArraySize(lTable)-1 ? ArraySize(lTable)-1 : DMoji.m_nPenStyle]); // linetype
creationInterface->setAttributes(attrib);
creationInterface->setExtrusion(0.0, 0.0, 1.0, 0.0 );
DL_TextData d(
// insertion point
DMoji.m_start.x, DMoji.m_start.y, 0.0,
// alignment point
0.0, 0.0, 0.0,
// height
DMoji.m_dSizeY,
// x scale
1.0,
// generation flags
0,
// h just
0,
// v just
0,
// text
DMoji.m_string,
// style
string("japanese"),
// angle
DMoji.m_degKakudo / 180.0 * M_PI);
creationInterface->addText(d);
#ifdef FINISHED
QTextCodec* codec = QTextCodec::codecForName("SJIS");
RS_TextData data3(RS_Vector(0.0, 0.0),
10,//double height,
10,//double width,
RS2::VAlignMiddle,
RS2::HAlignCenter,
RS2::LeftToRight,
RS2::AtLeast,
1.0,//double lineSpacingFactor,
RS_String(""),//const RS_String& text,
RS_String(""),
0.0,//double angle,
RS2::Update);
RS_Text* text;
data3.insertionPoint = RS_Vector(DMoji.m_start.x, DMoji.m_start.y);
data3.height = DMoji.m_dSizeY;
data3.width = DMoji.m_dSizeX;
data3.valign = RS2::VAlignBottom;//VAlignMiddle;
data3.halign = RS2::HAlignLeft;//HAlignCenter;
data3.drawingDirection = RS2::LeftToRight;
data3.lineSpacingStyle = RS2::Exact;
data3.lineSpacingFactor = DMoji.m_dKankaku;//1.0;
//コード変換
size_t left = DMoji.m_string.length();
char* sjis = (char *)DMoji.m_string.c_str();
char buf[200];
//memset(buf, NULL, 1000);
char* p = buf;
size_t bufleft = 200;
#ifdef _WINDOWS
// エンコーディングの変換：iconvを使う場合
iconv_t cd = iconv_open(UTF8_CES, SHIFTJIS_CES);
#ifdef DEBUG
printf("sjis = %x, p = %x\n", sjis, p);
#endif
size_t r = iconv(cd, (const char **)(&sjis), &left, &p, &bufleft);//const_cast<char**>
#ifdef DEBUG
printf("sjis = %x, p = %x\n", sjis, p);
printf("sjis = %x %x %x %x, p = %x %x %x %x\n", sjis[0],sjis[1],sjis[2],sjis[3], buf[0],buf[1],buf[2],buf[3]);
printf("r = %d, left = %d, bufleft = %d\n", r, left, bufleft);
#endif
*p = '\0';
iconv_close(cd);
#else
// int ires = SJIS2UTF8N(sjis,buf,bufleft);
int nBytesOut;
strcpy(buf,(const char *)CUnicodeF::sjis_to_euc((const unsigned char *)sjis/*, &nBytesOut*/));
// QTextCodec* codec = QTextCodec::codecForName("eucJP");
// data3.text = codec->toUnicode(buf);
#endif
// data3.text = codec->toUnicode(sjis);
data3.text = RS_String::fromUtf8(buf);
data3.style = RS_String("japanese-euc");
data3.angle = DMoji.m_degKakudo / 180.0 * M_PI;
#ifdef DEBUG
RS_DEBUG->setLevel(RS_Debug::D_DEBUGGING);
#endif
data3.updateMode = RS2::Update;
//jwDWORD m_nMojiShu;//文字種(斜体文字は20000、ボールド体は10000を加えた数値)
text = new RS_Text(graphic, data3);
RS2::LineType ltype = lTable[DMoji.m_nPenStyle];
RS_Color col = colTable[DMoji.m_nPenColor];
RS2::LineWidth lw = lWidth[DMoji.m_nPenWidth > 26 ? 0 : DMoji.m_nPenWidth];//RS2::Width12
text->setPen(RS_Pen(col, RS2::Width08, ltype));
//画層設定
RS_String lName = HEX[DMoji.m_nGLayer > 0x0f ? 0: DMoji.m_nGLayer] + "-" +
HEX[DMoji.m_nLayer > 0x0f ? 0 : DMoji.m_nLayer];
if( graphic->findLayer(lName) == (RS_Layer*)NULL ){
#ifdef DEBUG
std::cout << lName.ascii() << std::endl;
#endif
RS_Layer* layer = new RS_Layer(lName);
graphic->addLayer(layer);
}
text->setLayer(lName);
// add the line to the graphic
graphic->addEntity(text);
#ifdef DEBUG
std::cout << data3.height << " " << data3.width << std::endl;
std::cout << *text;
#endif
#endif
}
/**
* 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_DimAngular::update(bool /*autoText*/) {
RS_DEBUG->print("RS_DimAngular::update");
clear();
if (isUndone()) {
return;
}
// distance from entities (DIMEXO)
double dimexo = getExtensionLineOffset();
// extension line extension (DIMEXE)
double dimexe = getExtensionLineExtension();
// text height (DIMTXT)
double dimtxt = getTextHeight();
// text distance to line (DIMGAP)
double dimgap = getDimensionLineGap();
// find out center:
RS_Vector center = getCenter();
if (!center.valid) {
return;
}
double ang1 = 0.0;
double ang2 = 0.0;
bool reversed = false;
RS_Vector p1;
RS_Vector p2;
getAngles(ang1, ang2, reversed, p1, p2);
double rad = edata.definitionPoint4.distanceTo(center);
RS_Line* line;
RS_Vector dir;
double len;
double dist;
// 1st extension line:
dist = center.distanceTo(p1);
len = rad - dist + dimexe;
dir.setPolar(1.0, ang1);
line = new RS_Line(this,
RS_LineData(center + dir*dist + dir*dimexo,
center + dir*dist + dir*len));
line->setPen(RS_Pen(RS2::FlagInvalid));
line->setLayer(NULL);
addEntity(line);
// 2nd extension line:
dist = center.distanceTo(p2);
len = rad - dist + dimexe;
dir.setPolar(1.0, ang2);
line = new RS_Line(this,
RS_LineData(center + dir*dist + dir*dimexo,
center + dir*dist + dir*len));
line->setPen(RS_Pen(RS2::FlagInvalid));
line->setLayer(NULL);
addEntity(line);
// Create dimension line (arc):
RS_Arc* arc = new RS_Arc(this,
RS_ArcData(center,
rad, ang1, ang2, reversed));
arc->setPen(RS_Pen(RS2::FlagInvalid));
arc->setLayer(NULL);
addEntity(arc);
// length of dimension arc:
double distance = arc->getLength();
// do we have to put the arrows outside of the arc?
bool outsideArrows = (distance<getArrowSize()*2);
// arrow angles:
double arrowAngle1, arrowAngle2;
double arrowAng;
if (rad>1.0e-6) {
arrowAng = getArrowSize() / rad;
}
else {
arrowAng = 0.0;
}
RS_Vector v1, v2;
if (!arc->isReversed()) {
v1.setPolar(rad, arc->getAngle1()+arrowAng);
} else {
v1.setPolar(rad, arc->getAngle1()-arrowAng);
}
v1+=arc->getCenter();
arrowAngle1 = arc->getStartpoint().angleTo(v1);
if (!arc->isReversed()) {
v2.setPolar(rad, arc->getAngle2()-arrowAng);
} else {
v2.setPolar(rad, arc->getAngle2()+arrowAng);
}
v2+=arc->getCenter();
arrowAngle2 = arc->getEndpoint().angleTo(v2);
if (!outsideArrows) {
arrowAngle1 = arrowAngle1+M_PI;
arrowAngle2 = arrowAngle2+M_PI;
}
// Arrows:
RS_SolidData sd;
RS_Solid* arrow;
// arrow 1
arrow = new RS_Solid(this, sd);
arrow->shapeArrow(arc->getStartpoint(),
arrowAngle1,
getArrowSize());
arrow->setPen(RS_Pen(RS2::FlagInvalid));
arrow->setLayer(NULL);
addEntity(arrow);
// arrow 2:
arrow = new RS_Solid(this, sd);
arrow->shapeArrow(arc->getEndpoint(),
arrowAngle2,
getArrowSize());
arrow->setPen(RS_Pen(RS2::FlagInvalid));
arrow->setLayer(NULL);
addEntity(arrow);
// text label:
RS_TextData textData;
RS_Vector textPos = arc->getMiddlePoint();
RS_Vector distV;
double textAngle;
double dimAngle1 = textPos.angleTo(arc->getCenter())-M_PI/2.0;
// rotate text so it's readable from the bottom or right (ISO)
// quadrant 1 & 4
if (dimAngle1>M_PI/2.0*3.0+0.001 ||
dimAngle1<M_PI/2.0+0.001) {
distV.setPolar(dimgap, dimAngle1+M_PI/2.0);
textAngle = dimAngle1;
}
// quadrant 2 & 3
else {
distV.setPolar(dimgap, dimAngle1-M_PI/2.0);
textAngle = dimAngle1+M_PI;
}
// move text away from dimension line:
textPos+=distV;
textData = RS_TextData(textPos,
dimtxt, 30.0,
RS2::VAlignBottom,
RS2::HAlignCenter,
RS2::LeftToRight,
RS2::Exact,
1.0,
getLabel(),
"standard",
textAngle);
RS_Text* text = new RS_Text(this, textData);
// move text to the side:
text->setPen(RS_Pen(RS2::FlagInvalid));
text->setLayer(NULL);
addEntity(text);
calculateBorders();
}
/**
* Testing function.
*/
void LC_SimpleTests::slotTestInsertText() {
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_Text* text;
RS_TextData textData;
textData = RS_TextData(RS_Vector(10.0,10.0),RS_Vector(10.0,10.0),
10.0, 1.0,
RS_TextData::VABaseline,
RS_TextData::HALeft,
RS_TextData::None,
"LibreCAD",
"iso",
0.0);
text = new RS_Text(graphic, textData);
text->setLayerToActive();
text->setPen(RS_Pen(RS_Color(255, 0, 0),
RS2::Width01,
RS2::SolidLine));
graphic->addEntity(text);
/*
double x, y;
for (y=-250.0; y<=250.0; y+=50.0) {
for (x=-250.0; x<=250.0; x+=50.0) {
RS_Vector v(x, y);
textData = RS_TextData(v,
10.0, 100.0,
RS2::VAlignTop,
RS2::HAlignLeft,
RS2::LeftToRight,
RS2::Exact,
1.0,
"Andrew",
"normal",
0.0);
text = new RS_Text(graphic, textData);
text->setLayerToActive();
text->setPen(RS_Pen(RS_Color(255, 0, 0),
RS2::Width01,
RS2::SolidLine));
graphic->addEntity(text);
}
}
RS_Line* line;
for (x=0.0; x<M_PI*2.0; x+=0.2) {
RS_Vector v(600.0+cos(x)*50.0, 0.0+sin(x)*50.0);
line = new RS_Line(graphic,
RS_LineData(RS_Vector(600.0,0.0),
v));
line->setLayerToActive();
line->setPenToActive();
graphic->addEntity(line);
textData = RS_TextData(v,
5.0, 50.0,
RS2::VAlignTop,
RS2::HAlignLeft,
RS2::LeftToRight,
RS2::Exact,
1.0,
"Andrew",
"normal",
x);
text = new RS_Text(graphic, textData);
text->setLayerToActive();
text->setPen(RS_Pen(RS_Color(255, 0, 0),
RS2::Width01,
RS2::SolidLine));
graphic->addEntity(text);
}
RS_SolidData solidData = RS_SolidData(RS_Vector(5.0, 10.0),
RS_Vector(25.0, 15.0),
RS_Vector(15.0, 30.0));
RS_Solid* s = new RS_Solid(graphic, solidData);
s->setLayerToActive();
s->setPen(RS_Pen(RS_Color(255, 255, 0),
RS2::Width01,
RS2::SolidLine));
graphic->addEntity(s);
RS_GraphicView* v = getGraphicView();
if (v) {
v->redraw();
}
*/
}
RS_DEBUG->print("%s\n: end\n", __func__);
}
/**
* 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__);
}
void Plugin_Entity::updateData(QHash<int, QVariant> *data){
if (entity == NULL) return;
QHash<int, QVariant> hash = *data;
QString str;
RS_Vector vec;
RS_Pen epen = entity->getPen();
// double num;
if (hash.contains(DPI::LAYER)) {
str = (hash.take(DPI::LAYER)).toString();
entity->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);
}
entity->setPen(epen);
RS2::EntityType et = entity->rtti();
switch (et) {
//atomicEntity
case RS2::EntityLine: {
vec = static_cast<RS_Line*>(entity)->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*>(entity)->setStartpoint(vec);
vec = static_cast<RS_Line*>(entity)->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*>(entity)->setEndpoint(vec);
break;}
case RS2::EntityPoint: {
vec = static_cast<RS_Point*>(entity)->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*>(entity)->setPos(vec);
break; }
case RS2::EntityArc: {
RS_Arc *arc = static_cast<RS_Arc*>(entity);
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*>(entity);
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*>(entity);
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: {
break;}
case RS2::EntityOverlayBox:
//Unused ?
break;
//EntityContainer
case RS2::EntityInsert: {
break;}
case RS2::EntityText: {
RS_Text *txt = static_cast<RS_Text*>(entity);
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*>(entity);
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;
}
entity->update();
}