void ToolsTest::editTool()
{
// Initialization
TestMap map;
TestMapEditor editor(map.map);
EditTool* tool = new EditPointTool(editor.editor, nullptr); // TODO: Refactor EditTool: MapEditorController and SymbolWidget pointers could be unnecessary
editor.editor->setTool(tool);
// Move the first coordinate of the line object
MapWidget* map_widget = editor.map_widget;
PathObject* object = map.line_object;
const MapCoord& coord = object->getCoordinate(0);
QPointF drag_start_pos = map_widget->mapToViewport(coord);
QPointF drag_end_pos = drag_start_pos + QPointF(0, -50);
// Clear selection.
map.map->clearObjectSelection(false);
QVERIFY(map.map->selectedObjects().empty());
// Click to select the object
editor.simulateClick(drag_start_pos);
QCOMPARE(map.map->getFirstSelectedObject(), object);
// Drag the coordinate to the new position
editor.simulateDrag(drag_start_pos, drag_end_pos);
// Check position deviation
QPointF difference = map_widget->mapToViewport(coord) - drag_end_pos;
QCOMPARE(qMax(qAbs(difference.x()), 0.1), 0.1);
QCOMPARE(qMax(qAbs(difference.y()), 0.1), 0.1);
// Cleanup
editor.editor->setTool(nullptr);
}
bool DrawPathTool::removeLastPointFromSelectedPath()
{
if (editingInProgress() || map()->getNumSelectedObjects() != 1)
{
return false;
}
Object* object = map()->getFirstSelectedObject();
if (object->getType() != Object::Path)
{
return false;
}
PathObject* path = object->asPath();
if (path->parts().size() != 1)
{
return false;
}
int points_on_path = 0;
int num_coords = path->getCoordinateCount();
for (int i = 0; i < num_coords && points_on_path < 3; ++i)
{
++points_on_path;
if (path->getCoordinate(i).isCurveStart())
{
i += 2; // Skip the control points.
}
}
if (points_on_path < 3)
{
// Too few points after deleting the last: delete the whole object.
map()->deleteSelectedObjects();
return true;
}
ReplaceObjectsUndoStep* undo_step = new ReplaceObjectsUndoStep(map());
Object* undo_duplicate = object->duplicate();
undo_duplicate->setMap(map());
undo_step->addObject(object, undo_duplicate);
map()->push(undo_step);
updateDirtyRect();
path->parts().front().setClosed(false);
path->deleteCoordinate(num_coords - 1, false);
path->update();
map()->setObjectsDirty();
map()->emitSelectionEdited();
return true;
}
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();
}
void BooleanTool::rebuildTwoIndexSegment(
ClipperLib::Path::size_type start_index,
ClipperLib::Path::size_type end_index,
bool sequence_increasing,
const ClipperLib::Path& polygon,
const PolyMap& polymap,
PathObject* object)
{
Q_UNUSED(sequence_increasing); // only used in Q_ASSERT.
PathCoordInfo start_info = polymap.value(polygon.at(start_index));
PathCoordInfo end_info = polymap.value(polygon.at(end_index));
PathObject* original = end_info.first->path;
bool coords_increasing;
bool is_curve;
int coord_index;
if (start_info.second->index == end_info.second->index)
{
coord_index = end_info.second->index;
bool found = checkSegmentMatch(original, coord_index, polygon, start_index, end_index, coords_increasing, is_curve);
if (!found)
{
object->getCoordinate(object->getCoordinateCount() - 1).setCurveStart(false);
rebuildCoordinate(end_index, polygon, polymap, object);
return;
}
Q_ASSERT(coords_increasing == sequence_increasing);
}
else
{
coord_index = end_info.second->index;
bool found = checkSegmentMatch(original, coord_index, polygon, start_index, end_index, coords_increasing, is_curve);
if (!found)
{
coord_index = start_info.second->index;
found = checkSegmentMatch(original, coord_index, polygon, start_index, end_index, coords_increasing, is_curve);
if (!found)
{
object->getCoordinate(object->getCoordinateCount() - 1).setCurveStart(false);
rebuildCoordinate(end_index, polygon, polymap, object);
return;
}
}
}
if (!is_curve)
object->getCoordinate(object->getCoordinateCount() - 1).setCurveStart(false);
if (coords_increasing)
{
object->addCoordinate(resetCoordinate(original->getCoordinate(coord_index + 1)));
if (is_curve)
{
object->addCoordinate(original->getCoordinate(coord_index + 2));
object->addCoordinate(resetCoordinate(original->getCoordinate(coord_index + 3)));
}
}
else
{
if (is_curve)
{
object->addCoordinate(resetCoordinate(original->getCoordinate(coord_index + 2)));
object->addCoordinate(original->getCoordinate(coord_index + 1));
}
object->addCoordinate(resetCoordinate(original->getCoordinate(coord_index + 0)));
}
}
MapCoord SnappingToolHelper::snapToObject(MapCoordF position, MapWidget* widget, SnappingToolHelperSnapInfo* info, Object* exclude_object, float snap_distance)
{
if (snap_distance < 0)
snap_distance = 0.001f * widget->getMapView()->pixelToLength(Settings::getInstance().getMapEditorSnapDistancePx());
float closest_distance_sq = snap_distance * snap_distance;
auto result_position = MapCoord { position };
SnappingToolHelperSnapInfo result_info;
result_info.type = NoSnapping;
result_info.object = NULL;
result_info.coord_index = -1;
result_info.path_coord.pos = MapCoordF(0, 0);
result_info.path_coord.index = -1;
result_info.path_coord.clen = -1;
result_info.path_coord.param = -1;
if (filter & (ObjectCorners | ObjectPaths))
{
// Find map objects at the given position
SelectionInfoVector objects;
map->findAllObjectsAt(position, snap_distance, true, false, false, true, objects);
// Find closest snap spot from map objects
for (SelectionInfoVector::const_iterator it = objects.begin(), end = objects.end(); it != end; ++it)
{
Object* object = it->second;
if (object == exclude_object)
continue;
float distance_sq;
if (object->getType() == Object::Point && filter & ObjectCorners)
{
PointObject* point = object->asPoint();
distance_sq = point->getCoordF().distanceSquaredTo(position);
if (distance_sq < closest_distance_sq)
{
closest_distance_sq = distance_sq;
result_position = point->getCoord();
result_info.type = ObjectCorners;
result_info.object = object;
result_info.coord_index = 0;
}
}
else if (object->getType() == Object::Path)
{
PathObject* path = object->asPath();
if (filter & ObjectPaths)
{
PathCoord path_coord;
path->calcClosestPointOnPath(position, distance_sq, path_coord);
if (distance_sq < closest_distance_sq)
{
closest_distance_sq = distance_sq;
result_position = MapCoord(path_coord.pos);
result_info.object = object;
if (path_coord.param == 0.0)
{
result_info.type = ObjectCorners;
result_info.coord_index = path_coord.index;
}
else
{
result_info.type = ObjectPaths;
result_info.coord_index = -1;
result_info.path_coord = path_coord;
}
}
}
else
{
MapCoordVector::size_type index;
path->calcClosestCoordinate(position, distance_sq, index);
if (distance_sq < closest_distance_sq)
{
closest_distance_sq = distance_sq;
result_position = path->getCoordinate(index);
result_info.type = ObjectCorners;
result_info.object = object;
result_info.coord_index = index;
}
}
}
else if (object->getType() == Object::Text)
{
// No snapping to texts
continue;
}
}
}
// Find closest grid snap position
if ((filter & GridCorners) && widget->getMapView()->isGridVisible() &&
map->getGrid().isSnappingEnabled() && map->getGrid().getDisplayMode() == MapGrid::AllLines)
{
MapCoordF closest_grid_point = map->getGrid().getClosestPointOnGrid(position, map);
float distance_sq = closest_grid_point.distanceSquaredTo(position);
if (distance_sq < closest_distance_sq)
{
closest_distance_sq = distance_sq;
result_position = MapCoord(closest_grid_point);
result_info.type = GridCorners;
result_info.object = NULL;
result_info.coord_index = -1;
}
}
// Return
if (snap_mark != result_position || snapped_type != result_info.type)
{
snap_mark = result_position;
snapped_type = result_info.type;
emit displayChanged();
}
if (info != NULL)
*info = result_info;
return result_position;
}
void Importer::doImport(bool load_symbols_only, const QString& map_path)
{
import(load_symbols_only);
// Object post processing:
// - make sure that there is no object without symbol
// - make sure that all area-only path objects are closed
// - make sure that there are no special points in wrong places (e.g. curve starts inside curves)
for (int p = 0; p < map->getNumParts(); ++p)
{
MapPart* part = map->getPart(p);
for (int o = 0; o < part->getNumObjects(); ++o)
{
Object* object = part->getObject(o);
if (object->getSymbol() == NULL)
{
addWarning(Importer::tr("Found an object without symbol."));
if (object->getType() == Object::Point)
object->setSymbol(map->getUndefinedPoint(), true);
else if (object->getType() == Object::Path)
object->setSymbol(map->getUndefinedLine(), true);
else
{
// There is no undefined symbol for this type of object, delete the object
part->deleteObject(o, false);
--o;
continue;
}
}
if (object->getType() == Object::Path)
{
PathObject* path = object->asPath();
Symbol::Type contained_types = path->getSymbol()->getContainedTypes();
if (contained_types & Symbol::Area && !(contained_types & Symbol::Line))
path->closeAllParts();
for (MapCoordVector::size_type i = 0; i < path->getCoordinateCount(); ++i)
{
if (path->getCoordinate(i).isCurveStart())
{
if (i+3 >= path->getCoordinateCount())
{
path->getCoordinate(i).setCurveStart(false);
continue;
}
if (path->getCoordinate(i + 1).isClosePoint() || path->getCoordinate(i + 1).isHolePoint() ||
path->getCoordinate(i + 2).isClosePoint() || path->getCoordinate(i + 2).isHolePoint())
{
path->getCoordinate(i).setCurveStart(false);
continue;
}
path->getCoordinate(i + 1).setCurveStart(false);
path->getCoordinate(i + 1).setDashPoint(false);
path->getCoordinate(i + 2).setCurveStart(false);
path->getCoordinate(i + 2).setDashPoint(false);
i += 2;
}
if (i > 0 && path->getCoordinate(i).isHolePoint())
{
if (path->getCoordinate(i-1).isHolePoint())
path->deleteCoordinate(i, false);
}
}
}
}
}
// Symbol post processing
for (int i = 0; i < map->getNumSymbols(); ++i)
{
if (!map->getSymbol(i)->loadFinished(map))
throw FileFormatException(Importer::tr("Error during symbol post-processing."));
}
// Template loading: try to find all template files
bool have_lost_template = false;
for (int i = 0; i < map->getNumTemplates(); ++i)
{
Template* temp = map->getTemplate(i);
bool loaded_from_template_dir = false;
temp->tryToFindAndReloadTemplateFile(map_path, &loaded_from_template_dir);
if (loaded_from_template_dir)
addWarning(Importer::tr("Template \"%1\" has been loaded from the map's directory instead of the relative location to the map file where it was previously.").arg(temp->getTemplateFilename()));
if (temp->getTemplateState() != Template::Loaded)
have_lost_template = true;
}
if (have_lost_template)
{
#if defined(Q_OS_ANDROID)
addWarning(tr("At least one template file could not be found."));
#else
addWarning(tr("At least one template file could not be found.") + " " +
tr("Click the red template name(s) in the Templates -> Template setup window to locate the template file name(s)."));
#endif
}
}
void CutTool::pathFinished(PathObject* split_path)
{
Map* map = this->map();
// Get path endpoint and check if it is on the area boundary
const MapCoordVector& path_coords = split_path->getRawCoordinateVector();
MapCoord path_end = path_coords.at(path_coords.size() - 1);
PathObject* edited_path = reinterpret_cast<PathObject*>(edit_object);
PathCoord end_path_coord;
float distance_sq;
edited_path->calcClosestPointOnPath(MapCoordF(path_end), distance_sq, end_path_coord);
float click_tolerance_map = 0.001 * edit_widget->getMapView()->pixelToLength(clickTolerance());
if (distance_sq > click_tolerance_map*click_tolerance_map)
{
QMessageBox::warning(window(), tr("Error"), tr("The split line must end on the area boundary!"));
pathAborted();
return;
}
else if (drag_part_index != edited_path->findPartIndexForIndex(end_path_coord.index))
{
QMessageBox::warning(window(), tr("Error"), tr("Start and end of the split line are at different parts of the object!"));
pathAborted();
return;
}
else if (drag_start_len == end_path_coord.clen)
{
QMessageBox::warning(window(), tr("Error"), tr("Start and end of the split line are at the same position!"));
pathAborted();
return;
}
Q_ASSERT(split_path->parts().size() == 1);
split_path->parts().front().setClosed(false);
split_path->setCoordinate(split_path->getCoordinateCount() - 1, MapCoord(end_path_coord.pos));
// Do the splitting
const double split_threshold = 0.01;
MapPart* part = map->getCurrentPart();
AddObjectsUndoStep* add_step = new AddObjectsUndoStep(map);
add_step->addObject(part->findObjectIndex(edited_path), edited_path);
map->removeObjectFromSelection(edited_path, false);
map->deleteObject(edited_path, true);
map->setObjectsDirty();
DeleteObjectsUndoStep* delete_step = new DeleteObjectsUndoStep(map);
PathObject* holes = nullptr; // if the edited path contains holes, they are saved in this temporary object
if (edited_path->parts().size() > 1)
{
holes = edited_path->duplicate()->asPath();
holes->deletePart(0);
}
bool ok; Q_UNUSED(ok); // "ok" is only used in Q_ASSERT.
PathObject* parts[2] = { new PathObject { edited_path->parts().front() }, nullptr };
const PathPart& drag_part = edited_path->parts()[drag_part_index];
if (drag_part.isClosed())
{
parts[1] = new PathObject { *parts[0] };
parts[0]->changePathBounds(drag_part_index, drag_start_len, end_path_coord.clen);
ok = parts[0]->connectIfClose(split_path, split_threshold);
Q_ASSERT(ok);
parts[1]->changePathBounds(drag_part_index, end_path_coord.clen, drag_start_len);
ok = parts[1]->connectIfClose(split_path, split_threshold);
Q_ASSERT(ok);
}
else
{
float min_cut_pos = qMin(drag_start_len, end_path_coord.clen);
float max_cut_pos = qMax(drag_start_len, end_path_coord.clen);
float path_len = drag_part.path_coords.back().clen;
if (min_cut_pos <= 0 && max_cut_pos >= path_len)
{
ok = parts[0]->connectIfClose(split_path, split_threshold);
Q_ASSERT(ok);
parts[1] = new PathObject { *split_path };
parts[1]->setSymbol(edited_path->getSymbol(), false);
}
else if (min_cut_pos <= 0 || max_cut_pos >= path_len)
{
float cut_pos = (min_cut_pos <= 0) ? max_cut_pos : min_cut_pos;
parts[1] = new PathObject { *parts[0] };
parts[0]->changePathBounds(drag_part_index, 0, cut_pos);
ok = parts[0]->connectIfClose(split_path, split_threshold);
Q_ASSERT(ok);
parts[1]->changePathBounds(drag_part_index, cut_pos, path_len);
ok = parts[1]->connectIfClose(split_path, split_threshold);
Q_ASSERT(ok);
}
else
{
parts[1] = new PathObject { *parts[0] };
PathObject* temp_path = new PathObject { *parts[0] };
parts[0]->changePathBounds(drag_part_index, min_cut_pos, max_cut_pos);
ok = parts[0]->connectIfClose(split_path, split_threshold);
Q_ASSERT(ok);
parts[1]->changePathBounds(drag_part_index, 0, min_cut_pos);
ok = parts[1]->connectIfClose(split_path, split_threshold);
Q_ASSERT(ok);
temp_path->changePathBounds(drag_part_index, max_cut_pos, path_len);
ok = parts[1]->connectIfClose(temp_path, split_threshold);
Q_ASSERT(ok);
delete temp_path;
}
}
// If the object had holes, check into which parts they go
if (holes)
{
for (const auto& hole : holes->parts())
{
PathPartVector::size_type part_index = (parts[0]->isPointOnPath(MapCoordF(holes->getCoordinate(hole.first_index)), 0, false, false) != Symbol::NoSymbol) ? 0 : 1;
parts[part_index]->getCoordinate(parts[part_index]->getCoordinateCount() - 1).setHolePoint(true);
parts[part_index]->appendPathPart(hole);
}
}
for (auto& object : parts)
{
map->addObject(object);
delete_step->addObject(part->findObjectIndex(object));
map->addObjectToSelection(object, false);
}
CombinedUndoStep* undo_step = new CombinedUndoStep(map);
undo_step->push(add_step);
undo_step->push(delete_step);
map->push(undo_step);
map->setObjectsDirty();
pathAborted();
}
