void RS_ActionDrawArc::mouseReleaseEvent(RS_MouseEvent* e) {
if (RS2::qtToRsButtonState(e->button())==RS2::LeftButton) {
RS_CoordinateEvent ce(snapPoint(e));
coordinateEvent(&ce);
} else if (RS2::qtToRsButtonState(e->button())==RS2::RightButton) {
deletePreview();
deleteSnapper();
init(getStatus()-1);
}
}
void RS_ActionInfoDist2::trigger() {
RS_DEBUG->print("RS_ActionInfoDist2::trigger()");
deleteSnapper();
if (point.valid && entity!=NULL) {
double dist = entity->getDistanceToPoint(point);
QString str;
str.sprintf("%.6f", dist);
RS_DIALOGFACTORY->commandMessage(tr("Distance: %1").arg(str));
}
}
void RS_ActionDefault::mousePressEvent(QMouseEvent* e) {
if (e->button()==Qt::LeftButton) {
switch (getStatus()) {
case Neutral:
v1 = graphicView->toGraph(e->x(), e->y());
setStatus(Dragging);
break;
case Moving: {
v2 = snapPoint(e);
deletePreview();
RS_Modification m(*container, graphicView);
RS_MoveData data;
data.number = 0;
data.useCurrentLayer = false;
data.useCurrentAttributes = false;
data.offset = v2-v1;
m.move(data);
setStatus(Neutral);
RS_DIALOGFACTORY->updateSelectionWidget(
container->countSelected(),container->totalSelectedLength());
RS_DIALOGFACTORY->requestToolBar(RS2::ToolBarMain);
deleteSnapper();
}
break;
case MovingRef: {
v2 = snapPoint(e);
deletePreview();
RS_Modification m(*container, graphicView);
RS_MoveRefData data;
data.ref = v1;
data.offset = v2-v1;
m.moveRef(data);
//container->moveSelectedRef(v1, v2-v2);
setStatus(Neutral);
RS_DIALOGFACTORY->updateSelectionWidget(
container->countSelected(),container->totalSelectedLength());
RS_DIALOGFACTORY->requestToolBar(RS2::ToolBarMain);
}
break;
default:
break;
}
} else if (e->button()==Qt::RightButton) {
//cleanup
setStatus(Neutral);
e->accept();
}
}
void RS_ActionPolylineAppend::coordinateEvent(RS_CoordinateEvent* e) {
if (!e) {
return;
}
RS_Vector mouse = e->getCoordinate();
switch (getStatus()) {
case SetStartpoint:
history.clear();
history.append(point);
bHistory.clear();
bHistory.append(0.0);
start = point;
setStatus(SetNextPoint);
graphicView->moveRelativeZero(point);
updateMouseButtonHints();
break;
case SetNextPoint:
graphicView->moveRelativeZero(mouse);
point = mouse;
history.append(mouse);
bHistory.append(0.0);
if (!polyline) {
polyline = new RS_Polyline(container, *data);
polyline->addVertex(start, 0.0, prepend);
}
if (polyline) {
polyline->addVertex(mouse, 0.0, prepend);
// polyline->setEndpoint(mouse);
if (polyline->count()==1) {
polyline->setLayerToActive();
polyline->setPenToActive();
}
// RVT_PORT (can be deleted) deletePreview();
//clearPreview();
deleteSnapper();
graphicView->drawEntity(polyline);
drawSnapper();
}
//trigger();
//data.startpoint = data.endpoint;
updateMouseButtonHints();
//graphicView->moveRelativeZero(mouse);
break;
default:
break;
}
}
void RS_ActionDrawLinePolygon2::commandEvent(RS_CommandEvent* e) {
RS_String c = e->getCommand().lower();
if (checkCommand("help", c)) {
if (RS_DIALOGFACTORY!=NULL) {
RS_DIALOGFACTORY->commandMessage(msgAvailableCommands()
+ getAvailableCommands().join(", "));
}
return;
}
switch (getStatus()) {
case SetCorner1:
case SetCorner2:
if (checkCommand("number", c)) {
deleteSnapper();
deletePreview();
clearPreview();
lastStatus = (Status)getStatus();
setStatus(SetNumber);
}
break;
case SetNumber: {
bool ok;
int n = c.toInt(&ok);
if (ok==true) {
if (n>0 && n<10000) {
number = n;
} else {
if (RS_DIALOGFACTORY!=NULL) {
RS_DIALOGFACTORY->commandMessage(tr("Not a valid number. "
"Try 1..9999"));
}
}
} else {
if (RS_DIALOGFACTORY!=NULL) {
RS_DIALOGFACTORY->commandMessage(tr("Not a valid expression."));
}
}
if (RS_DIALOGFACTORY!=NULL) {
RS_DIALOGFACTORY->requestOptions(this, true, true);
}
setStatus(lastStatus);
}
break;
default:
break;
}
}
/**
* Called to initiate an action. This funtcion is often
* overwritten by the implementing action.
*
* @param status The status on which to initiate this action.
* default is 0 to begin the action.
*/
void RS_ActionInterface::init(int status) {
RS_Snapper::init();
setStatus(status);
if (status>=0) {
//graphicView->setMouseCursor(cursor);
updateMouseButtonHints();
updateMouseCursor();
updateToolBar();
}else{
//delete snapper when finished, bug#3416878
deleteSnapper();
}
}
void RS_ActionDrawPolyline::mouseReleaseEvent(QMouseEvent* e) {
if (e->button()==Qt::LeftButton) {
RS_CoordinateEvent ce(snapPoint(e));
coordinateEvent(&ce);
} else if (e->button()==Qt::RightButton) {
if (getStatus()==SetNextPoint) {
trigger();
}
deletePreview();
// clearPreview();
deleteSnapper();
init(getStatus()-1);
}
}
void RS_ActionPolylineAppend::mouseReleaseEvent(QMouseEvent* e) {
if (e->button()==Qt::LeftButton) {
if (getStatus()==SetStartpoint) {
originalPolyline = dynamic_cast<RS_Polyline*>(catchEntity(e));
if (!originalPolyline) {
RS_DIALOGFACTORY->commandMessage(tr("No Entity found."));
return;
} else if (originalPolyline->rtti()!=RS2::EntityPolyline) {
RS_DIALOGFACTORY->commandMessage(
tr("Entity must be a polyline."));
return;
} else if (originalPolyline->isClosed()) {
RS_DIALOGFACTORY->commandMessage(
tr("Can not append nodes in a closed polyline."));
return;
} else {
snapPoint(e);
RS_Polyline* op=static_cast<RS_Polyline*>(originalPolyline);
RS_Entity* entFirst = op->firstEntity();
RS_Entity* entLast = op->lastEntity();
double dist = graphicView->toGraphDX(snapRange)*0.9;
RS_Entity* nearestSegment = originalPolyline->getNearestEntity( RS_Vector(graphicView->toGraphX(e->x()),
graphicView->toGraphY(e->y())), &dist, RS2::ResolveNone);
polyline = static_cast<RS_Polyline*>(originalPolyline->clone());
container->addEntity(polyline);
prepend = false;
if (nearestSegment == entFirst){
prepend = true;
point = originalPolyline->getStartpoint();
}else if (nearestSegment == entLast){
point = originalPolyline->getEndpoint();
}else{
RS_DIALOGFACTORY->commandMessage(
tr("Click somewhere near the beginning or end of existing polyline."));
}
}
}
RS_CoordinateEvent ce(snapPoint(e));
coordinateEvent(&ce);
} else if (e->button()==Qt::RightButton) {
if (getStatus()==SetNextPoint) {
trigger();
}
// deletePreview();
//clearPreview();
deleteSnapper();
init(getStatus()-1);
}
}
void RS_ActionDrawLinePolygon2::trigger() {
RS_PreviewActionInterface::trigger();
deleteSnapper();
deletePreview();
clearPreview();
RS_Creation creation(container, graphicView);
bool ok = creation.createPolygon2(corner1, corner2, number);
if (!ok) {
RS_DEBUG->print("RS_ActionDrawLinePolygon2::trigger:"
" No polygon added\n");
}
}
void RS_ActionDefault::init(int status) {
RS_DEBUG->print("RS_ActionDefault::init");
if(status==Neutral){
deletePreview();
deleteSnapper();
}
RS_PreviewActionInterface::init(status);
v1 = v2 = RS_Vector(false);
// snapMode.clear();
// snapMode.restriction = RS2::RestrictNothing;
// restrBak = RS2::RestrictNothing;
// RS_DIALOGFACTORY->requestToolBar(RS2::ToolBarMain);
RS_DEBUG->print("RS_ActionDefault::init: OK");
}
void RS_ActionPolylineEquidistant::mouseReleaseEvent(QMouseEvent* e) {
if (e->button()==Qt::LeftButton) {
switch (getStatus()) {
case ChooseEntity:
originalEntity = catchEntity(e);
if (originalEntity==NULL) {
RS_DIALOGFACTORY->commandMessage(tr("No Entity found."));
} else if (originalEntity->rtti()!=RS2::EntityPolyline) {
RS_DIALOGFACTORY->commandMessage(
tr("Entity must be a polyline."));
} else {
targetPoint = snapFree(e);
originalEntity->setHighlighted(true);
graphicView->drawEntity(originalEntity);
double d = graphicView->toGraphDX(snapRange)*0.9;
RS_Entity* Segment = ((RS_Polyline*)originalEntity)->getNearestEntity( targetPoint, &d, RS2::ResolveNone);
if (Segment->rtti() == RS2::EntityLine) {
double ang = ((RS_Line*)Segment)->getAngle1();
double ang1 = ((RS_Line*)Segment)->getStartpoint().angleTo(RS_Vector(targetPoint));
if( ang > ang1 || ang + M_PI < ang1 )
bRightSide = true;
} else {
RS_Vector cen = ((RS_Arc*)Segment)->getCenter();
if (cen.distanceTo(targetPoint) > ((RS_Arc*)Segment)->getRadius() && ((RS_Arc*)Segment)->getBulge() > 0 )
bRightSide = true;
}
////////////////////////////////////////2006/06/15
graphicView->redraw();
////////////////////////////////////////
trigger();
}
break;
default:
break;
}
} else if (e->button()==Qt::RightButton) {
deleteSnapper();
if (originalEntity!=NULL) {
originalEntity->setHighlighted(false);
graphicView->drawEntity(originalEntity);
////////////////////////////////////////2006/06/15
graphicView->redraw();
////////////////////////////////////////
}
init(getStatus()-1);
}
}
void RS_ActionPolylineSegment::mouseReleaseEvent(QMouseEvent* e) {
if (e->button()==Qt::LeftButton) {
switch (getStatus()) {
case ChooseEntity:
targetEntity = catchEntity(e);
if (targetEntity==NULL) {
RS_DIALOGFACTORY->commandMessage(tr("No Entity found."));
} else if (targetEntity->rtti()!=RS2::EntityLine && targetEntity->rtti()!=RS2::EntityArc
&& targetEntity->rtti()!=RS2::EntityPolyline) {
RS_DIALOGFACTORY->commandMessage(
tr("Entity must be a line, arc or polyline."));
} else if (targetEntity->rtti()==RS2::EntityPolyline && ((RS_Polyline*)targetEntity)->isClosed()){
RS_DIALOGFACTORY->commandMessage(
tr("Entity can not be a closed polyline."));
} else {
targetEntity->setHighlighted(true);
graphicView->drawEntity(targetEntity);
// setStatus(SetReferencePoint);
////////////////////////////////////////2006/06/15
graphicView->redraw();
////////////////////////////////////////
trigger();
}
break;
default:
break;
}
} else if (e->button()==Qt::RightButton) {
deleteSnapper();
if (targetEntity!=NULL) {
targetEntity->setHighlighted(false);
graphicView->drawEntity(targetEntity);
////////////////////////////////////////2006/06/15
graphicView->redraw();
////////////////////////////////////////
}
init(getStatus()-1);
}
/* if (e->button())==Qt::LeftButton) {
RS_CoordinateEvent ce(snapPoint(e));
coordinateEvent(&ce);
} else if (RS2::qtToRsButtonState(e->button())==RS2::RightButton) {
deletePreview();
deleteSnapper
init(getStatus()-1);
}
*/
}
void RS_ActionDimLeader::mouseReleaseEvent(RS_MouseEvent* e) {
if (RS2::qtToRsButtonState(e->button())==RS2::LeftButton) {
RS_CoordinateEvent ce(snapPoint(e));
coordinateEvent(&ce);
} else if (RS2::qtToRsButtonState(e->button())==RS2::RightButton) {
if (getStatus()==SetEndpoint) {
trigger();
reset();
setStatus(SetStartpoint);
} else {
deletePreview();
deleteSnapper();
init(getStatus()-1);
}
}
}
void RS_ActionDrawPoint::trigger() {
if (pt.valid) {
RS_Point* point = new RS_Point(container, RS_PointData(pt));
container->addEntity(point);
if (document) {
document->startUndoCycle();
document->addUndoable(point);
document->endUndoCycle();
}
deleteSnapper();
graphicView->moveRelativeZero(RS_Vector(0.0,0.0));
graphicView->drawEntity(point);
graphicView->moveRelativeZero(pt);
drawSnapper();
}
}
void RS_ActionDefault::keyPressEvent(QKeyEvent* e) {
// std::cout<<"RS_ActionDefault::keyPressEvent(): begin"<<std::endl;
switch(e->key()){
case Qt::Key_Shift:
restrBak = snapMode.restriction;
setSnapRestriction(RS2::RestrictOrthogonal);
e->accept();
//cleanup default action, issue#285
case Qt::Key_Escape:
// std::cout<<"RS_ActionDefault::keyPressEvent(): Qt::Key_Escape"<<std::endl;
deletePreview();
deleteSnapper();
setStatus(Neutral);
e->accept();
default:
e->ignore();
}
}
void RS_ActionModifyTrim::mouseReleaseEvent(RS_MouseEvent* e) {
if (RS2::qtToRsButtonState(e->button())==RS2::LeftButton) {
RS_Vector mouse = graphicView->toGraph(e->x(), e->y());
RS_Entity* se = catchEntity(e);
switch (getStatus()) {
case ChooseLimitEntity:
limitCoord = mouse;
limitEntity = se;
if (limitEntity!=NULL /*&& limitEntity->isAtomic()*/) {
limitEntity->setHighlighted(true);
graphicView->drawEntity(limitEntity);
setStatus(ChooseTrimEntity);
}
break;
case ChooseTrimEntity:
trimCoord = mouse;
trimEntity = se;
if (trimEntity!=NULL && trimEntity->isAtomic()) {
trigger();
}
break;
default:
break;
}
} else if (RS2::qtToRsButtonState(e->button())==RS2::RightButton) {
deletePreview();
deleteSnapper();
if (limitEntity!=NULL) {
limitEntity->setHighlighted(false);
graphicView->drawEntity(limitEntity);
}
init(getStatus()-1);
}
}
void RS_ActionDrawLineFree::trigger() {
deleteSnapper();
if (polyline.get()) {
deletePreview();
polyline->endPolyline();
RS_VectorSolutions sol=polyline->getRefPoints();
if(sol.getNumber() > 2 ) {
RS_Entity* ent=polyline->clone();
container->addEntity(ent);
if (document) {
document->startUndoCycle();
document->addUndoable(ent);
document->endUndoCycle();
}
graphicView->redraw(RS2::RedrawDrawing);
RS_DEBUG->print("RS_ActionDrawLineFree::trigger():"
" polyline added: %d", ent->getId());
}
polyline.reset();
}
setStatus(SetStartpoint);
}
void RS_ActionInfoDist2::mouseMoveEvent(QMouseEvent* e) {
RS_DEBUG->print("RS_ActionInfoDist2::mouseMoveEvent begin");
switch (getStatus()) {
case SetEntity:
suspend();
//entity = catchEntity(e);
deleteSnapper();
break;
case SetPoint:
if (entity) {
RS_Vector&& mouse=snapPoint(e);
point = mouse;
}
break;
default:
break;
}
RS_DEBUG->print("RS_ActionInfoDist2::mouseMoveEvent end");
}
void RS_ActionPolylineAppend::trigger() {
RS_DEBUG->print("RS_ActionPolylineAppend::trigger()");
RS_PreviewActionInterface::trigger();
if (!polyline) {
return;
}
// add the entity
//RS_Polyline* polyline = new RS_Polyline(container, data);
polyline->setLayerToActive();
polyline->setPenToActive();
// upd. undo list:
if (document) {
document->startUndoCycle();
// RVT_PORT need to decide on how to handle undo cycles
originalPolyline->setUndoState(true);
document->addUndoable(originalPolyline);
document->addUndoable(polyline);
document->endUndoCycle();
}
// upd view
deleteSnapper();
graphicView->moveRelativeZero(RS_Vector(0.0,0.0));
graphicView->deleteEntity(originalPolyline);
graphicView->drawEntity(polyline);
graphicView->moveRelativeZero(polyline->getEndpoint());
drawSnapper();
RS_DEBUG->print("RS_ActionDrawPolyline::trigger(): polyline added: %d",
polyline->getId());
polyline = nullptr;
}
void RS_ActionDrawText::commandEvent(RS_CommandEvent* e) {
RS_String c = e->getCommand().lower();
if (checkCommand("help", c)) {
if (RS_DIALOGFACTORY!=NULL) {
RS_DIALOGFACTORY->commandMessage(msgAvailableCommands()
+ getAvailableCommands().join(", "));
}
return;
}
switch (getStatus()) {
case SetPos:
if (checkCommand("text", c)) {
deleteSnapper();
deletePreview();
clearPreview();
graphicView->disableCoordinateInput();
setStatus(SetText);
}
break;
case SetText: {
setText(e->getCommand());
if (RS_DIALOGFACTORY!=NULL) {
RS_DIALOGFACTORY->requestOptions(this, true, true);
}
graphicView->enableCoordinateInput();
setStatus(SetPos);
}
break;
default:
break;
}
}
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_ActionSelect::resume(){
RS_ActionInterface::resume();
deleteSnapper();
}
/**
* 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(RS_MouseEvent* e) {
RS_DEBUG->print("RS_Snapper::snapPoint");
deleteSnapper();
snapSpot = RS_Vector(false);
if (e==NULL) {
RS_DEBUG->print(RS_Debug::D_WARNING,
"RS_Snapper::snapPoint: event is NULL");
return snapSpot;
}
RS_Vector mouseCoord = graphicView->toGraph(e->x(), e->y());
switch (snapMode) {
case RS2::SnapFree:
snapSpot = snapFree(mouseCoord);
break;
case RS2::SnapEndpoint:
snapSpot = snapEndpoint(mouseCoord);
break;
case RS2::SnapGrid:
snapSpot = snapGrid(mouseCoord);
break;
case RS2::SnapOnEntity:
snapSpot = snapOnEntity(mouseCoord);
break;
case RS2::SnapCenter:
snapSpot = snapCenter(mouseCoord);
break;
case RS2::SnapMiddle:
snapSpot = snapMiddle(mouseCoord);
break;
case RS2::SnapDist:
snapSpot = snapDist(mouseCoord);
break;
case RS2::SnapIntersection:
snapSpot = snapIntersection(mouseCoord);
break;
default:
break;
}
// handle snap restrictions that can be activated in addition
// to the ones above:
switch (snapRes) {
case RS2::RestrictOrthogonal:
snapCoord = restrictOrthogonal(snapSpot);
break;
case RS2::RestrictHorizontal:
snapCoord = restrictHorizontal(snapSpot);
break;
case RS2::RestrictVertical:
snapCoord = restrictVertical(snapSpot);
break;
default:
case RS2::RestrictNothing:
snapCoord = snapSpot;
break;
}
drawSnapper();
if (RS_DIALOGFACTORY!=NULL) {
RS_DIALOGFACTORY->updateCoordinateWidget(snapCoord,
snapCoord - graphicView->getRelativeZero());
}
RS_DEBUG->print("RS_Snapper::snapPoint: OK");
return snapCoord;
}
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_Snapper::finish() {
finished = true;
deleteSnapper();
}
void RS_ActionModifyRound::commandEvent(RS_CommandEvent* e) {
RS_String c = e->getCommand().lower();
if (checkCommand("help", c)) {
if (RS_DIALOGFACTORY!=NULL) {
RS_DIALOGFACTORY->commandMessage(msgAvailableCommands()
+ getAvailableCommands().join(", "));
}
return;
}
switch (getStatus()) {
case SetEntity1:
case SetEntity2:
if (checkCommand("radius", c)) {
deleteSnapper();
deletePreview();
clearPreview();
lastStatus = (Status)getStatus();
setStatus(SetRadius);
} else if (checkCommand("trim", c)) {
/*deleteSnapper();
deletePreview();
clearPreview();
lastStatus = (Status)getStatus();
setStatus(SetTrim);
*/
data.trim = !data.trim;
if (RS_DIALOGFACTORY!=NULL) {
RS_DIALOGFACTORY->requestOptions(this, true, true);
}
}
break;
case SetRadius: {
bool ok;
double r = RS_Math::eval(c, &ok);
if (ok==true) {
data.radius = r;
} else {
if (RS_DIALOGFACTORY!=NULL) {
RS_DIALOGFACTORY->commandMessage(tr("Not a valid expression"));
}
}
if (RS_DIALOGFACTORY!=NULL) {
RS_DIALOGFACTORY->requestOptions(this, true, true);
}
setStatus(lastStatus);
}
break;
/*case SetTrim: {
if (c==cmdYes.lower() || c==cmdYes2) {
data.trim = true;
} else if (c==cmdNo.lower() || c==cmdNo2) {
data.trim = false;
} else {
RS_DIALOGFACTORY->commandMessage(tr("Please enter 'Yes' "
"or 'No'"));
}
RS_DIALOGFACTORY->requestOptions(this, true, true);
setStatus(lastStatus);
}
break;*/
default:
break;
}
}
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;
}
}
