void DrawPathTool::updateDirtyRect()
{
QRectF rect;
if (dragging)
{
rectIncludeSafe(rect, click_pos_map);
rectInclude(rect, cur_pos_map);
}
if (editingInProgress() && previous_point_is_curve_point)
{
rectIncludeSafe(rect, previous_pos_map);
rectInclude(rect, previous_drag_map);
}
if ((editingInProgress() && !dragging) ||
(!editingInProgress() && !shift_pressed && ctrl_pressed) ||
(!editingInProgress() && (picking_angle || picked_angle)))
{
angle_helper->includeDirtyRect(rect);
}
if (shift_pressed || (!editingInProgress() && ctrl_pressed))
snap_helper->includeDirtyRect(rect);
includePreviewRects(rect);
if (is_helper_tool)
emit(dirtyRectChanged(rect));
else
{
if (rect.isValid())
map()->setDrawingBoundingBox(rect, qMax(qMax(dragging ? 1 : 0, angle_helper->getDisplayRadius()), snap_helper->getDisplayRadius()), true);
else
map()->clearDrawingBoundingBox();
}
}
int EditPointTool::updateDirtyRectImpl(QRectF& rect)
{
bool show_object_points = map()->selectedObjects().size() <= max_objects_for_handle_display;
selection_extent = QRectF();
map()->includeSelectionRect(selection_extent);
rectInclude(rect, selection_extent);
int pixel_border = show_object_points ? (scaleFactor() * 6) : 1;
// Control points
if (show_object_points)
{
for (Map::ObjectSelection::const_iterator it = map()->selectedObjectsBegin(), end = map()->selectedObjectsEnd(); it != end; ++it)
(*it)->includeControlPointsRect(rect);
}
// Text selection
if (text_editor)
text_editor->includeDirtyRect(rect);
// Box selection
if (isDragging() && box_selection)
{
rectIncludeSafe(rect, click_pos_map);
rectIncludeSafe(rect, cur_pos_map);
}
return pixel_border;
}
int RotatePatternTool::updateDirtyRectImpl(QRectF& rect)
{
if (isDragging())
{
rectIncludeSafe(rect, click_pos_map);
rectIncludeSafe(rect, constrained_pos_map);
angle_helper->includeDirtyRect(rect);
}
return rect.isValid() ? angle_helper->getDisplayRadius() : -1;
}
void DrawLineAndAreaTool::includePreviewRects(QRectF& rect)
{
if (preview_path)
rectIncludeSafe(rect, preview_path->getExtent());
if (preview_points_shown)
{
for (std::size_t p = 0; p < 2; ++p)
{
std::size_t size = preview_points[p].size();
for (std::size_t i = 0; i < size; ++i)
rectIncludeSafe(rect, preview_points[p][i]->getExtent());
}
}
}
int CutoutTool::updateDirtyRectImpl(QRectF& rect)
{
rectInclude(rect, cutout_object->getExtent());
map()->includeSelectionRect(rect);
// Box selection
if (isDragging())
{
rectIncludeSafe(rect, click_pos_map);
rectIncludeSafe(rect, cur_pos_map);
}
return 0;
}
void TextObjectEditorHelper::includeDirtyRect(QRectF& rect)
{
QTransform transform = object->calcTextToMapTransform();
QRectF selection_rect;
int line = 0;
while (getNextLinesSelectionRect(line, selection_rect))
rectIncludeSafe(rect, transform.mapRect(selection_rect));
}
int DrawPointGPSTool::updateDirtyRectImpl(QRectF& rect)
{
if (preview_object)
{
rectIncludeSafe(rect, preview_object->getExtent());
return 0;
}
else
return -1;
}
int RotateTool::updateDirtyRectImpl(QRectF& rect)
{
if (rotation_center_set)
{
rectIncludeSafe(rect, rotation_center);
return qMax(angle_helper->getDisplayRadius(), 5);
}
else
return rect.isValid() ? 0 : -1;
}
QRectF Template::calculateTemplateBoundingBox() const
{
// Create bounding box by calculating the positions of all corners of the transformed extent rect
QRectF extent = getTemplateExtent();
QRectF bbox;
rectIncludeSafe(bbox, templateToMap(extent.topLeft()));
rectInclude(bbox, templateToMap(extent.topRight()));
rectInclude(bbox, templateToMap(extent.bottomRight()));
rectInclude(bbox, templateToMap(extent.bottomLeft()));
return bbox;
}
int DrawPointTool::updateDirtyRectImpl(QRectF& rect)
{
if (isDragging())
{
rectIncludeSafe(rect, click_pos_map);
rectInclude(rect, constrained_pos_map);
if (preview_object)
rectInclude(rect, preview_object->getExtent());
return qMax(1, angle_helper->getDisplayRadius());
}
else
{
if (preview_object)
{
rectIncludeSafe(rect, preview_object->getExtent());
return 0;
}
else
return -1;
}
}
void DrawTextTool::updateDirtyRect()
{
QRectF rect;
if (preview_text && !dragging)
{
rectIncludeSafe(rect, preview_text->getExtent());
if (text_editor)
text_editor->includeDirtyRect(rect);
}
if (dragging)
{
rectIncludeSafe(rect, click_pos_map);
rectIncludeSafe(rect, cur_pos_map);
}
if (rect.isValid())
map()->setDrawingBoundingBox(rect, 1, true);
else
map()->clearDrawingBoundingBox();
}
int DrawPointTool::updateDirtyRectImpl(QRectF& rect)
{
Q_ASSERT(preview_object);
int result = 0;
rectIncludeSafe(rect, preview_object->getExtent());
if (isDragging() && preview_object->getSymbol()->asPoint()->isRotatable())
{
rectInclude(rect, constrained_click_pos_map);
rectInclude(rect, constrained_pos_map);
result = qMax(3, angle_helper->getDisplayRadius());
}
return result;
}
void ScaleTool::updateDirtyRect()
{
QRectF rect;
map()->includeSelectionRect(rect);
if (scaling_center_set)
{
rectIncludeSafe(rect, scaling_center);
map()->setDrawingBoundingBox(rect, 5, true);
}
else if (rect.isValid())
map()->setDrawingBoundingBox(rect, 0, true);
else
map()->clearDrawingBoundingBox();
}
QRectF TemplateTrack::calculateTemplateBoundingBox() const
{
QRectF bbox;
int size = track.getNumWaypoints();
for (int i = 0; i < size; ++i)
{
const TrackPoint& track_point = track.getWaypoint(i);
MapCoordF point = track_point.map_coord;
rectIncludeSafe(bbox, is_georeferenced ? point : templateToMap(point));
}
for (int i = 0; i < track.getNumSegments(); ++i)
{
size = track.getSegmentPointCount(i);
for (int k = 0; k < size; ++k)
{
const TrackPoint& track_point = track.getSegmentPoint(i, k);
MapCoordF point = track_point.map_coord;
rectIncludeSafe(bbox, is_georeferenced ? point : templateToMap(point));
}
}
return bbox;
}
void TemplateImage::drawOntoTemplateUndo(bool redo)
{
int step_index;
if (!redo)
{
step_index = undo_index - 1;
if (step_index < 0)
return;
}
else
{
step_index = undo_index;
if (step_index >= static_cast<int>(undo_steps.size()))
return;
}
DrawOnImageUndoStep& step = undo_steps[step_index];
QImage undo_image = step.image.copy();
step.image = image.copy(step.x, step.y, step.image.width(), step.image.height());
QPainter painter(&image);
painter.setCompositionMode(QPainter::CompositionMode_Source);
painter.drawImage(step.x, step.y, undo_image);
undo_index += redo ? 1 : -1;
qreal template_left = step.x - 0.5 * image.width();
qreal template_top = step.y - 0.5 * image.height();
QRectF map_bbox;
rectIncludeSafe(map_bbox, templateToMap(QPointF(template_left, template_top)));
rectIncludeSafe(map_bbox, templateToMap(QPointF(template_left + step.image.width(), template_top)));
rectIncludeSafe(map_bbox, templateToMap(QPointF(template_left, template_top + step.image.height())));
rectIncludeSafe(map_bbox, templateToMap(QPointF(template_left + step.image.width(), template_top + step.image.height())));
map->setTemplateAreaDirty(this, map_bbox, 0);
setHasUnsavedChanges(true);
}
int RotateTool::updateDirtyRectImpl(QRectF& rect)
{
rectIncludeSafe(rect, rotation_center);
return 5;
}
void SnappingToolHelper::includeDirtyRect(QRectF& rect)
{
if (snapped_type != NoSnapping)
rectIncludeSafe(rect, QPointF(snap_mark));
}
void ConstrainAngleToolHelper::includeDirtyRect(QRectF& rect)
{
if (!active) return;
rectIncludeSafe(rect, center);
}
void TemplateImage::drawOntoTemplateImpl(MapCoordF* coords, int num_coords, QColor color, float width)
{
QPointF* points;
QRect radius_bbox;
int draw_iterations = 1;
bool all_coords_equal = true;
for (int i = 1; i < num_coords; ++i)
{
if (coords[i] != coords[i-1])
{
all_coords_equal = false;
break;
}
}
// Special case for points because drawPolyline() draws nothing in this case.
// drawPoint() is also unsuitable because it aligns the point to the closest pixel.
// drawEllipse() in the tested Qt version (5.1.1) seems to have a bug with antialiasing here.
if (all_coords_equal)
{
const qreal ring_radius = 0.8;
const qreal width_factor = 2.0;
draw_iterations = 2;
width *= width_factor;
num_coords = 5;
points = new QPointF[5];
points[0] = mapToTemplate(coords[0]) + QPointF(image.width() * 0.5f, image.height() * 0.5f);
points[1] = points[0] + QPointF(ring_radius, 0);
points[2] = points[0] + QPointF(0, ring_radius);
points[3] = points[0] + QPointF(-ring_radius, 0);
points[4] = points[0] + QPointF(0, -ring_radius);
points[0] = points[4];
radius_bbox = QRect(
qFloor(points[3].x() - width - 1), qFloor(points[4].y() - width - 1),
qCeil(2 * ring_radius + 2*width + 2.5f), qCeil(2 * ring_radius + 2*width + 2.5f)
);
}
else
{
points = new QPointF[num_coords];
QRectF bbox;
for (int i = 0; i < num_coords; ++i)
{
points[i] = mapToTemplate(coords[i]) + QPointF(image.width() * 0.5f, image.height() * 0.5f);
rectIncludeSafe(bbox, points[i]);
}
radius_bbox = QRect(
qFloor(bbox.left() - width - 1), qFloor(bbox.top() - width - 1),
qCeil(bbox.width() + 2*width + 2.5f), qCeil(bbox.height() + 2*width + 2.5f)
);
radius_bbox = radius_bbox.intersected(QRect(0, 0, image.width(), image.height()));
}
// Create undo step
DrawOnImageUndoStep undo_step;
undo_step.x = radius_bbox.left();
undo_step.y = radius_bbox.top();
undo_step.image = image.copy(radius_bbox);
addUndoStep(undo_step);
// This conversion is to prevent a very strange bug where the behavior of the
// default QPainter composition mode seems to be incorrect for images which are
// loaded from a file without alpha and then painted over with the eraser
if (color.alpha() == 0 && image.format() != QImage::Format_ARGB32_Premultiplied)
image = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
QPainter painter;
painter.begin(&image);
if (color.alpha() == 0)
painter.setCompositionMode(QPainter::CompositionMode_Clear);
else
painter.setOpacity(color.alphaF());
QPen pen(color);
pen.setWidthF(width);
pen.setCapStyle(Qt::RoundCap);
pen.setJoinStyle(Qt::RoundJoin);
painter.setPen(pen);
painter.setRenderHint(QPainter::Antialiasing);
for (int i = 0; i < draw_iterations; ++ i)
painter.drawPolyline(points, num_coords);
painter.end();
delete[] points;
}
