[tracer] If tracing is not possible, simply use a straight line like usual

wonder-sk · wonder-sk · commit 06932d98de11 · 2016-01-20T10:39:19.000+01:00
Until now the tracing was quite strict and it would show error messages
if something went wrong with start/end-points and would not allow creation
of points outside the tracing graph. It is however more user-friendly
to allow capturing points outside of the graph, so the user does not need
to enable/disable tracing whenever capturing some extra points is needed.

Also, the warning "too many features" is hidden immediately when there
is reasonable amount of features (before it would stick there until timeout).
diff --git a/src/gui/qgsmapcanvastracer.cpp b/src/gui/qgsmapcanvastracer.cpp
@@ -45,6 +45,8 @@ QgsMapCanvasTracer* QgsMapCanvasTracer::tracerForCanvas( QgsMapCanvas* canvas )
 
 void QgsMapCanvasTracer::reportError( QgsTracer::PathError err, bool addingVertex )
 {
+  Q_UNUSED( addingVertex );
+
   if ( !mMessageBar )
     return;
 
@@ -58,17 +60,6 @@ void QgsMapCanvasTracer::reportError( QgsTracer::PathError err, bool addingVerte
     case ErrTooManyFeatures:
       message = tr( "Disabled - there are too many features displayed. Try zooming in or disable some layers." );
       break;
-    case ErrPoint1:
-      message = tr( "The start point needs to be snapped and in the visible map view" );
-      break;
-    case ErrPoint2:
-      if ( addingVertex )
-        message = tr( "The end point needs to be snapped" );
-      break;
-    case ErrNoPath:
-      if ( addingVertex )
-        message = tr( "Endpoints are not connected" );
-      break;
     case ErrNone:
     default:
       break;
diff --git a/src/gui/qgsmaptoolcapture.cpp b/src/gui/qgsmaptoolcapture.cpp
@@ -161,18 +161,18 @@ QgsPoint QgsMapToolCapture::tracingStartPoint()
 }
 
 
-void QgsMapToolCapture::tracingMouseMove( QgsMapMouseEvent* e )
+bool QgsMapToolCapture::tracingMouseMove( QgsMapMouseEvent* e )
 {
   if ( !e->isSnapped() )
-    return;
+    return false;
 
   QgsPoint pt0 = tracingStartPoint();
   if ( pt0 == QgsPoint() )
-    return;
+    return false;
 
   QgsMapCanvasTracer* tracer = QgsMapCanvasTracer::tracerForCanvas( mCanvas );
   if ( !tracer )
-    return;  // this should not happen!
+    return false;  // this should not happen!
 
   mTempRubberBand->reset( mCaptureMode == CapturePolygon ? QGis::Polygon : QGis::Line );
 
@@ -181,7 +181,7 @@ void QgsMapToolCapture::tracingMouseMove( QgsMapMouseEvent* e )
   if ( points.isEmpty() )
   {
     tracer->reportError( err, false );
-    return;
+    return false;
   }
 
   if ( mCaptureMode == CapturePolygon )
@@ -190,6 +190,9 @@ void QgsMapToolCapture::tracingMouseMove( QgsMapMouseEvent* e )
   //  update rubberband
   for ( int i = 0; i < points.count(); ++i )
     mTempRubberBand->addPoint( points.at( i ), i == points.count() - 1 );
+
+  tracer->reportError( QgsTracer::ErrNone, false ); // clear messagebar if there was any error
+  return true;
 }
 
 
@@ -227,10 +230,7 @@ bool QgsMapToolCapture::tracingAddVertex( const QgsPoint& point )
   QgsTracer::PathError err;
   QVector<QgsPoint> points = tracer->findShortestPath( pt0, point, &err );
   if ( points.isEmpty() )
-  {
-    tracer->reportError( err, true );
     return false; // ignore the vertex - can't find path to the end point!
-  }
 
   // transform points
   QList<QgsPointV2> layerPoints;
@@ -249,6 +249,8 @@ bool QgsMapToolCapture::tracingAddVertex( const QgsPoint& point )
     mRubberBand->addPoint( points[i], i == points.count() - 1 );
     mCaptureCurve.addVertex( layerPoints[i-1] );
   }
