void RS_ActionDrawArcTangential::mouseReleaseEvent(QMouseEvent* e) {
if (e->button()==Qt::LeftButton) {
switch (getStatus()) {
// set base entity:
case SetBaseEntity: {
RS_Vector coord = graphicView->toGraph(e->x(), e->y());
RS_Entity* entity = catchEntity(coord, RS2::ResolveAll);
if (entity) {
if (entity->isAtomic()) {
baseEntity = static_cast<RS_AtomicEntity*>(entity);
if (baseEntity->getStartpoint().distanceTo(coord) <
baseEntity->getEndpoint().distanceTo(coord)) {
isStartPoint = true;
} else {
isStartPoint = false;
}
setStatus(SetEndAngle);
updateMouseButtonHints();
}
}
}
break;
// set angle (point that defines the angle)
case SetEndAngle: {
RS_CoordinateEvent ce(snapPoint(e));
coordinateEvent(&ce);
}
break;
}
} else if (e->button()==Qt::RightButton) {
deletePreview();
init(getStatus()-1);
}
}
void RS_ActionDrawNephroid::mouseMoveEvent(QMouseEvent* e) {
snapPoint(e);
}
void RS_ActionPolylineTrim::mouseReleaseEvent(QMouseEvent* e) {
if (e->button()==Qt::LeftButton) {
RS_Vector cPoint;
switch (getStatus()) {
case ChooseEntity:
delEntity = catchEntity(e);
if (delEntity==NULL) {
RS_DIALOGFACTORY->commandMessage(tr("No Entity found."));
} else if (delEntity->rtti()!=RS2::EntityPolyline) {
RS_DIALOGFACTORY->commandMessage(
tr("Entity must be a polyline."));
} else {
delEntity->setHighlighted(true);
graphicView->drawEntity(delEntity);
setStatus(SetSegment1);
////////////////////////////////////////2006/06/15
graphicView->redraw();
////////////////////////////////////////
}
break;
case SetSegment1:
cPoint = snapPoint(e);
if (delEntity==NULL) {
RS_DIALOGFACTORY->commandMessage(tr("No Entity found."));
} else if (!cPoint.valid) {
RS_DIALOGFACTORY->commandMessage(tr("Specifying point is invalid."));
} else if (!delEntity->isPointOnEntity(cPoint)) {
RS_DIALOGFACTORY->commandMessage(
tr("No Segment found on entity."));
}else{
Segment1 = NULL;
double dist = graphicView->toGraphDX(snapRange)*0.9;
Segment1 = (RS_AtomicEntity*)((RS_Polyline*)delEntity)->getNearestEntity( RS_Vector(graphicView->toGraphX(e->x()),
graphicView->toGraphY(e->y())), &dist, RS2::ResolveNone);
if(Segment1 == NULL)
break;
setStatus(SetSegment2);
}
break;
case SetSegment2:
cPoint = snapPoint(e);
if (delEntity==NULL) {
RS_DIALOGFACTORY->commandMessage(tr("No Entity found."));
} else if (!cPoint.valid) {
RS_DIALOGFACTORY->commandMessage(tr("Specifying point is invalid."));
} else if (!delEntity->isPointOnEntity(cPoint)) {
RS_DIALOGFACTORY->commandMessage(
tr("No Segment found on entity."));
}else{
Segment2 = NULL;
double dist = graphicView->toGraphDX(snapRange)*0.9;
Segment2 = (RS_AtomicEntity*)((RS_Polyline*)delEntity)->getNearestEntity( RS_Vector(graphicView->toGraphX(e->x()),
graphicView->toGraphY(e->y())), &dist, RS2::ResolveNone);
if(Segment2 == NULL)
break;
deleteSnapper();
trigger();
}
break;
default:
break;
}
} else if (e->button()==Qt::RightButton) {
deleteSnapper();
if (delEntity) {
delEntity->setHighlighted(false);
graphicView->drawEntity(delEntity);
////////////////////////////////////////2006/06/15
graphicView->redraw();
////////////////////////////////////////
}
init(getStatus()-1);
}
}
void RS_ActionDefault::mouseMoveEvent(QMouseEvent* e) {
RS_Vector mouse = graphicView->toGraph(RS_Vector(e->x(), e->y()));
RS_Vector relMouse = mouse - graphicView->getRelativeZero();
RS_DIALOGFACTORY->updateCoordinateWidget(mouse, relMouse);
switch (getStatus()) {
case Neutral:
deleteSnapper();
break;
case Dragging:
//v2 = graphicView->toGraph(e->x(), e->y());
v2 = mouse;
if (graphicView->toGuiDX(v1.distanceTo(v2))>10) {
// look for reference points to drag:
double dist;
RS_Vector ref = container->getNearestSelectedRef(v1, &dist);
if (ref.valid==true && graphicView->toGuiDX(dist)<8) {
RS_DEBUG->print("RS_ActionDefault::mouseMoveEvent: "
"moving reference point");
setStatus(MovingRef);
v1 = ref;
graphicView->moveRelativeZero(v1);
}
else {
// test for an entity to drag:
RS_Entity* en = catchEntity(v1);
if (en!=NULL && en->isSelected()) {
RS_DEBUG->print("RS_ActionDefault::mouseMoveEvent: "
"moving entity");
setStatus(Moving);
v1 = en->getNearestRef(v1);
graphicView->moveRelativeZero(v1);
}
// no entity found. start area selection:
else {
setStatus(SetCorner2);
}
}
}
break;
case MovingRef:
v2 = snapPoint(e);
deletePreview();
preview->addSelectionFrom(*container);
preview->moveRef(v1, v2-v1);
drawPreview();
break;
case Moving:
v2 = snapPoint(e);
deletePreview();
preview->addSelectionFrom(*container);
preview->move(v2-v1);
drawPreview();
break;
case SetCorner2:
if (v1.valid) {
v2 = mouse;
deletePreview();
RS_OverlayBox* ob=new RS_OverlayBox(preview, RS_OverlayBoxData(v1, v2));
preview->addEntity(ob);
drawPreview();
}
default:
break;
}
}
void RS_ActionSetRelativeZero::mouseMoveEvent(RS_MouseEvent* e) {
snapPoint(e);
}
Point2d MgCommandDraw::snapPoint(const MgMotion* sender, bool firstStep)
{
return snapPoint(sender, sender->pointM, firstStep);
}
void RS_ActionPolylineDelBetween::mouseReleaseEvent(RS_MouseEvent* e) {
if (RS2::qtToRsButtonState(e->button())==RS2::LeftButton) {
switch (getStatus()) {
case ChooseSegment:
delEntity = catchEntity(e);
if (delEntity==NULL) {
RS_DIALOGFACTORY->commandMessage(tr("No Entity found."));
} else if (delEntity->rtti()!=RS2::EntityPolyline) {
RS_DIALOGFACTORY->commandMessage(
tr("Entity must be a polyline."));
} else {
RS_Vector clickCoord = snapPoint(e);
delSegment = NULL;
double dist = graphicView->toGraphDX(snapRange)*0.9;
delSegment = (RS_AtomicEntity*)((RS_Polyline*)delEntity)->getNearestEntity( RS_Vector(graphicView->toGraphX(e->x()),
graphicView->toGraphY(e->y())), &dist, RS2::ResolveNone);
if(delSegment == NULL)
break;
delEntity->setHighlighted(true);
graphicView->drawEntity(delEntity);
setStatus(SetNodePoint1);
////////////////////////////////////////2006/06/15
graphicView->redraw();
////////////////////////////////////////
}
break;
case SetNodePoint1:
nodePoint1 = snapPoint(e);
if (delEntity==NULL) {
RS_DIALOGFACTORY->commandMessage(tr("No Entity found."));
} else if (!nodePoint1.valid) {
RS_DIALOGFACTORY->commandMessage(tr("Deletinging point is invalid."));
} else if (!delEntity->isPointOnEntity(nodePoint1)) {
RS_DIALOGFACTORY->commandMessage(
tr("Deleting point is not on entity."));
}else{
setStatus(SetNodePoint2);
}
break;
case SetNodePoint2:
nodePoint2 = snapPoint(e);
if (delEntity==NULL) {
RS_DIALOGFACTORY->commandMessage(tr("No Entity found."));
} else if (!nodePoint2.valid) {
RS_DIALOGFACTORY->commandMessage(tr("Deletinging point is invalid."));
} else if (!delEntity->isPointOnEntity(nodePoint2)) {
RS_DIALOGFACTORY->commandMessage(
tr("Deleteinging point is not on entity."));
} else {
deleteSnapper();
trigger();
}
break;
default:
break;
}
} else if (RS2::qtToRsButtonState(e->button())==RS2::RightButton) {
deleteSnapper();
if (delEntity!=NULL) {
delEntity->setHighlighted(false);
graphicView->drawEntity(delEntity);
////////////////////////////////////////2006/06/15
graphicView->redraw();
////////////////////////////////////////
}
init(getStatus()-1);
}
}
void RS_ActionDrawEllipseAxis::mouseMoveEvent(QMouseEvent* e) {
RS_DEBUG->print("RS_ActionDrawEllipseAxis::mouseMoveEvent begin");
RS_Vector mouse = snapPoint(e);
switch (getStatus()) {
case SetCenter:
break;
case SetMajor:
if (center.valid) {
deletePreview();
RS_EllipseData ed(center, mouse-center,
0.5,
0.0, isArc?2.*M_PI:0.0,
false);
preview->addEntity(new RS_Ellipse(preview, ed));
drawPreview();
}
break;
case SetMinor:
if (center.valid && major.valid) {
deletePreview();
RS_Line line(NULL, RS_LineData(center-major, center+major));
double d = line.getDistanceToPoint(mouse);
ratio = d/(line.getLength()/2);
RS_EllipseData ed(center, major,
ratio,
0.0, isArc?2.*M_PI:0.0,
false);
preview->addEntity(new RS_Ellipse(preview, ed));
drawPreview();
}
break;
case SetAngle1:
if (center.valid && major.valid) {
deletePreview();
//angle1 = center.angleTo(mouse);
RS_Vector m = mouse;
m.rotate(center, -major.angle());
RS_Vector v = m-center;
v.scale(RS_Vector(1.0, 1.0/ratio));
angle1 = v.angle(); // + major.angle();
preview->addEntity(new RS_Line(preview, RS_LineData(center, mouse)));
RS_EllipseData ed(center, major,
ratio,
angle1, angle1+1.0,
false);
preview->addEntity(new RS_Ellipse(preview, ed));
drawPreview();
}
break;
case SetAngle2:
if (center.valid && major.valid) {
deletePreview();
//angle2 = center.angleTo(mouse);
RS_Vector m = mouse;
m.rotate(center, -major.angle());
RS_Vector v = m-center;
v.scale(RS_Vector(1.0, 1.0/ratio));
angle2 = v.angle(); // + major.angle();
preview->addEntity(new RS_Line(preview, RS_LineData(center, mouse)));
RS_EllipseData ed(
center, major,
ratio,
angle1, angle2,
false);
preview->addEntity(new RS_Ellipse(preview, ed));
drawPreview();
}
default:
break;
}
RS_DEBUG->print("RS_ActionDrawEllipseAxis::mouseMoveEvent end");
}
void RS_ActionDrawEpicycloid::mouseMoveEvent(QMouseEvent* e) {
snapPoint(e);
}
void RS_ActionDrawStar::mouseMoveEvent(QMouseEvent* e) {
snapPoint(e);
}
void RS_ActionDrawEllipseAxis::mouseMoveEvent(QMouseEvent* e) {
RS_DEBUG->print("RS_ActionDrawEllipseAxis::mouseMoveEvent begin");
RS_Vector mouse = snapPoint(e);
switch (getStatus()) {
// case SetCenter:
// break;
case SetMajor:
if (pPoints->center.valid) {
deletePreview();
preview->addEntity(new RS_Ellipse{preview.get(),
{pPoints->center, mouse-pPoints->center, 0.5, 0.0,
pPoints->isArc?2.*M_PI:0.
, false}});
drawPreview();
}
break;
case SetMinor:
if (pPoints->center.valid && pPoints->m_vMajorP.valid) {
deletePreview();
RS_Line line{pPoints->center-pPoints->m_vMajorP, pPoints->center+pPoints->m_vMajorP};
double d = line.getDistanceToPoint(mouse);
pPoints->ratio = d/(line.getLength()/2);
preview->addEntity(new RS_Ellipse{preview.get(),
{pPoints->center, pPoints->m_vMajorP, pPoints->ratio, 0., pPoints->isArc?2.*M_PI:0.
, false}});
drawPreview();
}
break;
case SetAngle1:
if (pPoints->center.valid && pPoints->m_vMajorP.valid) {
deletePreview();
//angle1 = center.angleTo(mouse);
RS_Vector m = mouse;
m.rotate(pPoints->center, -pPoints->m_vMajorP.angle());
RS_Vector v = m-pPoints->center;
v.y /= pPoints->ratio;
pPoints->angle1 = v.angle(); // + m_vMajorP.angle();
preview->addEntity(new RS_Line{preview.get(), pPoints->center, mouse});
preview->addEntity(new RS_Ellipse{preview.get(),
{pPoints->center, pPoints->m_vMajorP, pPoints->ratio, pPoints->angle1, pPoints->angle1+1.0
, false}});
drawPreview();
}
break;
case SetAngle2:
if (pPoints->center.valid && pPoints->m_vMajorP.valid) {
deletePreview();
//angle2 = center.angleTo(mouse);
RS_Vector m = mouse;
m.rotate(pPoints->center, -pPoints->m_vMajorP.angle());
RS_Vector v = m-pPoints->center;
v.y /= pPoints->ratio;
pPoints->angle2 = v.angle(); // + m_vMajorP.angle();
preview->addEntity(new RS_Line{preview.get(), pPoints->center, mouse});
preview->addEntity(new RS_Ellipse{preview.get(),
{pPoints->center, pPoints->m_vMajorP,
pPoints->ratio,
pPoints->angle1, pPoints->angle2
, false}});
drawPreview();
}
default:
break;
}
RS_DEBUG->print("RS_ActionDrawEllipseAxis::mouseMoveEvent end");
}
void RS_ActionModifyStretch::mouseMoveEvent(QMouseEvent* e) {
RS_DEBUG->print("RS_ActionModifyStretch::mouseMoveEvent begin");
RS_Vector mouse = snapPoint(e);
switch (getStatus()) {
case SetFirstCorner:
break;
case SetSecondCorner:
if (firstCorner.valid) {
secondCorner = snapPoint(e);
deletePreview();
preview->addEntity(
new RS_Line(preview,
RS_LineData(RS_Vector(firstCorner.x,
firstCorner.y),
RS_Vector(secondCorner.x,
firstCorner.y))));
preview->addEntity(
new RS_Line(preview,
RS_LineData(RS_Vector(secondCorner.x,
firstCorner.y),
RS_Vector(secondCorner.x,
secondCorner.y))));
preview->addEntity(
new RS_Line(preview,
RS_LineData(RS_Vector(secondCorner.x,
secondCorner.y),
RS_Vector(firstCorner.x,
secondCorner.y))));
preview->addEntity(
new RS_Line(preview,
RS_LineData(RS_Vector(firstCorner.x,
secondCorner.y),
RS_Vector(firstCorner.x,
firstCorner.y))));
drawPreview();
}
break;
case SetReferencePoint:
break;
case SetTargetPoint:
if (referencePoint.valid) {
targetPoint = mouse;
deletePreview();
preview->addStretchablesFrom(*container, firstCorner, secondCorner);
//preview->move(targetPoint-referencePoint);
preview->stretch(firstCorner, secondCorner,
targetPoint-referencePoint);
drawPreview();
}
break;
default:
break;
}
RS_DEBUG->print("RS_ActionModifyStretch::mouseMoveEvent end");
}
/**
* Snap to a coordinate in the drawing using the current snap mode.
*
* @param e A mouse event.
* @return The coordinates of the point or an invalid vector.
*/
RS_Vector RS_Snapper::snapPoint(QMouseEvent* e) {
RS_DEBUG->print("RS_Snapper::snapPoint");
pImpData->snapSpot = RS_Vector(false);
RS_Vector t(false);
if (!e) {
RS_DEBUG->print(RS_Debug::D_WARNING,
"RS_Snapper::snapPoint: event is nullptr");
return pImpData->snapSpot;
}
RS_Vector mouseCoord = graphicView->toGraph(e->x(), e->y());
double ds2Min=RS_MAXDOUBLE*RS_MAXDOUBLE;
if (snapMode.snapEndpoint) {
t = snapEndpoint(mouseCoord);
double ds2=mouseCoord.squaredTo(t);
if (ds2 < ds2Min){
ds2Min=ds2;
pImpData->snapSpot = t;
}
}
if (snapMode.snapCenter) {
t = snapCenter(mouseCoord);
double ds2=mouseCoord.squaredTo(t);
if (ds2 < ds2Min){
ds2Min=ds2;
pImpData->snapSpot = t;
}
}
if (snapMode.snapMiddle) {
//this is still brutal force
//todo: accept value from widget QG_SnapMiddleOptions
if(RS_DIALOGFACTORY ) {
RS_DIALOGFACTORY->requestSnapMiddleOptions(middlePoints, snapMode.snapMiddle);
}
t = snapMiddle(mouseCoord);
double ds2=mouseCoord.squaredTo(t);
if (ds2 < ds2Min){
ds2Min=ds2;
pImpData->snapSpot = t;
}
}
if (snapMode.snapDistance) {
//this is still brutal force
//todo: accept value from widget QG_SnapDistOptions
if(RS_DIALOGFACTORY ) {
RS_DIALOGFACTORY->requestSnapDistOptions(m_SnapDistance, snapMode.snapDistance);
}
t = snapDist(mouseCoord);
double ds2=mouseCoord.squaredTo(t);
if (ds2 < ds2Min){
ds2Min=ds2;
pImpData->snapSpot = t;
}
}
if (snapMode.snapIntersection) {
t = snapIntersection(mouseCoord);
double ds2=mouseCoord.squaredTo(t);
if (ds2 < ds2Min){
ds2Min=ds2;
pImpData->snapSpot = t;
}
}
if (snapMode.snapOnEntity &&
pImpData->snapSpot.distanceTo(mouseCoord) > snapMode.distance) {
t = snapOnEntity(mouseCoord);
double ds2=mouseCoord.squaredTo(t);
if (ds2 < ds2Min){
ds2Min=ds2;
pImpData->snapSpot = t;
}
}
if (snapMode.snapGrid) {
t = snapGrid(mouseCoord);
double ds2=mouseCoord.squaredTo(t);
if (ds2 < ds2Min){
ds2Min=ds2;
pImpData->snapSpot = t;
}
}
if( !pImpData->snapSpot.valid ) {
pImpData->snapSpot=mouseCoord; //default to snapFree
} else {
// std::cout<<"mouseCoord.distanceTo(snapSpot)="<<mouseCoord.distanceTo(snapSpot)<<std::endl;
// std::cout<<"snapRange="<<snapRange<<std::endl;
//retreat to snapFree when distance is more than half grid
if(snapMode.snapFree){
RS_Vector const& ds=mouseCoord - pImpData->snapSpot;
RS_Vector const& grid=graphicView->getGrid()->getCellVector()*0.5;
if( fabs(ds.x) > fabs(grid.x) || fabs(ds.y) > fabs(grid.y) ) pImpData->snapSpot = mouseCoord;
}
//another choice is to keep snapRange in GUI coordinates instead of graph coordinates
// if (mouseCoord.distanceTo(snapSpot) > snapRange ) snapSpot = mouseCoord;
}
//if (snapSpot.distanceTo(mouseCoord) > snapMode.distance) {
// handle snap restrictions that can be activated in addition
// to the ones above:
//apply restriction
RS_Vector rz = graphicView->getRelativeZero();
RS_Vector vpv(rz.x, pImpData->snapSpot.y);
RS_Vector vph(pImpData->snapSpot.x,rz.y);
switch (snapMode.restriction) {
case RS2::RestrictOrthogonal:
pImpData->snapCoord= ( mouseCoord.distanceTo(vpv)< mouseCoord.distanceTo(vph))?
vpv:vph;
break;
case RS2::RestrictHorizontal:
pImpData->snapCoord = vph;
break;
case RS2::RestrictVertical:
pImpData->snapCoord = vpv;
break;
//case RS2::RestrictNothing:
default:
pImpData->snapCoord = pImpData->snapSpot;
break;
}
//}
//else snapCoord = snapSpot;
snapPoint(pImpData->snapSpot, false);
//If the cursor is too-close to the snapSpot (by number of screen pixels), then hide it.
if (graphicView->toGui(pImpData->snapSpot).distanceTo(graphicView->toGui(mouseCoord)) < 32 /* xenoRadius */)
{
graphicView->setCursor(Qt::BlankCursor);
}
else
{
graphicView->setCursor(Qt::CrossCursor);
}
return pImpData->snapCoord;
}
void RS_ActionDrawArc::mouseMoveEvent(QMouseEvent* e) {
RS_DEBUG->print("RS_ActionDrawArc::mouseMoveEvent begin");
RS_Vector mouse = snapPoint(e);
switch (getStatus()) {
case SetCenter:
data.center = mouse;
break;
case SetRadius:
if (data.center.valid) {
data.radius = data.center.distanceTo(mouse);
deletePreview();
preview->addEntity(new RS_Circle(preview,
RS_CircleData(data.center,
data.radius)));
drawPreview();
}
break;
case SetAngle1:
data.angle1 = data.center.angleTo(mouse);
if (data.reversed) {
data.angle2 = RS_Math::correctAngle(data.angle1-M_PI/3);
} else {
data.angle2 = RS_Math::correctAngle(data.angle1+M_PI/3);
}
deletePreview();
preview->addEntity(new RS_Arc(preview,
data));
drawPreview();
break;
case SetAngle2:
data.angle2 = data.center.angleTo(mouse);
deletePreview();
preview->addEntity(new RS_Arc(preview,
data));
drawPreview();
break;
case SetIncAngle:
data.angle2 = data.angle1 + data.center.angleTo(mouse);
deletePreview();
preview->addEntity(new RS_Arc(preview,
data));
drawPreview();
break;
case SetChordLength: {
double x = data.center.distanceTo(mouse);
if (fabs(x/(2*data.radius))<=1.0) {
data.angle2 = data.angle1 + asin(x/(2*data.radius)) * 2;
deletePreview();
preview->addEntity(new RS_Arc(preview,
data));
drawPreview();
}
}
break;
default:
break;
}
RS_DEBUG->print("RS_ActionDrawArc::mouseMoveEvent end");
}
void RS_ActionDimAngular::mouseReleaseEvent(QMouseEvent* e) {
if (e->button()==Qt::LeftButton) {
switch (getStatus()) {
case SetLine1: {
RS_Entity* en = catchEntity(e, RS2::ResolveAll);
if (en!=NULL &&
en->rtti()==RS2::EntityLine) {
line1 = (RS_Line*)en;
setStatus(SetLine2);
}
}
break;
case SetLine2: {
RS_Entity* en = catchEntity(e, RS2::ResolveAll);
if (en!=NULL &&
en->rtti()==RS2::EntityLine) {
line2 = (RS_Line*)en;
RS_VectorSolutions sol =
RS_Information::getIntersectionLineLine(line1, line2);
if (sol.get(0).valid) {
center = sol.get(0);
if (center.distanceTo(line1->getStartpoint()) <
center.distanceTo(line1->getEndpoint())) {
edata->definitionPoint1 = line1->getStartpoint();
edata->definitionPoint2 = line1->getEndpoint();
} else {
edata->definitionPoint1 = line1->getEndpoint();
edata->definitionPoint2 = line1->getStartpoint();
}
if (center.distanceTo(line2->getStartpoint()) <
center.distanceTo(line2->getEndpoint())) {
edata->definitionPoint3 = line2->getStartpoint();
data->definitionPoint = line2->getEndpoint();
} else {
edata->definitionPoint3 = line2->getEndpoint();
data->definitionPoint = line2->getStartpoint();
}
graphicView->moveRelativeZero(center);
setStatus(SetPos);
}
}
}
break;
case SetPos: {
RS_CoordinateEvent ce(snapPoint(e));
coordinateEvent(&ce);
}
break;
}
} else if (e->button()==Qt::RightButton) {
deletePreview();
init(getStatus()-1);
}
}
void RS_ActionDrawCircleTan1_2P::mouseMoveEvent(QMouseEvent* e) {
RS_DEBUG->print("RS_ActionDrawCircleTan1_2P::mouseMoveEvent begin");
switch(getStatus() ){
case SetPoint1:
{
RS_Vector&& mouse=snapPoint(e);
pPoints->points.clear();
pPoints->points.push_back(mouse);
switch(circle->rtti()){
case RS2::EntityArc:
case RS2::EntityCircle:
{
RS_Vector const& dvp=mouse - circle->getCenter();
double rvp=dvp.magnitude();
if(rvp<RS_TOLERANCE2) break;
pPoints->cData.radius=(circle->getRadius()+rvp)*0.5;
pPoints->cData.center=circle->getCenter()+dvp*(pPoints->cData.radius/rvp);
pPoints->cData.radius=fabs(circle->getRadius()-pPoints->cData.radius);
}
break;
case RS2::EntityLine:
{
RS_Line* line=static_cast<RS_Line*>(circle);
RS_Vector&& vp=line->getNearestPointOnEntity(pPoints->points[0],false);
if(vp.valid){
pPoints->cData.center=(vp+pPoints->points[0])*0.5;
pPoints->cData.radius=vp.distanceTo(pPoints->cData.center);
}
}
break;
default:
return;
}
deletePreview();
RS_Circle* e=new RS_Circle(preview.get(), pPoints->cData);
preview->addEntity(e);
drawPreview();
break;
}
case SetPoint2: {
RS_Vector const& mouse=snapPoint(e);
pPoints->points.resize(1);
pPoints->points.push_back(mouse);
deletePreview();
pPoints->coord=mouse;
if (!getCenters()) return;
if (preparePreview()) {
RS_Circle* e=new RS_Circle(preview.get(), pPoints->cData);
preview->addEntity(e);
drawPreview();
}
break;
}
case SetCenter: {
// RS_Entity* en = catchEntity(e, enTypeList, RS2::ResolveAll);
pPoints->coord= graphicView->toGraph(e->x(), e->y());
// circles[getStatus()]=static_cast<RS_Line*>(en);
if(preparePreview()) {
deletePreview();
RS_Circle* e=new RS_Circle(preview.get(), pPoints->cData);
for(size_t i=0; i<pPoints->centers.size(); ++i)
preview->addEntity(new RS_Point(preview.get(), RS_PointData(pPoints->centers.at(i))));
preview->addEntity(e);
// double r0=cData.radius*0.1;
// if(centers.size()>1)
// for(unsigned i=0; i< centers.size(); ++i){
// RS_DEBUG->print(RS_Debug::D_ERROR, "center %d: (%g, %g)\n",i,centers.at(i).x,centers.at(i).y);
// preview->addEntity(new RS_Circle(preview, RS_CircleData(centers.at(i), r0)));
// }
drawPreview();
}
}
break;
default:
break;
}
RS_DEBUG->print("RS_ActionDrawCircleTan1_2P::mouseMoveEvent end");
}
void RS_ActionDrawPoint::mouseMoveEvent(RS_MouseEvent* e) {
snapPoint(e);
}
