void DrawPathTool::createPreviewCurve(MapCoord position, float direction)
{
if (!path_has_preview_point)
{
int last = preview_path->getCoordinateCount() - 1;
(preview_path->getCoordinate(last)).setCurveStart(true);
preview_path->addCoordinate(MapCoord(0, 0));
preview_path->addCoordinate(MapCoord(0, 0));
if (draw_dash_points)
position.setDashPoint(true);
position.setCurveStart(false);
preview_path->addCoordinate(position);
path_has_preview_point = true;
}
// Adjust the preview curve
int last = preview_path->getCoordinateCount() - 1;
MapCoord previous_point = preview_path->getCoordinate(last - 3);
MapCoord last_point = preview_path->getCoordinate(last);
double bezier_handle_distance = BEZIER_HANDLE_DISTANCE * previous_point.distanceTo(last_point);
preview_path->setCoordinate(last - 2, MapCoord(previous_point.x() - bezier_handle_distance * sin(previous_point_direction),
previous_point.y() - bezier_handle_distance * cos(previous_point_direction)));
preview_path->setCoordinate(last - 1, MapCoord(last_point.x() + bezier_handle_distance * sin(direction),
last_point.y() + bezier_handle_distance * cos(direction)));
updatePreviewPath();
}
void EditPointTool::clickPress()
{
Q_ASSERT(!hover_state.testFlag(OverObjectNode) ||
!hover_state.testFlag(OverPathEdge) ||
hover_object);
if (hover_state.testFlag(OverPathEdge) &&
active_modifiers & Qt::ControlModifier)
{
// Add new point to path
PathObject* path = hover_object->asPath();
float distance_sq;
PathCoord path_coord;
path->calcClosestPointOnPath(cur_pos_map, distance_sq, path_coord);
float click_tolerance_map_sq = cur_map_widget->getMapView()->pixelToLength(clickTolerance());
click_tolerance_map_sq = click_tolerance_map_sq * click_tolerance_map_sq;
if (distance_sq <= click_tolerance_map_sq)
{
startEditing();
QScopedValueRollback<bool> no_effect_rollback(no_more_effect_on_click);
no_more_effect_on_click = true;
startDragging();
hover_state = OverObjectNode;
hover_point = path->subdivide(path_coord);
if (addDashPointDefault() ^ space_pressed)
{
MapCoord point = path->getCoordinate(hover_point);
point.setDashPoint(true);
path->setCoordinate(hover_point, point);
map()->emitSelectionEdited();
}
startEditingSetup();
updatePreviewObjects();
}
}
else if (hover_state.testFlag(OverObjectNode) &&
hover_object->getType() == Object::Path)
{
PathObject* hover_object = this->hover_object->asPath();
Q_ASSERT(hover_point < hover_object->getCoordinateCount());
if (space_pressed &&
!hover_object->isCurveHandle(hover_point))
{
// Switch point between dash / normal point
createReplaceUndoStep(hover_object);
MapCoord& hover_coord = hover_object->getCoordinate(hover_point);
hover_coord.setDashPoint(!hover_coord.isDashPoint());
hover_object->update();
updateDirtyRect();
no_more_effect_on_click = true;
}
else if (active_modifiers & Qt::ControlModifier)
{
auto hover_point_part_index = hover_object->findPartIndexForIndex(hover_point);
PathPart& hover_point_part = hover_object->parts()[hover_point_part_index];
if (hover_object->isCurveHandle(hover_point))
{
// Convert the curve into a straight line
createReplaceUndoStep(hover_object);
hover_object->deleteCoordinate(hover_point, false);
hover_object->update();
map()->emitSelectionEdited();
updateHoverState(cur_pos_map);
updateDirtyRect();
no_more_effect_on_click = true;
}
else
{
// Delete the point
if (hover_point_part.countRegularNodes() <= 2 ||
( !(hover_object->getSymbol()->getContainedTypes() & Symbol::Line) &&
hover_point_part.size() <= 3 ) )
{
// Not enough remaining points -> delete the part and maybe object
if (hover_object->parts().size() == 1)
{
map()->removeObjectFromSelection(hover_object, false);
auto undo_step = new AddObjectsUndoStep(map());
auto part = map()->getCurrentPart();
int index = part->findObjectIndex(hover_object);
Q_ASSERT(index >= 0);
undo_step->addObject(index, hover_object);
map()->deleteObject(hover_object, true);
map()->push(undo_step);
map()->setObjectsDirty();
map()->emitSelectionEdited();
updateHoverState(cur_pos_map);
}
else
{
createReplaceUndoStep(hover_object);
hover_object->deletePart(hover_point_part_index);
hover_object->update();
map()->emitSelectionEdited();
updateHoverState(cur_pos_map);
updateDirtyRect();
}
no_more_effect_on_click = true;
}
else
{
// Delete the point only
createReplaceUndoStep(hover_object);
int delete_bezier_spline_point_setting;
if (active_modifiers & Qt::ShiftModifier)
delete_bezier_spline_point_setting = Settings::EditTool_DeleteBezierPointActionAlternative;
else
delete_bezier_spline_point_setting = Settings::EditTool_DeleteBezierPointAction;
hover_object->deleteCoordinate(hover_point, true, Settings::getInstance().getSettingCached((Settings::SettingsEnum)delete_bezier_spline_point_setting).toInt());
hover_object->update();
map()->emitSelectionEdited();
updateHoverState(cur_pos_map);
updateDirtyRect();
no_more_effect_on_click = true;
}
}
}
}
else if (hoveringOverSingleText())
{
TextObject* hover_object = map()->getFirstSelectedObject()->asText();
startEditing();
// Don't show the original text while editing
map()->removeRenderablesOfObject(hover_object, true);
// Make sure that the TextObjectEditorHelper remembers the correct standard cursor
cur_map_widget->setCursor(getCursor());
old_text = hover_object->getText();
old_horz_alignment = (int)hover_object->getHorizontalAlignment();
old_vert_alignment = (int)hover_object->getVerticalAlignment();
text_editor = new TextObjectEditorHelper(hover_object, editor);
connect(text_editor, SIGNAL(selectionChanged(bool)), this, SLOT(textSelectionChanged(bool)));
// Select clicked position
int pos = hover_object->calcTextPositionAt(cur_pos_map, false);
text_editor->setSelection(pos, pos);
updatePreviewObjects();
}
click_timer.restart();
}
bool DrawRectangleTool::mousePressEvent(QMouseEvent* event, MapCoordF map_coord, MapWidget* widget)
{
// Adjust flags to have possibly more recent state
int modifiers = (event->modifiers() | (key_button_bar ? key_button_bar->activeModifiers() : 0));
ctrl_pressed = modifiers & Qt::ControlModifier;
shift_pressed = modifiers & Qt::ShiftModifier;
cur_map_widget = widget;
if (isDrawingButton(event->button()))
{
dragging = false;
click_pos = event->pos();
click_pos_map = map_coord;
cur_pos = event->pos();
cur_pos_map = click_pos_map;
if (shift_pressed)
cur_pos_map = MapCoordF(snap_helper->snapToObject(cur_pos_map, widget));
constrained_pos_map = cur_pos_map;
if (!editingInProgress())
{
if (ctrl_pressed)
{
// Pick direction
pickDirection(cur_pos_map, widget);
}
else
{
// Start drawing
if (angle_helper->isActive())
angle_helper->setCenter(click_pos_map);
startDrawing();
MapCoord coord = MapCoord(cur_pos_map);
coord.setDashPoint(draw_dash_points);
preview_path->addCoordinate(coord);
preview_path->addCoordinate(coord);
angles.push_back(0);
updateStatusText();
}
}
else
{
if (angles.size() >= 2 && drawingParallelTo(angles[angles.size() - 2]))
{
// Drawing parallel to last section, just move the last point
undoLastPoint();
}
// Add new point
int cur_point_index = angles.size();
if (!preview_path->getCoordinate(cur_point_index).isPositionEqualTo(preview_path->getCoordinate(cur_point_index - 1)))
{
MapCoord coord = MapCoord(cur_pos_map);
coord.setDashPoint(draw_dash_points);
preview_path->addCoordinate(coord);
if (angles.size() == 1)
{
// Bring to correct number of points: line becomes a rectangle
preview_path->addCoordinate(coord);
}
angles.push_back(0);
angle_helper->setActive(true, MapCoordF(preview_path->getCoordinate(cur_point_index)));
angle_helper->clearAngles();
angle_helper->addAngles(angles[0], M_PI/4);
if (event->button() != Qt::RightButton || !drawOnRightClickEnabled())
{
updateHover(false);
updateHover(false); // Call it again, really.
}
}
}
}
else if (event->button() == Qt::RightButton && editingInProgress())
{
constrained_pos_map = MapCoordF(preview_path->getCoordinate(angles.size() - 1));
undoLastPoint();
if (editingInProgress()) // despite undoLastPoint()
finishDrawing();
no_more_effect_on_click = true;
}
else
{
return false;
}
return true;
}
bool DrawPathTool::mouseReleaseEvent(QMouseEvent* event, MapCoordF map_coord, MapWidget* widget)
{
if (!isDrawingButton(event->button()))
return false;
left_mouse_down = false;
if (picking_angle)
{
picking_angle = false;
picked_angle = pickAngle(map_coord, widget);
return true;
}
else if (!editingInProgress())
{
return false;
}
if (following)
{
finishFollowing();
if ((event->button() == Qt::RightButton) && drawOnRightClickEnabled())
finishDrawing();
return true;
}
if (!create_segment)
return true;
if (previous_point_is_curve_point && !dragging && !create_spline_corner)
{
// The new point has not been added yet
MapCoord coord;
if (shift_pressed)
{
coord = snap_helper->snapToObject(map_coord, widget);
}
else if (angle_helper->isActive())
{
QPointF constrained_pos;
angle_helper->getConstrainedCursorPositions(map_coord, constrained_pos_map, constrained_pos, widget);
coord = MapCoord(constrained_pos_map);
}
else
{
coord = MapCoord(map_coord);
}
if (draw_dash_points)
coord.setDashPoint(true);
preview_path->addCoordinate(coord);
updatePreviewPath();
updateDirtyRect();
}
previous_point_is_curve_point = dragging;
if (previous_point_is_curve_point)
{
QPointF constrained_pos;
angle_helper->getConstrainedCursorPositions(map_coord, constrained_pos_map, constrained_pos, widget);
previous_pos_map = click_pos_map;
previous_drag_map = constrained_pos_map;
previous_point_direction = calculateRotation(constrained_pos.toPoint(), constrained_pos_map);
}
updateAngleHelper();
create_spline_corner = false;
path_has_preview_point = false;
dragging = false;
if ((event->button() == Qt::RightButton) && drawOnRightClickEnabled())
finishDrawing();
return true;
}
void DrawRectangleTool::updateRectangle()
{
double angle = angle_helper->getConstrainedCursorPosMap(constrained_pos_map, constrained_pos_map);
if (angles.size() == 1)
{
// Update vectors and angles
forward_vector = constrained_pos_map - MapCoordF(preview_path->getCoordinate(0));
forward_vector.normalize();
angles.back() = -forward_vector.angle();
// Update rectangle
MapCoord coord = MapCoord(constrained_pos_map);
coord.setDashPoint(draw_dash_points);
preview_path->setCoordinate(1, coord);
}
else
{
// Update vectors and angles
forward_vector = MapCoordF::fromPolar(1.0, -angle);
angles.back() = angle;
// Update rectangle
auto cur_point_index = angles.size();
deleteClosePoint();
float forward_dist = MapCoordF::dotProduct(forward_vector, constrained_pos_map - MapCoordF(preview_path->getCoordinate(cur_point_index - 1)));
MapCoord coord = preview_path->getCoordinate(cur_point_index - 1) + MapCoord(forward_dist * forward_vector);
snapped_to_line = false;
float best_snap_distance_sq = std::numeric_limits<float>::max();
if (ctrl_pressed && angles.size() > 2)
{
// Try to snap to existing lines
MapCoord original_coord = coord;
for (int i = 0; i < (int)angles.size() - 1; ++i)
{
MapCoordF direction(100, 0);
direction.rotate(-angles[i]);
int num_steps;
double angle_step, angle_offset = 0;
if (i == 0 || qAbs(qAbs(fmod_pos(angles[i], M_PI) - fmod_pos(angles[i-1], M_PI)) - (M_PI / 2)) < 0.1)
{
num_steps = 2;
angle_step = M_PI/2;
}
else
{
num_steps = 4;
angle_step = M_PI/4;
}
for (int k = 0; k < num_steps; ++k)
{
if (qAbs(fmod_pos(angle, M_PI) - fmod_pos(angles[i] - (angle_offset + k * angle_step), M_PI)) < 0.1)
continue;
MapCoordF rotated_direction = direction;
rotated_direction.rotate(angle_offset + k * angle_step);
QLineF a(QPointF(preview_path->getCoordinate(cur_point_index - 1)), MapCoordF(preview_path->getCoordinate(cur_point_index - 1)) + forward_vector);
QLineF b(QPointF(preview_path->getCoordinate(i)), MapCoordF(preview_path->getCoordinate(i)) + rotated_direction);
QPointF intersection_point;
QLineF::IntersectType intersection_type = a.intersect(b, &intersection_point);
if (intersection_type == QLineF::NoIntersection)
continue;
float snap_distance_sq = original_coord.distanceSquaredTo(MapCoord(intersection_point));
if (snap_distance_sq > best_snap_distance_sq)
continue;
best_snap_distance_sq = snap_distance_sq;
coord = MapCoord(intersection_point);
snapped_to_line_a = coord;
snapped_to_line_b = coord + MapCoord(rotated_direction);
snapped_to_line = true;
}
}
}
coord.setDashPoint(draw_dash_points);
preview_path->setCoordinate(cur_point_index, coord);
auto close_vector = calculateClosingVector();
float close_dist = MapCoordF::dotProduct(close_vector, MapCoordF(preview_path->getCoordinate(0) - preview_path->getCoordinate(cur_point_index)));
coord = preview_path->getCoordinate(cur_point_index) + MapCoord(close_dist * close_vector);
coord.setDashPoint(draw_dash_points);
preview_path->setCoordinate(cur_point_index + 1, coord);
preview_path->parts().front().setClosed(true, true);
}
updatePreviewPath();
updateDirtyRect();
}