+
+  tracer->reportError( QgsTracer::ErrNone, true ); // clear messagebar if there was any error
   return true;
 }
 
@@ -287,11 +289,13 @@ void QgsMapToolCapture::cadCanvasMoveEvent( QgsMapMouseEvent * e )
 
   if ( mCaptureMode != CapturePoint && mTempRubberBand && mCapturing )
   {
+    bool hasTrace = false;
     if ( tracingEnabled() && mCaptureCurve.numPoints() != 0 )
     {
-      tracingMouseMove( e );
+      hasTrace = tracingMouseMove( e );
     }
-    else
+
+    if ( !hasTrace )
     {
       if ( mCaptureCurve.numPoints() > 0 &&
            (( mCaptureMode == CaptureLine && mTempRubberBand->numberOfVertices() != 2 ) ||
@@ -371,13 +375,13 @@ int QgsMapToolCapture::addVertex( const QgsPoint& point )
     mTempRubberBand->reset( mCaptureMode == CapturePolygon ? QGis::Polygon : QGis::Line );
   }
 
+  bool traceCreated = false;
   if ( tracingEnabled() )
   {
-    bool res = tracingAddVertex( point );
-    if ( !res )
-      return 1;  // early exit if the point cannot be accepted
+    traceCreated = tracingAddVertex( point );
   }
-  else
+
+  if ( !traceCreated )
   {
     // ordinary digitizing
     mRubberBand->addPoint( point );
diff --git a/src/gui/qgsmaptoolcapture.h b/src/gui/qgsmaptoolcapture.h
@@ -146,7 +146,7 @@ class GUI_EXPORT QgsMapToolCapture : public QgsMapToolAdvancedDigitizing
     //! first point that will be used as a start of the trace
     QgsPoint tracingStartPoint();
     //! handle of mouse movement when tracing enabled and capturing has started
-    void tracingMouseMove( QgsMapMouseEvent* e );
+    bool tracingMouseMove( QgsMapMouseEvent* e );
     //! handle of addition of clicked point (with the rest of the trace) when tracing enabled
     bool tracingAddVertex( const QgsPoint& point );
 

Original file line number	Diff line number	Diff line change
`@@ -161,18 +161,18 @@ QgsPoint QgsMapToolCapture::tracingStartPoint()`
`161`	`161`	`}`
`162`	`162`
`163`	`163`
`164`		`-void QgsMapToolCapture::tracingMouseMove( QgsMapMouseEvent* e )`
	`164`	`+bool QgsMapToolCapture::tracingMouseMove( QgsMapMouseEvent* e )`
`165`	`165`	`{`
`166`	`166`	`if ( !e->isSnapped() )`
`167`		`- return;`
	`167`	`+ return false;`
`168`	`168`
`169`	`169`	`QgsPoint pt0 = tracingStartPoint();`
`170`	`170`	`if ( pt0 == QgsPoint() )`
`171`		`- return;`
	`171`	`+ return false;`
`172`	`172`
`173`	`173`	`QgsMapCanvasTracer* tracer = QgsMapCanvasTracer::tracerForCanvas( mCanvas );`
`174`	`174`	`if ( !tracer )`
`175`		`- return; // this should not happen!`
	`175`	`+ return false; // this should not happen!`
`176`	`176`
`177`	`177`	`mTempRubberBand->reset( mCaptureMode == CapturePolygon ? QGis::Polygon : QGis::Line );`
`178`	`178`
`@@ -181,7 +181,7 @@ void QgsMapToolCapture::tracingMouseMove( QgsMapMouseEvent* e )`
`181`	`181`	`if ( points.isEmpty() )`
`182`	`182`	`{`
`183`	`183`	`tracer->reportError( err, false );`
`184`		`- return;`
	`184`	`+ return false;`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`if ( mCaptureMode == CapturePolygon )`
`@@ -190,6 +190,9 @@ void QgsMapToolCapture::tracingMouseMove( QgsMapMouseEvent* e )`
`190`	`190`	`// update rubberband`
`191`	`191`	`for ( int i = 0; i < points.count(); ++i )`
`192`	`192`	`mTempRubberBand->addPoint( points.at( i ), i == points.count() - 1 );`
	`193`	`+`
	`194`	`+ tracer->reportError( QgsTracer::ErrNone, false ); // clear messagebar if there was any error`
	`195`	`+ return true;`
`193`	`196`	`}`
`194`	`197`
`195`	`198`
`@@ -227,10 +230,7 @@ bool QgsMapToolCapture::tracingAddVertex( const QgsPoint& point )`
`227`	`230`	`QgsTracer::PathError err;`
`228`	`231`	`QVector<QgsPoint> points = tracer->findShortestPath( pt0, point, &err );`
`229`	`232`	`if ( points.isEmpty() )`
`230`		`- {`
`231`		`- tracer->reportError( err, true );`
`232`	`233`	`return false; // ignore the vertex - can't find path to the end point!`
`233`		`- }`
`234`	`234`
`235`	`235`	`// transform points`
`236`	`236`	`QList<QgsPointV2> layerPoints;`
`@@ -249,6 +249,8 @@ bool QgsMapToolCapture::tracingAddVertex( const QgsPoint& point )`
`249`	`249`	`mRubberBand->addPoint( points[i], i == points.count() - 1 );`
`250`	`250`	`mCaptureCurve.addVertex( layerPoints[i-1] );`
`251`	`251`	`}`
	`252`	`+`
	`253`	`+ tracer->reportError( QgsTracer::ErrNone, true ); // clear messagebar if there was any error`
`252`	`254`	`return true;`
`253`	`255`	`}`
`254`	`256`
`@@ -287,11 +289,13 @@ void QgsMapToolCapture::cadCanvasMoveEvent( QgsMapMouseEvent * e )`
`287`	`289`
`288`	`290`	`if ( mCaptureMode != CapturePoint && mTempRubberBand && mCapturing )`
`289`	`291`	`{`
	`292`	`+ bool hasTrace = false;`
`290`	`293`	`if ( tracingEnabled() && mCaptureCurve.numPoints() != 0 )`
`291`	`294`	`{`
`292`		`- tracingMouseMove( e );`
	`295`	`+ hasTrace = tracingMouseMove( e );`
`293`	`296`	`}`
`294`		`- else`
	`297`	`+`
	`298`	`+ if ( !hasTrace )`
`295`	`299`	`{`
`296`	`300`	`if ( mCaptureCurve.numPoints() > 0 &&`
`297`	`301`	`(( mCaptureMode == CaptureLine && mTempRubberBand->numberOfVertices() != 2 ) \|\|`
`@@ -371,13 +375,13 @@ int QgsMapToolCapture::addVertex( const QgsPoint& point )`
`371`	`375`	`mTempRubberBand->reset( mCaptureMode == CapturePolygon ? QGis::Polygon : QGis::Line );`
`372`	`376`	`}`
`373`	`377`
	`378`	`+ bool traceCreated = false;`
`374`	`379`	`if ( tracingEnabled() )`
`375`	`380`	`{`
`376`		`- bool res = tracingAddVertex( point );`
`377`		`- if ( !res )`
`378`		`- return 1; // early exit if the point cannot be accepted`
	`381`	`+ traceCreated = tracingAddVertex( point );`
`379`	`382`	`}`
`380`		`- else`
	`383`	`+`
	`384`	`+ if ( !traceCreated )`
`381`	`385`	`{`
`382`	`386`	`// ordinary digitizing`
`383`	`387`	`mRubberBand->addPoint( point );`