//! mouse button released
void QgsGrassRegionEdit::canvasReleaseEvent( QgsMapMouseEvent *event )
{
if ( !mDraw )
return;
mEndPoint = toMapCoordinates( event->pos() );
setRegion( mStartPoint, mEndPoint );
mDraw = false;
emit captureEnded();
}
void QgsMapToolRotateLabel::canvasPressEvent( QgsMapMouseEvent* e )
{
deleteRubberBands();
QgsLabelPosition labelPos;
if ( !labelAtPosition( e, labelPos ) )
{
mCurrentLabel = LabelDetails();
return;
}
mCurrentLabel = LabelDetails( labelPos );
if ( !mCurrentLabel.valid )
return;
// only rotate non-pinned OverPoint placements until other placements are supported in pal::Feature
if ( !mCurrentLabel.pos.isPinned
&& mCurrentLabel.settings.placement != QgsPalLayerSettings::OverPoint )
{
return;
}
// rotate unpinned labels (i.e. no hali/vali settings) as if hali/vali was Center/Half
if ( !currentLabelRotationPoint( mRotationPoint, false, !mCurrentLabel.pos.isPinned ) )
{
return;
}
if ( true )
{
mCurrentMouseAzimuth = azimuthToCCW( mRotationPoint.azimuth( toMapCoordinates( e->pos() ) ) );
bool hasRotationValue;
int rotationCol;
if ( currentLabelDataDefinedRotation( mCurrentRotation, hasRotationValue, rotationCol, true ) )
{
if ( !hasRotationValue )
{
mCurrentRotation = 0;
}
mStartRotation = mCurrentRotation;
createRubberBands();
mRotationPreviewBox = createRotationPreviewBox();
mRotationItem = new QgsPointRotationItem( mCanvas );
mRotationItem->setOrientation( QgsPointRotationItem::Counterclockwise );
mRotationItem->setSymbol( QgsApplication::getThemePixmap( "mActionRotatePointSymbols.svg" ).toImage() );
mRotationItem->setPointLocation( mRotationPoint );
mRotationItem->setSymbolRotation( mCurrentRotation );
}
}
}
//! mouse pressed in map canvas
void QgsGrassRegionEdit::canvasPressEvent( QgsMapMouseEvent * event )
{
mDraw = true;
mRubberBand->reset( QgsWkbTypes::PolygonGeometry );
mSrcRubberBand->reset( QgsWkbTypes::PolygonGeometry );
emit captureStarted();
mStartPoint = toMapCoordinates( event->pos() );
mEndPoint = mStartPoint;
setRegion( mStartPoint, mEndPoint );
}
void QgsAnnotationItem::updatePosition()
{
if ( mMapPositionFixed )
{
setPos( toCanvasCoordinates( mMapPosition ) );
}
else
{
mMapPosition = toMapCoordinates( pos().toPoint() );
}
}
void QgsMapToolSelectPolygon::canvasMoveEvent( QgsMapMouseEvent* e )
{
if ( !mRubberBand )
return;
if ( mRubberBand->numberOfVertices() > 0 )
{
mRubberBand->removeLastPoint( 0 );
mRubberBand->addPoint( toMapCoordinates( e->pos() ) );
}
}
QgsPoint QgsMapToolEdit::snapPointFromResults( const QList<QgsSnappingResult>& snapResults, const QPoint& screenCoords )
{
if ( snapResults.size() < 1 )
{
return toMapCoordinates( screenCoords );
}
else
{
return snapResults.constBegin()->snappedVertex;
}
}
void QgsMapToolMoveFeature::canvasMoveEvent( QgsMapMouseEvent* e )
{
if ( mRubberBand )
{
QgsPoint pointCanvasCoords = toMapCoordinates( e->pos() );
double offsetX = pointCanvasCoords.x() - mStartPointMapCoords.x();
double offsetY = pointCanvasCoords.y() - mStartPointMapCoords.y();
mRubberBand->setTranslationOffset( offsetX, offsetY );
mRubberBand->updatePosition();
mRubberBand->update();
}
}
void QgsBullsEyeTool::canvasReleaseEvent( QMouseEvent *e )
{
if ( mPicking )
{
mWidget->centerPicked( toMapCoordinates( e->pos() ) );
setPicking( false );
}
else if ( e->button() == Qt::RightButton )
{
canvas()->unsetMapTool( this );
}
}
void QgsMapToolNodeTool::createTopologyRubberBands()
{
QgsVectorLayer* vlayer = mSelectedFeature->vlayer();
Q_FOREACH ( const QgsVertexEntry* vertexEntry, mSelectedFeature->vertexMap() )
{
if ( !vertexEntry->isSelected() )
{
continue;
}
// Snap vertex
QMultiMap<double, QgsSnappingResult> snapResults;
vlayer->snapWithContext( vertexEntry->pointV1(), ZERO_TOLERANCE, snapResults, QgsSnapper::SnapToVertex );
Q_FOREACH ( const QgsSnappingResult& snapResult, snapResults )
{
// Get geometry of snapped feature
QgsFeatureId snapFeatureId = snapResult.snappedAtGeometry;
QgsFeature feature;
if ( !vlayer->getFeatures( QgsFeatureRequest( snapFeatureId ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( feature ) )
{
continue;
}
// Get VertexId of snapped vertex
QgsVertexId vid;
if ( !feature.geometry().vertexIdFromVertexNr( snapResult.snappedVertexNr, vid ) )
{
continue;
}
// Add rubberband if not already added
if ( !mMoveRubberBands.contains( snapFeatureId ) )
{
QgsGeometryRubberBand* rb = new QgsGeometryRubberBand( mCanvas, feature.geometry().type() );
QSettings settings;
QColor color(
settings.value( QStringLiteral( "/qgis/digitizing/line_color_red" ), 255 ).toInt(),
settings.value( QStringLiteral( "/qgis/digitizing/line_color_green" ), 0 ).toInt(),
settings.value( QStringLiteral( "/qgis/digitizing/line_color_blue" ), 0 ).toInt() );
double myAlpha = settings.value( QStringLiteral( "/qgis/digitizing/line_color_alpha" ), 30 ).toInt() / 255.0 ;
color.setAlphaF( myAlpha );
rb->setOutlineColor( color );
rb->setBrushStyle( Qt::NoBrush );
rb->setOutlineWidth( settings.value( QStringLiteral( "/qgis/digitizing/line_width" ), 1 ).toInt() );
QgsAbstractGeometry* rbGeom = feature.geometry().geometry()->clone();
if ( mCanvas->mapSettings().layerTransform( vlayer ).isValid() )
rbGeom->transform( mCanvas->mapSettings().layerTransform( vlayer ) );
rb->setGeometry( rbGeom );
mMoveRubberBands.insert( snapFeatureId, rb );
}
// Add to list of vertices to be moved
mMoveVertices[snapFeatureId].append( qMakePair( vid, toMapCoordinates( vlayer, feature.geometry().geometry()->vertexAt( vid ) ) ) );
}
}
//! mouse pressed in map canvas
void QgsGrassRegionEdit::canvasPressEvent( QMouseEvent * event )
{
QgsDebugMsg( "entered." );
mDraw = true;
mRubberBand->reset( true );
mSrcRubberBand->reset( true );
emit captureStarted();
mStartPoint = toMapCoordinates( event->pos() );
mEndPoint = mStartPoint;
setRegion( mStartPoint, mEndPoint );
}
void QgsAnnotationItem::updatePosition()
{
if ( mMapPositionFixed )
{
QgsCoordinateTransform t( mMapPositionCrs, mMapCanvas->mapSettings().destinationCrs() );
setPos( toCanvasCoordinates( t.transform( mMapPosition ) ) );
}
else
{
mMapPosition = toMapCoordinates( pos().toPoint() );
}
}
void QgsMapToolSelectFreehand::canvasPressEvent( QMouseEvent * e )
{
if ( e->button() != Qt::LeftButton )
{
return;
}
if ( mRubberBand == NULL )
{
mRubberBand = new QgsRubberBand( mCanvas, true );
}
mRubberBand->addPoint( toMapCoordinates( e->pos() ) );
mDragging = true;
}
void QgsMapToolSelectFreehand::canvasPressEvent( QgsMapMouseEvent* e )
{
if ( e->button() != Qt::LeftButton )
return;
if ( !mRubberBand )
{
mRubberBand = new QgsRubberBand( mCanvas, QGis::Polygon );
mRubberBand->setFillColor( mFillColor );
mRubberBand->setBorderColor( mBorderColour );
}
mRubberBand->addPoint( toMapCoordinates( e->pos() ) );
mDragging = true;
}
void QgsMapToolNodeTool::createTopologyRubberBands()
{
QgsVectorLayer* vlayer = mSelectedFeature->vlayer();
foreach ( const QgsVertexEntry* vertexEntry, mSelectedFeature->vertexMap() )
{
if ( !vertexEntry->isSelected() )
{
continue;
}
// Snap vertex
QMultiMap<double, QgsSnappingResult> snapResults;
vlayer->snapWithContext( vertexEntry->pointV1(), ZERO_TOLERANCE, snapResults, QgsSnapper::SnapToVertex );
foreach ( const QgsSnappingResult& snapResult, snapResults.values() )
{
// Get geometry of snapped feature
QgsFeatureId snapFeatureId = snapResult.snappedAtGeometry;
QgsFeature feature;
if ( !vlayer->getFeatures( QgsFeatureRequest( snapFeatureId ).setSubsetOfAttributes( QgsAttributeList() ) ).nextFeature( feature ) )
{
continue;
}
// Get VertexId of snapped vertex
QgsVertexId vid;
if ( !feature.geometry()->vertexIdFromVertexNr( snapResult.snappedVertexNr, vid ) )
{
continue;
}
// Add rubberband if not already added
if ( !mMoveRubberBands.contains( snapFeatureId ) )
{
QgsGeometryRubberBand* rb = new QgsGeometryRubberBand( mCanvas, feature.geometry()->type() );
rb->setOutlineColor( Qt::blue );
rb->setBrushStyle( Qt::NoBrush );
rb->setOutlineWidth( 2 );
QgsAbstractGeometryV2* rbGeom = feature.geometry()->geometry()->clone();
if ( mCanvas->mapSettings().layerTransform( vlayer ) )
rbGeom->transform( *mCanvas->mapSettings().layerTransform( vlayer ) );
rb->setGeometry( rbGeom );
mMoveRubberBands.insert( snapFeatureId, rb );
}
// Add to list of vertices to be moved
mMoveVertices[snapFeatureId].append( qMakePair( vid, toMapCoordinates( vlayer, feature.geometry()->geometry()->vertexAt( vid ) ) ) );
}
}
}
void QgsGrassEditNewLine::activate()
{
QgsDebugMsg( "entered." );
// Display dynamic segment
if ( e->mEditPoints->n_points > 0 )
{
Vect_reset_line( e->mPoints );
Vect_append_points( e->mPoints, e->mEditPoints, GV_FORWARD );
QgsPoint point = toMapCoordinates( e->mCanvas->mouseLastXY() );
Vect_append_point( e->mPoints, point.x(), point.y(), 0.0 );
e->displayDynamic( e->mPoints );
}
QgsGrassEditTool::activate(); // call default bahivour
}
void QgsMapToolCapture::cadCanvasMoveEvent( QgsMapMouseEvent *e )
{
QgsMapToolAdvancedDigitizing::cadCanvasMoveEvent( e );
QgsPointXY point = e->mapPoint();
mSnapIndicator->setMatch( e->mapPointMatch() );
if ( !mTempRubberBand && mCaptureCurve.numPoints() > 0 )
{
mTempRubberBand = createRubberBand( mCaptureMode == CapturePolygon ? QgsWkbTypes::PolygonGeometry : QgsWkbTypes::LineGeometry, true );
QgsPoint pt = mCaptureCurve.endPoint();
mTempRubberBand->addPoint( QgsPointXY( pt.x(), pt.y() ) );
mTempRubberBand->addPoint( point );
}
if ( mCaptureMode != CapturePoint && mTempRubberBand && mCapturing )
{
bool hasTrace = false;
if ( tracingEnabled() && mCaptureCurve.numPoints() != 0 )
{
hasTrace = tracingMouseMove( e );
}
if ( !hasTrace )
{
if ( mCaptureCurve.numPoints() > 0 )
{
// fix temporary rubber band after tracing which may have added multiple points
mTempRubberBand->reset( mCaptureMode == CapturePolygon ? QgsWkbTypes::PolygonGeometry : QgsWkbTypes::LineGeometry );
if ( mCaptureMode == CapturePolygon )
mTempRubberBand->addPoint( *mRubberBand->getPoint( 0, 0 ), false );
QgsPoint pt = mCaptureCurve.endPoint();
QgsPointXY mapPt = toMapCoordinates( qobject_cast<QgsVectorLayer *>( mCanvas->currentLayer() ), QgsPointXY( pt.x(), pt.y() ) );
mTempRubberBand->addPoint( mapPt );
mTempRubberBand->addPoint( point );
// fix existing rubber band after tracing - the last point may have been moved if using offset
if ( mRubberBand->numberOfVertices() )
mRubberBand->movePoint( mapPt );
}
else
mTempRubberBand->movePoint( point );
}
}
} // mouseMoveEvent
bool QgsMapToolLabel::labelAtPosition( QMouseEvent* e, QgsLabelPosition& p )
{
QgsPoint pt = toMapCoordinates( e->pos() );
const QgsLabelingResults* labelingResults = mCanvas->labelingResults();
if ( labelingResults )
{
QList<QgsLabelPosition> labelPosList = labelingResults->labelsAtPosition( pt );
QList<QgsLabelPosition>::const_iterator posIt = labelPosList.constBegin();
if ( posIt != labelPosList.constEnd() )
{
p = *posIt;
return true;
}
}
return false;
}
bool QgsMapToolLabel::labelAtPosition( QMouseEvent* e, QgsLabelPosition& p )
{
QgsPoint pt = toMapCoordinates( e->pos() );
QgsLabelingEngineInterface* labelingEngine = mCanvas->mapRenderer()->labelingEngine();
if ( labelingEngine )
{
QList<QgsLabelPosition> labelPosList = labelingEngine->labelsAtPosition( pt );
QList<QgsLabelPosition>::const_iterator posIt = labelPosList.constBegin();
if ( posIt != labelPosList.constEnd() )
{
p = *posIt;
return true;
}
}
return false;
}
void QgsMapToolSelectRadius::canvasMoveEvent( QgsMapMouseEvent* e )
{
if ( e->buttons() != Qt::LeftButton )
return;
if ( !mDragging )
{
if ( !mRubberBand )
{
mRubberBand = new QgsRubberBand( mCanvas, QGis::Polygon );
mRubberBand->setFillColor( mFillColor );
mRubberBand->setBorderColor( mBorderColour );
}
mDragging = true;
}
QgsPoint radiusEdge = toMapCoordinates( e->pos() );
setRadiusRubberBand( radiusEdge );
}
QgsAnnotationItem* QgsMapToolFormAnnotation::createItem( QMouseEvent* e )
{
//try to associate the current vector layer and a feature to the form item
QgsVectorLayer* currentVectorLayer = 0;
if ( mCanvas )
{
QgsMapLayer* mLayer = mCanvas->currentLayer();
if ( mLayer )
{
currentVectorLayer = dynamic_cast<QgsVectorLayer*>( mLayer );
}
}
QgsFormAnnotationItem* formItem = new QgsFormAnnotationItem( mCanvas, currentVectorLayer );
formItem->setMapPosition( toMapCoordinates( e->pos() ) );
formItem->setSelected( true );
formItem->setFrameSize( QSizeF( 200, 100 ) );
return formItem;
}
QgsPointXY QgsMapToolCapture::tracingStartPoint()
{
try
{
QgsMapLayer *layer = mCanvas->currentLayer();
if ( !layer )
return QgsPointXY();
// if we have starting point from previous trace, then preferably use that one
// (useful when tracing with offset)
if ( mTracingStartPoint != QgsPointXY() )
return mTracingStartPoint;
QgsPoint v = mCaptureCurve.endPoint();
return toMapCoordinates( layer, QgsPointXY( v.x(), v.y() ) );
}
catch ( QgsCsException & )
{
QgsDebugMsg( QStringLiteral( "transformation to layer coordinate failed" ) );
return QgsPointXY();
}
}
QgsRubberBand* QgsMapToolNodeTool::createRubberBandMarker( QgsPoint center, QgsVectorLayer* vlayer )
{
//create rubber band marker for moving points
QgsRubberBand* marker = new QgsRubberBand( mCanvas, true );
marker->setColor( Qt::red );
marker->setWidth( 2 );
double movement = 4;
double s = QgsTolerance::toleranceInMapUnits( movement, vlayer, mCanvas->mapRenderer(), QgsTolerance::Pixels );
QgsPoint pom = toMapCoordinates( vlayer, center );
pom.setX( pom.x() - s );
pom.setY( pom.y() - s );
marker->addPoint( pom );
pom.setX( pom.x() + 2*s );
marker->addPoint( pom );
pom.setY( pom.y() + 2*s );
marker->addPoint( pom );
pom.setX( pom.x() - 2*s );
marker->addPoint( pom );
pom.setY( pom.y() - 2*s );
marker->addPoint( pom );
return marker;
}
void QgsMapToolRotateLabel::canvasMoveEvent( QgsMapMouseEvent *e )
{
if ( mLabelRubberBand )
{
QgsPointXY currentPoint = toMapCoordinates( e->pos() );
double azimuth = convertAzimuth( mRotationPoint.azimuth( currentPoint ) );
double azimuthDiff = azimuth - mCurrentMouseAzimuth;
azimuthDiff = azimuthDiff > 180 ? azimuthDiff - 360 : azimuthDiff;
mCurrentRotation += azimuthDiff;
if ( mCurrentRotation >= 360 || mCurrentRotation <= -360 )
mCurrentRotation = std::fmod( mCurrentRotation, 360.0 );
if ( mCurrentRotation < 0 )
mCurrentRotation += 360.0;
mCurrentMouseAzimuth = std::fmod( azimuth, 360.0 );
//if shift-modifier is pressed, round to 15 degrees
int displayValue;
if ( e->modifiers() & Qt::ControlModifier )
{
displayValue = roundTo15Degrees( mCurrentRotation );
mCtrlPressed = true;
}
else
{
displayValue = ( int )( mCurrentRotation );
mCtrlPressed = false;
}
if ( mRotationItem )
{
mRotationItem->setSymbolRotation( displayValue );
setRotationPreviewBox( displayValue - mStartRotation );
mRotationItem->update();
}
}
}
void QgsMapToolSelectPolygon::canvasPressEvent( QMouseEvent * e )
{
if ( mRubberBand == NULL )
{
mRubberBand = new QgsRubberBand( mCanvas, true );
}
if ( e->button() == Qt::LeftButton )
{
mRubberBand->addPoint( toMapCoordinates( e->pos() ) );
}
else
{
if ( mRubberBand->numberOfVertices() > 2 )
{
QgsGeometry* polygonGeom = mRubberBand->asGeometry();
QgsMapToolSelectUtils::setSelectFeatures( mCanvas, polygonGeom, e );
delete polygonGeom;
}
mRubberBand->reset( true );
delete mRubberBand;
mRubberBand = 0;
}
}
void QgsMapToolSelectPolygon::canvasPressEvent( QgsMapMouseEvent* e )
{
if ( !mRubberBand )
{
mRubberBand = new QgsRubberBand( mCanvas, Qgis::Polygon );
mRubberBand->setFillColor( mFillColor );
mRubberBand->setBorderColor( mBorderColour );
}
if ( e->button() == Qt::LeftButton )
{
mRubberBand->addPoint( toMapCoordinates( e->pos() ) );
}
else
{
if ( mRubberBand->numberOfVertices() > 2 )
{
QgsGeometry polygonGeom = mRubberBand->asGeometry();
QgsMapToolSelectUtils::selectMultipleFeatures( mCanvas, polygonGeom, e );
}
mRubberBand->reset( Qgis::Polygon );
delete mRubberBand;
mRubberBand = nullptr;
}
}
void QgsMapToolRotateLabel::canvasMoveEvent( QgsMapMouseEvent* e )
{
if ( mLabelRubberBand )
{
QgsPoint currentPoint = toMapCoordinates( e->pos() );
double azimuth = azimuthToCCW( mRotationPoint.azimuth( currentPoint ) );
double azimuthDiff = azimuth - mCurrentMouseAzimuth;
azimuthDiff = azimuthDiff > 180 ? azimuthDiff - 360 : azimuthDiff;
mCurrentRotation += azimuthDiff;
mCurrentRotation = mCurrentRotation - static_cast<float>( static_cast<int>( mCurrentRotation / 360 ) ) * 360; //mCurrentRotation % 360;
mCurrentRotation = mCurrentRotation < 0 ? 360 - mCurrentRotation : mCurrentRotation;
mCurrentMouseAzimuth = azimuth - static_cast<float>( static_cast<int>( azimuth / 360 ) ) * 360;
//if shift-modifier is pressed, round to 15 degrees
int displayValue;
if ( e->modifiers() & Qt::ControlModifier )
{
displayValue = roundTo15Degrees( mCurrentRotation );
mCtrlPressed = true;
}
else
{
displayValue = ( int )( mCurrentRotation );
mCtrlPressed = false;
}
if ( mRotationItem )
{
mRotationItem->setSymbolRotation( displayValue );
setRotationPreviewBox( displayValue - mStartRotation );
mRotationItem->update();
}
}
}
QgsPoint QgsMapTool::toLayerCoordinates( QgsMapLayer* layer, const QPoint& point )
{
QgsPoint pt = toMapCoordinates( point );
return toLayerCoordinates( layer, pt );
}
void QgsMapToolMoveLabel::canvasReleaseEvent( QgsMapMouseEvent* e )
{
if ( !mLabelRubberBand )
{
return;
}
deleteRubberBands();
QgsMapLayer* layer = QgsMapLayerRegistry::instance()->mapLayer( mCurrentLabelPos.layerID );
if ( !layer )
{
return;
}
QgsVectorLayer* vlayer = dynamic_cast<QgsVectorLayer*>( layer );
if ( !vlayer )
{
return;
}
if ( !vlayer->isEditable() )
{
return;
}
QgsPoint releaseCoords = toMapCoordinates( e->pos() );
double xdiff = releaseCoords.x() - mStartPointMapCoords.x();
double ydiff = releaseCoords.y() - mStartPointMapCoords.y();
int xCol, yCol;
double xPosOrig, yPosOrig;
bool xSuccess, ySuccess;
if ( !dataDefinedPosition( vlayer, mCurrentLabelPos.featureId, xPosOrig, xSuccess, yPosOrig, ySuccess, xCol, yCol ) )
{
return;
}
double xPosNew, yPosNew;
if ( !xSuccess || !ySuccess )
{
xPosNew = releaseCoords.x() - mClickOffsetX;
yPosNew = releaseCoords.y() - mClickOffsetY;
}
else
{
//transform to map crs first, because xdiff,ydiff are in map coordinates
const QgsMapSettings& ms = mCanvas->mapSettings();
if ( ms.hasCrsTransformEnabled() )
{
QgsPoint transformedPoint = ms.layerToMapCoordinates( vlayer, QgsPoint( xPosOrig, yPosOrig ) );
xPosOrig = transformedPoint.x();
yPosOrig = transformedPoint.y();
}
xPosNew = xPosOrig + xdiff;
yPosNew = yPosOrig + ydiff;
}
//transform back to layer crs
if ( mCanvas )
{
const QgsMapSettings& s = mCanvas->mapSettings();
if ( s.hasCrsTransformEnabled() )
{
QgsPoint transformedPoint = s.mapToLayerCoordinates( vlayer, QgsPoint( xPosNew, yPosNew ) );
xPosNew = transformedPoint.x();
yPosNew = transformedPoint.y();
}
}
vlayer->beginEditCommand( tr( "Moved label" ) + QString( " '%1'" ).arg( currentLabelText( 24 ) ) );
vlayer->changeAttributeValue( mCurrentLabelPos.featureId, xCol, xPosNew );
vlayer->changeAttributeValue( mCurrentLabelPos.featureId, yCol, yPosNew );
// set rotation to that of label, if data-defined and no rotation set yet
// honor whether to preserve preexisting data on pin
// must come after setting x and y positions
int rCol;
if ( !mCurrentLabelPos.isDiagram
&& !mCurrentLabelPos.isPinned
&& !preserveRotation()
&& layerIsRotatable( vlayer, rCol ) )
{
double defRot;
bool rSuccess;
if ( dataDefinedRotation( vlayer, mCurrentLabelPos.featureId, defRot, rSuccess ) )
{
double labelRot = mCurrentLabelPos.rotation * 180 / M_PI;
vlayer->changeAttributeValue( mCurrentLabelPos.featureId, rCol, labelRot );
}
}
vlayer->endEditCommand();
if ( mCanvas )
mCanvas->refresh();
}
void QgsMapToolNodeTool::createMovingRubberBands()
{
int topologicalEditing = QgsProject::instance()->readNumEntry( "Digitizing", "/TopologicalEditing", 0 );
Q_ASSERT( mSelectedFeature );
QgsVectorLayer *vlayer = mSelectedFeature->vlayer();
Q_ASSERT( vlayer );
QList<QgsVertexEntry*> &vertexMap = mSelectedFeature->vertexMap();
QgsGeometry* geometry = mSelectedFeature->geometry();
int beforeVertex, afterVertex;
int lastRubberBand = 0;
int vertex;
for ( int i = 0; i < vertexMap.size(); i++ )
{
// create rubberband
if ( vertexMap[i]->isSelected() && !vertexMap[i]->isInRubberBand() )
{
geometry->adjacentVertices( i, beforeVertex, afterVertex );
vertex = i;
while ( beforeVertex != -1 )
{
// move forward NOTE: end if whole cycle is selected
if ( vertexMap[beforeVertex]->isSelected() && beforeVertex != i ) // and take care of cycles
{
vertex = beforeVertex;
geometry->adjacentVertices( vertex, beforeVertex, afterVertex );
}
else
{
// break if cycle is found
break;
}
}
// we have first vertex of moving part
// create rubberband and set default paramaters
QgsRubberBand* rb = new QgsRubberBand( mCanvas, QGis::Line );
rb->setWidth( 2 );
rb->setColor( Qt::blue );
int index = 0;
if ( beforeVertex != -1 ) // adding first point which is not moving
{
rb->addPoint( toMapCoordinates( vlayer, vertexMap[beforeVertex]->point() ), false );
vertexMap[beforeVertex]->setRubberBandValues( true, lastRubberBand, index );
index++;
}
while ( vertex != -1 && vertexMap[vertex]->isSelected() && !vertexMap[vertex]->isInRubberBand() )
{
// topology rubberband creation if needed
if ( topologicalEditing )
{
createTopologyRubberBands( vlayer, vertexMap, vertex );
}
// adding point which will be moved
rb->addPoint( toMapCoordinates( vlayer, vertexMap[vertex]->point() ), false );
// setting values about added vertex
vertexMap[vertex]->setRubberBandValues( true, lastRubberBand, index );
index++;
geometry->adjacentVertices( vertex, beforeVertex, vertex );
}
if ( vertex != -1 && !vertexMap[vertex]->isSelected() ) // add last point not moving if exists
{
rb->addPoint( toMapCoordinates( vlayer, vertexMap[vertex]->point() ), true );
vertexMap[vertex]->setRubberBandValues( true, lastRubberBand, index );
index++;
}
mRubberBands.append( rb );
lastRubberBand++;
}
}
}
void QgsMapToolNodeTool::canvasMoveEvent( QMouseEvent * e )
{
if ( !mSelectedFeature || !mClicked )
return;
QgsVectorLayer* vlayer = mSelectedFeature->vlayer();
Q_ASSERT( vlayer );
mSelectAnother = false;
if ( mMoving )
{
// create rubberband, if none exists
if ( mRubberBands.empty() )
{
if ( mIsPoint )
{
QList<QgsVertexEntry*> &vertexMap = mSelectedFeature->vertexMap();
for ( int i = 0; i < vertexMap.size(); i++ )
{
if ( vertexMap[i]->isSelected() )
{
QgsRubberBand* rb = createRubberBandMarker( vertexMap[i]->point(), vlayer );
mRubberBands.append( rb );
}
}
}
createMovingRubberBands();
QList<QgsSnappingResult> snapResults;
QgsPoint posMapCoord = snapPointFromResults( snapResults, e->pos() );
mPosMapCoordBackup = posMapCoord;
}
else
{
// move rubberband
QList<QgsSnappingResult> snapResults;
mSnapper.snapToBackgroundLayers( e->pos(), snapResults, QList<QgsPoint>() << mClosestMapVertex );
// get correct coordinates to move to
QgsPoint posMapCoord = snapPointFromResults( snapResults, e->pos() );
QgsPoint pressMapCoords;
if ( snapResults.size() > 0 )
{
pressMapCoords = mClosestMapVertex;
}
else
{
pressMapCoords = toMapCoordinates( mPressCoordinates );
}
QgsVector offset = posMapCoord - pressMapCoords;
// handle points
if ( mIsPoint )
{
for ( int i = 0; i < mRubberBands.size(); i++ )
{
mRubberBands[i]->setTranslationOffset( offset.x(), offset.y() );
}
return;
}
// move points
QList<QgsVertexEntry*> &vertexMap = mSelectedFeature->vertexMap();
for ( int i = 0; i < vertexMap.size(); i++ )
{
if ( !vertexMap[i]->isSelected() )
continue;
QgsPoint p = toMapCoordinates( vlayer, vertexMap[i]->point() ) + offset;
mRubberBands[vertexMap[i]->rubberBandNr()]->movePoint( vertexMap[i]->rubberBandIndex(), p );
if ( vertexMap[i]->rubberBandIndex() == 0 )
{
mRubberBands[vertexMap[i]->rubberBandNr()]->movePoint( 0, p );
}
}
// topological editing
offset = posMapCoord - mPosMapCoordBackup;
for ( int i = 0; i < mTopologyRubberBand.size(); i++ )
{
for ( int pointIndex = 0; pointIndex < mTopologyRubberBand[i]->numberOfVertices(); pointIndex++ )
{
if ( mTopologyRubberBandVertexes[i]->contains( pointIndex ) )
{
const QgsPoint* point = mTopologyRubberBand[i]->getPoint( 0, pointIndex );
if ( point == 0 )
{
break;
}
mTopologyRubberBand[i]->movePoint( pointIndex, *point + offset );
}
}
}
mPosMapCoordBackup = posMapCoord;
}
}
else
{
if ( !mSelectionRectangle )
{
mSelectionRectangle = true;
mSelectionRubberBand = new QRubberBand( QRubberBand::Rectangle, mCanvas );
mRect = new QRect();
mRect->setTopLeft( mPressCoordinates );
}
mRect->setBottomRight( e->pos() );
QRect normalizedRect = mRect->normalized();
mSelectionRubberBand->setGeometry( normalizedRect );
mSelectionRubberBand->show();
}
}
