自学教程：C++ toMapCoordinates函数代码示例

//! mouse button releasedvoid 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 canvasvoid 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 canvasvoid 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++;    }  }}