← Back to branch summary

~ubuntu-branches/ubuntu/wily/qgis/wily

« back to all changes in this revision

Viewing changes to src/plugins/grass/qgsgrassedittools.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Johan Van de Wauw
  • Date: 2010-07-11 20:23:24 UTC
  • mfrom: (3.1.4 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100711202324-5ktghxa7hracohmr
Tags: 1.4.0+12730-3ubuntu1
https://launchpad.net/bugs/540941
* Merge from Debian unstable (LP: #540941).
* Fix compilation issues with QT 4.7
* Add build-depends on libqt4-webkit-dev 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/grass/qgsgrassedittools.cpp
14
14
 *                                                                         *
15
15
 ***************************************************************************/
16
16
 
17
 
#include "qgsmapcanvas.h"
18
 
#include "qgsmaplayer.h"
19
 
#include "qgsvectorlayer.h"
20
17
#include "qgsgrassedittools.h"
 
18
#include "qgsgrassattributes.h"
21
19
#include "qgsgrassedit.h"
22
 
#include "qgsgrassattributes.h"
23
 
#include "../../src/providers/grass/qgsgrassprovider.h"
 
20
#include "qgsgrassprovider.h"
 
21
 
 
22
#include "qgisinterface.h"
 
23
#include "qgslogger.h"
 
24
#include "qgsmapcanvas.h"
24
25
#include "qgsvertexmarker.h"
25
26
 
26
 
extern "C" {
27
 
#include <grass/gis.h>
 
27
#include <QMouseEvent>
 
28
 
 
29
extern "C"
 
30
{
28
31
#include <grass/Vect.h>
29
32
}
30
33
 
31
34
 
32
 
 
33
 
QgsGrassEditTool::QgsGrassEditTool(QgsGrassEdit* edit)
34
 
  : QgsMapTool(edit->mCanvas), e(edit)
 
35
QgsGrassEditTool::QgsGrassEditTool( QgsGrassEdit* edit )
 
36
    : QgsMapTool( edit->mCanvas ), e( edit )
35
37
{
36
38
}
37
39
 
38
 
void QgsGrassEditTool::canvasPressEvent(QMouseEvent * event)
 
40
void QgsGrassEditTool::canvasPressEvent( QMouseEvent * event )
39
41
{
40
 
  QgsPoint point = toLayerCoords(e->layer(), event->pos());
41
 
  mouseClick(point,  event->button());
 
42
  QgsPoint point = toLayerCoordinates( e->layer(), event->pos() );
 
43
  mouseClick( point,  event->button() );
42
44
 
43
45
  // Set last click
44
46
  e->mLastPoint = point;
45
47
 
46
 
  e->statusBar()->message(e->mCanvasPrompt);
 
48
  e->statusBar()->showMessage( e->mCanvasPrompt );
47
49
 
48
 
#ifdef QGISDEBUG
49
 
  std::cerr << "n_points = " << e->mEditPoints->n_points << std::endl;
50
 
#endif
 
50
  QgsDebugMsg( QString( "n_points = %1" ).arg( e->mEditPoints->n_points ) );
51
51
}
52
52
 
53
 
void QgsGrassEditTool::canvasMoveEvent(QMouseEvent * event)
 
53
void QgsGrassEditTool::canvasMoveEvent( QMouseEvent * event )
54
54
{
55
 
  QgsPoint point = toLayerCoords(e->layer(), event->pos());
56
 
  mouseMove(point);
 
55
  QgsPoint point = toLayerCoordinates( e->layer(), event->pos() );
 
56
  mouseMove( point );
57
57
 
58
 
  e->statusBar()->message(e->mCanvasPrompt);
 
58
  e->statusBar()->showMessage( e->mCanvasPrompt );
59
59
}
60
60
 
61
61
 
64
64
// ------------------------------------------------------------------
65
65
 
66
66
 
67
 
QgsGrassEditNewPoint::QgsGrassEditNewPoint(QgsGrassEdit* edit, bool newCentroid)
68
 
  : QgsGrassEditTool(edit), mNewCentroid(newCentroid)
 
67
QgsGrassEditNewPoint::QgsGrassEditNewPoint( QgsGrassEdit* edit, bool newCentroid )
 
68
    : QgsGrassEditTool( edit ), mNewCentroid( newCentroid )
69
69
{
70
 
  if (newCentroid)
71
 
    e->setCanvasPropmt( QObject::tr("New centroid"), "", "" );
 
70
  if ( newCentroid )
 
71
    e->setCanvasPrompt( tr( "New centroid" ), "", "" );
72
72
  else
73
 
    e->setCanvasPropmt( QObject::tr("New point"), "", "" );
 
73
    e->setCanvasPrompt( tr( "New point" ), "", "" );
74
74
 
75
75
}
76
76
 
77
77
 
78
 
void QgsGrassEditNewPoint::mouseClick(QgsPoint & point, Qt::ButtonState button)
 
78
void QgsGrassEditNewPoint::mouseClick( QgsPoint & point, Qt::MouseButton button )
79
79
{
80
 
    Vect_reset_line ( e->mEditPoints );
81
 
    e->snap ( point ); 
82
 
    Vect_append_point ( e->mEditPoints, point.x(), point.y(), 0.0 );
83
 
 
84
 
    int type;
85
 
    if (mNewCentroid) // new centroid or point ?
86
 
      type = GV_CENTROID;
87
 
    else
88
 
      type = GV_POINT;
89
 
 
90
 
    int line;
91
 
    line = e->writeLine ( type, e->mEditPoints );
92
 
    e->updateSymb();
93
 
    e->displayUpdated();
94
 
 
95
 
    if ( e->mAttributes ) 
96
 
    {
97
 
        e->mAttributes->setLine ( line );
98
 
        e->mAttributes->clear();
99
 
    }
100
 
    else
101
 
    {
102
 
        e->mAttributes = new QgsGrassAttributes ( e, e->mProvider, line, e->mQgisApp );
103
 
    }
104
 
    for ( int i = 0; i < e->mCats->n_cats; i++ ) {
105
 
      e->addAttributes ( e->mCats->field[i], e->mCats->cat[i] );
106
 
    }
107
 
    e->mAttributes->show();
108
 
    e->mAttributes->raise();
 
80
  if ( button != Qt::LeftButton )
 
81
    return;
 
82
 
 
83
  Vect_reset_line( e->mEditPoints );
 
84
  e->snap( point );
 
85
  Vect_append_point( e->mEditPoints, point.x(), point.y(), 0.0 );
 
86
 
 
87
  int type;
 
88
  if ( mNewCentroid ) // new centroid or point ?
 
89
    type = GV_CENTROID;
 
90
  else
 
91
    type = GV_POINT;
 
92
 
 
93
  int line;
 
94
  line = e->writeLine( type, e->mEditPoints );
 
95
  e->updateSymb();
 
96
  e->displayUpdated();
 
97
 
 
98
  if ( e->mAttributes )
 
99
  {
 
100
    e->mAttributes->setLine( line );
 
101
    e->mAttributes->clear();
 
102
  }
 
103
  else
 
104
  {
 
105
    e->mAttributes = new QgsGrassAttributes( e, e->mProvider, line, e->mIface->mainWindow() );
 
106
  }
 
107
  for ( int i = 0; i < e->mCats->n_cats; i++ )
 
108
  {
 
109
    e->addAttributes( e->mCats->field[i], e->mCats->cat[i] );
 
110
  }
 
111
  e->mAttributes->show();
 
112
  e->mAttributes->raise();
109
113
}
110
114
 
111
115
 
113
117
// NEW LINE + NEW BOUNDARY
114
118
// ------------------------------------------------------------------
115
119
 
116
 
QgsGrassEditNewLine::QgsGrassEditNewLine(QgsGrassEdit* edit, bool newBoundary)
117
 
  : QgsGrassEditTool(edit), mNewBoundary(newBoundary)
 
120
QgsGrassEditNewLine::QgsGrassEditNewLine( QgsGrassEdit* edit, bool newBoundary )
 
121
    : QgsGrassEditTool( edit ), mNewBoundary( newBoundary )
118
122
{
119
 
  e->setCanvasPropmt( QObject::tr("New vertex"), "", "");
 
123
  e->setCanvasPrompt( tr( "New vertex" ), "", "" );
120
124
}
121
125
 
122
126
void QgsGrassEditNewLine::deactivate()
123
127
{
124
128
  // Delete last segment
125
 
  if ( e->mEditPoints->n_points > 1 ) {
126
 
      Vect_reset_line ( e->mPoints );
127
 
      Vect_append_points ( e->mPoints, e->mEditPoints, GV_FORWARD );
128
 
      e->displayDynamic ( e->mPoints );
 
129
  if ( e->mEditPoints->n_points > 1 )
 
130
  {
 
131
    Vect_reset_line( e->mPoints );
 
132
    Vect_append_points( e->mPoints, e->mEditPoints, GV_FORWARD );
 
133
    e->displayDynamic( e->mPoints );
129
134
  }
130
 
  e->setCanvasPropmt( QObject::tr("New vertex"), "", "");
131
 
  
 
135
  e->setCanvasPrompt( tr( "New vertex" ), "", "" );
 
136
 
132
137
  QgsGrassEditTool::deactivate(); // call default bahivour
133
138
}
134
139
 
135
140
void QgsGrassEditNewLine::activate()
136
141
{
137
 
  std::cerr << "QgsGrassEditNewLine::activate()" << std::endl;
 
142
  QgsDebugMsg( "entered." );
138
143
 
139
144
  // Display dynamic segment
140
 
  if ( e->mEditPoints->n_points > 0 ) {
141
 
      Vect_reset_line ( e->mPoints );
142
 
      Vect_append_points ( e->mPoints, e->mEditPoints, GV_FORWARD );
143
 
      QgsPoint point = toMapCoords( e->mCanvas->mouseLastXY() );
144
 
      Vect_append_point ( e->mPoints, point.x(), point.y(), 0.0 );
145
 
      e->displayDynamic ( e->mPoints );
 
145
  if ( e->mEditPoints->n_points > 0 )
 
146
  {
 
147
    Vect_reset_line( e->mPoints );
 
148
    Vect_append_points( e->mPoints, e->mEditPoints, GV_FORWARD );
 
149
    QgsPoint point = toMapCoordinates( e->mCanvas->mouseLastXY() );
 
150
    Vect_append_point( e->mPoints, point.x(), point.y(), 0.0 );
 
151
    e->displayDynamic( e->mPoints );
146
152
  }
147
 
  
 
153
 
148
154
  QgsGrassEditTool::activate(); // call default bahivour
149
155
}
150
156
 
151
 
void QgsGrassEditNewLine::mouseClick(QgsPoint & point, Qt::ButtonState button)
 
157
void QgsGrassEditNewLine::mouseClick( QgsPoint & point, Qt::MouseButton button )
152
158
{
153
 
  switch ( button ) {
 
159
  switch ( button )
 
160
  {
154
161
    case Qt::LeftButton:
155
162
      if ( e->mEditPoints->n_points > 2 )
156
163
      {
157
 
          e->snap ( point, e->mEditPoints->x[0], e->mEditPoints->y[0] ); 
 
164
        e->snap( point, e->mEditPoints->x[0], e->mEditPoints->y[0] );
158
165
      }
159
166
      else
160
167
      {
161
 
          e->snap ( point ); 
 
168
        e->snap( point );
162
169
      }
163
 
      Vect_append_point ( e->mEditPoints, point.x(), point.y(), 0.0 );
 
170
      Vect_append_point( e->mEditPoints, point.x(), point.y(), 0.0 );
164
171
 
165
172
      // Draw
166
 
      Vect_reset_line ( e->mPoints );
167
 
      Vect_append_points ( e->mPoints, e->mEditPoints, GV_FORWARD );
168
 
      e->displayDynamic ( e->mPoints );
 
173
      Vect_reset_line( e->mPoints );
 
174
      Vect_append_points( e->mPoints, e->mEditPoints, GV_FORWARD );
 
175
      e->displayDynamic( e->mPoints );
169
176
      break;
170
177
    case Qt::MidButton:
171
 
      if ( e->mEditPoints->n_points > 0 ) {
 
178
      if ( e->mEditPoints->n_points > 0 )
 
179
      {
172
180
        e->mEditPoints->n_points--;
173
 
        Vect_reset_line ( e->mPoints );
174
 
        Vect_append_points ( e->mPoints, e->mEditPoints, GV_FORWARD );
175
 
        QgsPoint point = toMapCoords( e->mCanvas->mouseLastXY() );
176
 
        Vect_append_point ( e->mPoints, point.x(), point.y(), 0.0 );
177
 
        e->displayDynamic ( e->mPoints );
 
181
        Vect_reset_line( e->mPoints );
 
182
        Vect_append_points( e->mPoints, e->mEditPoints, GV_FORWARD );
 
183
        QgsPoint point = toMapCoordinates( e->mCanvas->mouseLastXY() );
 
184
        Vect_append_point( e->mPoints, point.x(), point.y(), 0.0 );
 
185
        e->displayDynamic( e->mPoints );
178
186
      }
179
187
      break;
180
188
    case Qt::RightButton:
181
189
      e->eraseDynamic();
182
 
      if ( e->mEditPoints->n_points > 1 ) {
 
190
      if ( e->mEditPoints->n_points > 1 )
 
191
      {
183
192
        int type;
184
193
 
185
194
        if ( mNewBoundary ) // boundary or line?
188
197
          type = GV_LINE;
189
198
 
190
199
        int line;
191
 
        line = e->writeLine ( type, e->mEditPoints );
 
200
        line = e->writeLine( type, e->mEditPoints );
192
201
        e->updateSymb();
193
202
        e->displayUpdated();
194
203
 
195
 
        if ( e->mAttributes ) 
196
 
        {
197
 
            e->mAttributes->setLine ( line );
198
 
            e->mAttributes->clear();
199
 
        }
200
 
        else
201
 
        {
202
 
            e->mAttributes = new QgsGrassAttributes ( e, e->mProvider, line, e->mQgisApp );
203
 
        }
204
 
        for ( int i = 0; i < e->mCats->n_cats; i++ ) {
205
 
          e->addAttributes ( e->mCats->field[i], e->mCats->cat[i] );
 
204
        if ( e->mAttributes )
 
205
        {
 
206
          e->mAttributes->setLine( line );
 
207
          e->mAttributes->clear();
 
208
        }
 
209
        else
 
210
        {
 
211
          e->mAttributes = new QgsGrassAttributes( e, e->mProvider, line, e->mIface->mainWindow() );
 
212
        }
 
213
        for ( int i = 0; i < e->mCats->n_cats; i++ )
 
214
        {
 
215
          e->addAttributes( e->mCats->field[i], e->mCats->cat[i] );
206
216
        }
207
217
        e->mAttributes->show();
208
218
        e->mAttributes->raise();
209
219
      }
210
 
      Vect_reset_line ( e->mEditPoints );
211
 
      break;
212
 
  }
213
 
  
214
 
  if ( e->mEditPoints->n_points == 0 ) {
215
 
    e->setCanvasPropmt( QObject::tr("New point"), "", "");
216
 
  } else if ( e->mEditPoints->n_points == 1 ) {
217
 
    e->setCanvasPropmt( QObject::tr("New point"), QObject::tr("Undo last point"), "" );
218
 
  } else if ( e->mEditPoints->n_points > 1 ) {
219
 
    e->setCanvasPropmt( QObject::tr("New point"), QObject::tr("Undo last point"), QObject::tr("Close line"));
 
220
      Vect_reset_line( e->mEditPoints );
 
221
      break;
 
222
 
 
223
    default:
 
224
      // ignore others
 
225
      break;
 
226
  }
 
227
 
 
228
  if ( e->mEditPoints->n_points == 0 )
 
229
  {
 
230
    e->setCanvasPrompt( tr( "New point" ), "", "" );
 
231
  }
 
232
  else if ( e->mEditPoints->n_points == 1 )
 
233
  {
 
234
    e->setCanvasPrompt( tr( "New point" ), tr( "Undo last point" ), "" );
 
235
  }
 
236
  else if ( e->mEditPoints->n_points > 1 )
 
237
  {
 
238
    e->setCanvasPrompt( tr( "New point" ), tr( "Undo last point" ), tr( "Close line" ) );
220
239
  }
221
240
}
222
241
 
223
 
void QgsGrassEditNewLine::mouseMove(QgsPoint & newPoint)
 
242
void QgsGrassEditNewLine::mouseMove( QgsPoint & newPoint )
224
243
{
225
 
    if ( e->mEditPoints->n_points > 0 ) {
226
 
        // Draw the line with new segment
227
 
      Vect_reset_line ( e->mPoints );
228
 
      Vect_append_points ( e->mPoints, e->mEditPoints, GV_FORWARD );
229
 
      Vect_append_point ( e->mPoints, newPoint.x(), newPoint.y(), 0.0 );
230
 
      e->displayDynamic ( e->mPoints );
231
 
    }
 
244
  if ( e->mEditPoints->n_points > 0 )
 
245
  {
 
246
    // Draw the line with new segment
 
247
    Vect_reset_line( e->mPoints );
 
248
    Vect_append_points( e->mPoints, e->mEditPoints, GV_FORWARD );
 
249
    Vect_append_point( e->mPoints, newPoint.x(), newPoint.y(), 0.0 );
 
250
    e->displayDynamic( e->mPoints );
 
251
  }
232
252
}
233
253
 
234
254
 
236
256
// MOVE VERTEX
237
257
// ------------------------------------------------------------------
238
258
 
239
 
QgsGrassEditMoveVertex::QgsGrassEditMoveVertex(QgsGrassEdit* edit)
240
 
  : QgsGrassEditTool(edit)
 
259
QgsGrassEditMoveVertex::QgsGrassEditMoveVertex( QgsGrassEdit* edit )
 
260
    : QgsGrassEditTool( edit )
241
261
{
242
 
  e->setCanvasPropmt( QObject::tr("Select vertex"), "", "" );
 
262
  e->setCanvasPrompt( tr( "Select vertex" ), "", "" );
243
263
}
244
 
    
245
 
void QgsGrassEditMoveVertex::mouseClick(QgsPoint & point, Qt::ButtonState button)
 
264
 
 
265
void QgsGrassEditMoveVertex::mouseClick( QgsPoint & point, Qt::MouseButton button )
246
266
{
247
267
  double thresh = e->threshold();
248
268
 
249
 
  switch ( button ) {
 
269
  switch ( button )
 
270
  {
250
271
    case Qt::LeftButton:
251
 
      // Move previously selected vertex 
252
 
      if ( e->mSelectedLine > 0 ) {
 
272
      // Move previously selected vertex
 
273
      if ( e->mSelectedLine > 0 )
 
274
      {
253
275
        e->eraseDynamic();
254
 
        e->eraseElement ( e->mSelectedLine );
 
276
        e->eraseElement( e->mSelectedLine );
255
277
 
256
278
        // Move vertex
257
 
        int type = e->mProvider->readLine ( e->mPoints, e->mCats, e->mSelectedLine );
258
 
        e->snap ( point ); 
 
279
        int type = e->mProvider->readLine( e->mPoints, e->mCats, e->mSelectedLine );
 
280
        e->snap( point );
259
281
        e->mPoints->x[e->mSelectedPart] = point.x();
260
282
        e->mPoints->y[e->mSelectedPart] = point.y();
261
283
 
262
 
        Vect_line_prune ( e->mPoints );
263
 
        e->mProvider->rewriteLine ( e->mSelectedLine, type, e->mPoints, e->mCats );
 
284
        Vect_line_prune( e->mPoints );
 
285
        e->mProvider->rewriteLine( e->mSelectedLine, type, e->mPoints, e->mCats );
264
286
        e->updateSymb();
265
287
        e->displayUpdated();
266
288
 
267
289
        e->mSelectedLine = 0;
268
 
        Vect_reset_line ( e->mEditPoints );
 
290
        Vect_reset_line( e->mEditPoints );
269
291
 
270
 
        e->setCanvasPropmt( QObject::tr("Select vertex"), "", "" );
271
 
      } else {
 
292
        e->setCanvasPrompt( tr( "Select vertex" ), "", "" );
 
293
      }
 
294
      else
 
295
      {
272
296
        // Select new line
273
 
        e->mSelectedLine = e->mProvider->findLine ( point.x(), point.y(), GV_LINES, thresh );
 
297
        e->mSelectedLine = e->mProvider->findLine( point.x(), point.y(), GV_LINES, thresh );
274
298
 
275
 
        if ( e->mSelectedLine ) { // highlite
276
 
          e->mProvider->readLine ( e->mEditPoints, NULL, e->mSelectedLine );
277
 
          e->displayElement ( e->mSelectedLine, e->mSymb[QgsGrassEdit::SYMB_HIGHLIGHT], e->mSize );
 
299
        if ( e->mSelectedLine )   // highlite
 
300
        {
 
301
          e->mProvider->readLine( e->mEditPoints, NULL, e->mSelectedLine );
 
302
          e->displayElement( e->mSelectedLine, e->mSymb[QgsGrassEdit::SYMB_HIGHLIGHT], e->mSize );
278
303
 
279
304
          double xl, yl; // nearest point on the line
280
305
 
281
306
          // Note first segment is 1!
282
 
          e->mSelectedPart = Vect_line_distance ( e->mEditPoints, point.x(), point.y(), 0.0, 0, 
283
 
                                               &xl, &yl, NULL, NULL, NULL, NULL );
 
307
          e->mSelectedPart = Vect_line_distance( e->mEditPoints, point.x(), point.y(), 0.0, 0,
 
308
                                                 &xl, &yl, NULL, NULL, NULL, NULL );
284
309
 
285
 
          double dist1 = Vect_points_distance ( xl, yl, 0.0, e->mEditPoints->x[e->mSelectedPart-1], 
286
 
              e->mEditPoints->y[e->mSelectedPart-1], 0.0, 0);
287
 
          double dist2 = Vect_points_distance ( xl, yl, 0.0, e->mEditPoints->x[e->mSelectedPart], 
288
 
              e->mEditPoints->y[e->mSelectedPart], 0.0, 0);
 
310
          double dist1 = Vect_points_distance( xl, yl, 0.0, e->mEditPoints->x[e->mSelectedPart-1],
 
311
                                               e->mEditPoints->y[e->mSelectedPart-1], 0.0, 0 );
 
312
          double dist2 = Vect_points_distance( xl, yl, 0.0, e->mEditPoints->x[e->mSelectedPart],
 
313
                                               e->mEditPoints->y[e->mSelectedPart], 0.0, 0 );
289
314
 
290
315
          if ( dist1 < dist2 ) e->mSelectedPart--;
291
316
 
292
 
          e->setCanvasPropmt( QObject::tr("Select new position"), "", "Release vertex" );
 
317
          e->setCanvasPrompt( tr( "Select new position" ), "", "Release vertex" );
293
318
        }
294
319
      }
295
320
      break;
296
321
 
297
322
    case Qt::RightButton:
298
323
      e->eraseDynamic();
299
 
      e->displayElement ( e->mSelectedLine, e->mSymb[e->mLineSymb[e->mSelectedLine]], e->mSize );
 
324
      e->displayElement( e->mSelectedLine, e->mSymb[e->mLineSymb[e->mSelectedLine]], e->mSize );
300
325
      e->mSelectedLine = 0;
301
 
      Vect_reset_line ( e->mEditPoints );
 
326
      Vect_reset_line( e->mEditPoints );
302
327
 
303
 
      e->setCanvasPropmt( QObject::tr("Select vertex"), "", "" );
 
328
      e->setCanvasPrompt( tr( "Select vertex" ), "", "" );
304
329
      break;
305
330
 
306
 
    case Qt::MidButton:
 
331
    default:
 
332
      // ignore others
307
333
      break;
308
334
  }
309
335
 
310
336
}
311
337
 
312
 
void QgsGrassEditMoveVertex::mouseMove(QgsPoint & newPoint)
 
338
void QgsGrassEditMoveVertex::mouseMove( QgsPoint & newPoint )
313
339
{
314
 
  if ( e->mSelectedLine > 0 ) {
 
340
  if ( e->mSelectedLine > 0 )
 
341
  {
315
342
    // Transform coordinates
316
 
    Vect_reset_line ( e->mPoints );
317
 
    if ( e->mSelectedPart == 0 ) {
318
 
      Vect_append_point ( e->mPoints, e->mEditPoints->x[1], e->mEditPoints->y[1], 0.0 );
319
 
      Vect_append_point ( e->mPoints, newPoint.x(), newPoint.y(), 0.0 );
320
 
    } else if ( e->mSelectedPart == e->mEditPoints->n_points-1 ) {
321
 
      Vect_append_point ( e->mPoints, e->mEditPoints->x[e->mSelectedPart-1], 
322
 
                          e->mEditPoints->y[e->mSelectedPart-1], 0.0 );
323
 
      Vect_append_point ( e->mPoints, newPoint.x(), newPoint.y(), 0.0 );
324
 
    } else {
325
 
      Vect_append_point ( e->mPoints, e->mEditPoints->x[e->mSelectedPart-1], 
326
 
                          e->mEditPoints->y[e->mSelectedPart-1], 0.0 );
327
 
      Vect_append_point ( e->mPoints, newPoint.x(), newPoint.y(), 0.0 );
328
 
      Vect_append_point ( e->mPoints, e->mEditPoints->x[e->mSelectedPart+1], 
329
 
                          e->mEditPoints->y[e->mSelectedPart+1], 0.0 );
330
 
    }
331
 
    for (int i = 0; i < e->mPoints->n_points; i++ ) {
332
 
      std::cerr << e->mPoints->x[i] << " " << e->mPoints->y[i] << std::endl;
 
343
    Vect_reset_line( e->mPoints );
 
344
    if ( e->mSelectedPart == 0 )
 
345
    {
 
346
      Vect_append_point( e->mPoints, e->mEditPoints->x[1], e->mEditPoints->y[1], 0.0 );
 
347
      Vect_append_point( e->mPoints, newPoint.x(), newPoint.y(), 0.0 );
 
348
    }
 
349
    else if ( e->mSelectedPart == e->mEditPoints->n_points - 1 )
 
350
    {
 
351
      Vect_append_point( e->mPoints, e->mEditPoints->x[e->mSelectedPart-1],
 
352
                         e->mEditPoints->y[e->mSelectedPart-1], 0.0 );
 
353
      Vect_append_point( e->mPoints, newPoint.x(), newPoint.y(), 0.0 );
 
354
    }
 
355
    else
 
356
    {
 
357
      Vect_append_point( e->mPoints, e->mEditPoints->x[e->mSelectedPart-1],
 
358
                         e->mEditPoints->y[e->mSelectedPart-1], 0.0 );
 
359
      Vect_append_point( e->mPoints, newPoint.x(), newPoint.y(), 0.0 );
 
360
      Vect_append_point( e->mPoints, e->mEditPoints->x[e->mSelectedPart+1],
 
361
                         e->mEditPoints->y[e->mSelectedPart+1], 0.0 );
 
362
    }
 
363
    for ( int i = 0; i < e->mPoints->n_points; i++ )
 
364
    {
 
365
      QgsDebugMsg( QString( "%1 %2" ).arg( e->mPoints->x[i] ).arg( e->mPoints->y[i] ) );
333
366
    }
334
367
 
335
 
    e->displayDynamic ( e->mPoints );
 
368
    e->displayDynamic( e->mPoints );
336
369
  }
337
370
}
338
371
 
341
374
// ADD VERTEX
342
375
// ------------------------------------------------------------------
343
376
 
344
 
QgsGrassEditAddVertex::QgsGrassEditAddVertex(QgsGrassEdit* edit)
345
 
  : QgsGrassEditTool(edit)
 
377
QgsGrassEditAddVertex::QgsGrassEditAddVertex( QgsGrassEdit* edit )
 
378
    : QgsGrassEditTool( edit )
346
379
{
347
 
  e->setCanvasPropmt( QObject::tr("Select line segment"), "", "" );
 
380
  e->setCanvasPrompt( tr( "Select line segment" ), "", "" );
348
381
}
349
 
    
350
 
void QgsGrassEditAddVertex::mouseClick(QgsPoint & point, Qt::ButtonState button)
 
382
 
 
383
void QgsGrassEditAddVertex::mouseClick( QgsPoint & point, Qt::MouseButton button )
351
384
{
352
385
  double thresh = e->threshold();
353
 
  
354
 
  switch ( button ) {
 
386
 
 
387
  switch ( button )
 
388
  {
355
389
    case Qt::LeftButton:
356
 
          // Add vertex to previously selected line
357
 
      if ( e->mSelectedLine > 0 ) {
 
390
      // Add vertex to previously selected line
 
391
      if ( e->mSelectedLine > 0 )
 
392
      {
358
393
        e->eraseDynamic();
359
 
        e->eraseElement ( e->mSelectedLine );
360
 
 
361
 
            // Move vertex
362
 
        int type = e->mProvider->readLine ( e->mPoints, e->mCats, e->mSelectedLine );
363
 
 
364
 
        if ( e->mAddVertexEnd && e->mSelectedPart == e->mEditPoints->n_points-1 ) {
365
 
          e->snap ( point ); 
366
 
          Vect_append_point ( e->mPoints, point.x(), point.y(), 0.0 );
367
 
        } else {
368
 
          Vect_line_insert_point ( e->mPoints, e->mSelectedPart, point.x(), point.y(), 0.0 );
369
 
        }
370
 
 
371
 
        Vect_line_prune ( e->mPoints );
372
 
        e->mProvider->rewriteLine ( e->mSelectedLine, type, e->mPoints, e->mCats );
 
394
        e->eraseElement( e->mSelectedLine );
 
395
 
 
396
        // Move vertex
 
397
        int type = e->mProvider->readLine( e->mPoints, e->mCats, e->mSelectedLine );
 
398
 
 
399
        if ( e->mAddVertexEnd && e->mSelectedPart == e->mEditPoints->n_points - 1 )
 
400
        {
 
401
          e->snap( point );
 
402
          Vect_append_point( e->mPoints, point.x(), point.y(), 0.0 );
 
403
        }
 
404
        else
 
405
        {
 
406
          Vect_line_insert_point( e->mPoints, e->mSelectedPart, point.x(), point.y(), 0.0 );
 
407
        }
 
408
 
 
409
        Vect_line_prune( e->mPoints );
 
410
        e->mProvider->rewriteLine( e->mSelectedLine, type, e->mPoints, e->mCats );
373
411
        e->updateSymb();
374
412
        e->displayUpdated();
375
413
 
376
414
        e->mSelectedLine = 0;
377
 
        Vect_reset_line ( e->mEditPoints );
378
 
 
379
 
        e->setCanvasPropmt( QObject::tr("Select line segment"), "", "" );
380
 
      } else {
381
 
            // Select new line
382
 
        e->mSelectedLine = e->mProvider->findLine ( point.x(), point.y(), GV_LINES, thresh );
383
 
 
384
 
        if ( e->mSelectedLine ) { // highlite
385
 
          e->mProvider->readLine ( e->mEditPoints, NULL, e->mSelectedLine );
386
 
          e->displayElement ( e->mSelectedLine, e->mSymb[QgsGrassEdit::SYMB_HIGHLIGHT], e->mSize );
 
415
        Vect_reset_line( e->mEditPoints );
 
416
 
 
417
        e->setCanvasPrompt( tr( "Select line segment" ), "", "" );
 
418
      }
 
419
      else
 
420
      {
 
421
        // Select new line
 
422
        e->mSelectedLine = e->mProvider->findLine( point.x(), point.y(), GV_LINES, thresh );
 
423
 
 
424
        if ( e->mSelectedLine )   // highlite
 
425
        {
 
426
          e->mProvider->readLine( e->mEditPoints, NULL, e->mSelectedLine );
 
427
          e->displayElement( e->mSelectedLine, e->mSymb[QgsGrassEdit::SYMB_HIGHLIGHT], e->mSize );
387
428
 
388
429
          double xl, yl; // nearest point on the line
389
430
 
390
 
              // Note first segment is 1!
391
 
          e->mSelectedPart = Vect_line_distance ( e->mEditPoints, point.x(), point.y(), 0.0, 0, 
392
 
                                               &xl, &yl, NULL, NULL, NULL, NULL );
393
 
 
394
 
          double dist1 = Vect_points_distance ( xl, yl, 0.0, e->mEditPoints->x[e->mSelectedPart-1], 
395
 
              e->mEditPoints->y[e->mSelectedPart-1], 0.0, 0);
396
 
          double dist2 = Vect_points_distance ( xl, yl, 0.0, e->mEditPoints->x[e->mSelectedPart], 
397
 
              e->mEditPoints->y[e->mSelectedPart], 0.0, 0);
398
 
 
399
 
          double maxdist = (dist1 + dist2)/4;
400
 
 
401
 
          if ( e->mSelectedPart == 1 && dist1 < maxdist ) {
 
431
          // Note first segment is 1!
 
432
          e->mSelectedPart = Vect_line_distance( e->mEditPoints, point.x(), point.y(), 0.0, 0,
 
433
                                                 &xl, &yl, NULL, NULL, NULL, NULL );
 
434
 
 
435
          double dist1 = Vect_points_distance( xl, yl, 0.0, e->mEditPoints->x[e->mSelectedPart-1],
 
436
                                               e->mEditPoints->y[e->mSelectedPart-1], 0.0, 0 );
 
437
          double dist2 = Vect_points_distance( xl, yl, 0.0, e->mEditPoints->x[e->mSelectedPart],
 
438
                                               e->mEditPoints->y[e->mSelectedPart], 0.0, 0 );
 
439
 
 
440
          double maxdist = ( dist1 + dist2 ) / 4;
 
441
 
 
442
          if ( e->mSelectedPart == 1 && dist1 < maxdist )
 
443
          {
402
444
            e->mSelectedPart = 0;
403
445
            e->mAddVertexEnd = true;
404
 
          } else if ( e->mSelectedPart == e->mEditPoints->n_points-1 && dist2 < maxdist ) {
 
446
          }
 
447
          else if ( e->mSelectedPart == e->mEditPoints->n_points - 1 && dist2 < maxdist )
 
448
          {
405
449
            e->mAddVertexEnd = true;
406
 
          } else {
 
450
          }
 
451
          else
 
452
          {
407
453
            e->mAddVertexEnd = false;
408
454
          }
409
455
 
410
 
          e->setCanvasPropmt( QObject::tr("New vertex position"), "", QObject::tr("Release") );
411
 
        } else {
412
 
          e->setCanvasPropmt( QObject::tr("Select line segment"), "", "" );
 
456
          e->setCanvasPrompt( tr( "New vertex position" ), "", tr( "Release" ) );
 
457
        }
 
458
        else
 
459
        {
 
460
          e->setCanvasPrompt( tr( "Select line segment" ), "", "" );
413
461
        }
414
462
      }
415
463
      break;
416
464
 
417
465
    case Qt::RightButton:
418
466
      e->eraseDynamic();
419
 
      e->displayElement ( e->mSelectedLine, e->mSymb[e->mLineSymb[e->mSelectedLine]], e->mSize );
 
467
      e->displayElement( e->mSelectedLine, e->mSymb[e->mLineSymb[e->mSelectedLine]], e->mSize );
420
468
      e->mSelectedLine = 0;
421
 
      Vect_reset_line ( e->mEditPoints );
 
469
      Vect_reset_line( e->mEditPoints );
422
470
 
423
 
      e->setCanvasPropmt( QObject::tr("Select line segment"), "", "" );
 
471
      e->setCanvasPrompt( tr( "Select line segment" ), "", "" );
424
472
      break;
425
473
 
426
 
    case Qt::MidButton:
 
474
    default:
 
475
      // ignore others
427
476
      break;
428
477
  }
429
478
 
430
479
}
431
480
 
432
 
void QgsGrassEditAddVertex::mouseMove(QgsPoint & newPoint)
 
481
void QgsGrassEditAddVertex::mouseMove( QgsPoint & newPoint )
433
482
{
434
 
  if ( e->mSelectedLine > 0 ) {
435
 
    Vect_reset_line ( e->mPoints );
436
 
    if ( e->mAddVertexEnd ) {
437
 
      Vect_append_point ( e->mPoints, e->mEditPoints->x[e->mSelectedPart], 
438
 
                          e->mEditPoints->y[e->mSelectedPart], 0.0 );
439
 
      Vect_append_point ( e->mPoints, newPoint.x(), newPoint.y(), 0.0 );
440
 
    } else {
441
 
      Vect_append_point ( e->mPoints, e->mEditPoints->x[e->mSelectedPart-1], 
442
 
                          e->mEditPoints->y[e->mSelectedPart-1], 0.0 );
443
 
      Vect_append_point ( e->mPoints, newPoint.x(), newPoint.y(), 0.0 );
444
 
      Vect_append_point ( e->mPoints, e->mEditPoints->x[e->mSelectedPart], 
445
 
                          e->mEditPoints->y[e->mSelectedPart], 0.0 );
446
 
    }
447
 
    for (int i = 0; i < e->mPoints->n_points; i++ ) {
448
 
      std::cerr << e->mPoints->x[i] << " " << e->mPoints->y[i] << std::endl;
 
483
  if ( e->mSelectedLine > 0 )
 
484
  {
 
485
    Vect_reset_line( e->mPoints );
 
486
    if ( e->mAddVertexEnd )
 
487
    {
 
488
      Vect_append_point( e->mPoints, e->mEditPoints->x[e->mSelectedPart],
 
489
                         e->mEditPoints->y[e->mSelectedPart], 0.0 );
 
490
      Vect_append_point( e->mPoints, newPoint.x(), newPoint.y(), 0.0 );
 
491
    }
 
492
    else
 
493
    {
 
494
      Vect_append_point( e->mPoints, e->mEditPoints->x[e->mSelectedPart-1],
 
495
                         e->mEditPoints->y[e->mSelectedPart-1], 0.0 );
 
496
      Vect_append_point( e->mPoints, newPoint.x(), newPoint.y(), 0.0 );
 
497
      Vect_append_point( e->mPoints, e->mEditPoints->x[e->mSelectedPart],
 
498
                         e->mEditPoints->y[e->mSelectedPart], 0.0 );
 
499
    }
 
500
    for ( int i = 0; i < e->mPoints->n_points; i++ )
 
501
    {
 
502
      QgsDebugMsg( QString( "%1 %2" ).arg( e->mPoints->x[i] ).arg( e->mPoints->y[i] ) );
449
503
    }
450
504
 
451
 
    e->displayDynamic ( e->mPoints );
 
505
    e->displayDynamic( e->mPoints );
452
506
  }
453
507
}
454
508
 
456
510
// DELETE VERTEX
457
511
// ------------------------------------------------------------------
458
512
 
459
 
QgsGrassEditDeleteVertex::QgsGrassEditDeleteVertex(QgsGrassEdit* edit)
460
 
  : QgsGrassEditTool(edit)
 
513
QgsGrassEditDeleteVertex::QgsGrassEditDeleteVertex( QgsGrassEdit* edit )
 
514
    : QgsGrassEditTool( edit )
461
515
{
462
 
  e->setCanvasPropmt( QObject::tr("Select vertex"), "", "" );
 
516
  e->setCanvasPrompt( tr( "Select vertex" ), "", "" );
463
517
}
464
 
    
465
 
void QgsGrassEditDeleteVertex::mouseClick(QgsPoint & point, Qt::ButtonState button)
 
518
 
 
519
void QgsGrassEditDeleteVertex::mouseClick( QgsPoint & point, Qt::MouseButton button )
466
520
{
467
521
  double thresh = e->threshold();
468
 
  
469
 
  switch ( button ) {
 
522
 
 
523
  switch ( button )
 
524
  {
470
525
    case Qt::LeftButton:
471
 
      // Delete previously selected vertex 
472
 
      if ( e->mSelectedLine > 0 ) {
 
526
      // Delete previously selected vertex
 
527
      if ( e->mSelectedLine > 0 )
 
528
      {
473
529
        e->eraseDynamic();
474
 
        e->eraseElement ( e->mSelectedLine );
 
530
        e->eraseElement( e->mSelectedLine );
475
531
 
476
532
        // Move vertex
477
 
        int type = e->mProvider->readLine ( e->mPoints, e->mCats, e->mSelectedLine );
478
 
        Vect_line_delete_point ( e->mPoints, e->mSelectedPart );
 
533
        int type = e->mProvider->readLine( e->mPoints, e->mCats, e->mSelectedLine );
 
534
        Vect_line_delete_point( e->mPoints, e->mSelectedPart );
479
535
 
480
536
        if ( e->mPoints->n_points < 2 ) // delete line
481
537
        {
482
 
            e->mProvider->deleteLine ( e->mSelectedLine );
 
538
          e->mProvider->deleteLine( e->mSelectedLine );
483
539
 
484
 
            // Check orphan records
485
 
            for ( int i = 0 ; i < e->mCats->n_cats; i++ ) {
486
 
              e->checkOrphan ( e->mCats->field[i], e->mCats->cat[i] );
487
 
            }
 
540
          // Check orphan records
 
541
          for ( int i = 0 ; i < e->mCats->n_cats; i++ )
 
542
          {
 
543
            e->checkOrphan( e->mCats->field[i], e->mCats->cat[i] );
 
544
          }
488
545
        }
489
 
        else 
 
546
        else
490
547
        {
491
 
            e->mProvider->rewriteLine ( e->mSelectedLine, type, e->mPoints, e->mCats );
 
548
          e->mProvider->rewriteLine( e->mSelectedLine, type, e->mPoints, e->mCats );
492
549
        }
493
550
 
494
551
        e->updateSymb();
495
552
        e->displayUpdated();
496
553
 
497
554
        e->mSelectedLine = 0;
498
 
        Vect_reset_line ( e->mEditPoints );
 
555
        Vect_reset_line( e->mEditPoints );
499
556
 
500
 
        e->setCanvasPropmt( QObject::tr("Select vertex"), "", "" );
501
 
      } else {
 
557
        e->setCanvasPrompt( tr( "Select vertex" ), "", "" );
 
558
      }
 
559
      else
 
560
      {
502
561
        // Select new/next line
503
 
        e->mSelectedLine = e->mProvider->findLine ( point.x(), point.y(), GV_LINES, thresh );
504
 
 
505
 
        if ( e->mSelectedLine ) { // highlite
506
 
          e->mProvider->readLine ( e->mEditPoints, NULL, e->mSelectedLine );
507
 
 
508
 
          e->displayElement ( e->mSelectedLine, e->mSymb[QgsGrassEdit::SYMB_HIGHLIGHT], e->mSize );
 
562
        e->mSelectedLine = e->mProvider->findLine( point.x(), point.y(), GV_LINES, thresh );
 
563
 
 
564
        if ( e->mSelectedLine )   // highlite
 
565
        {
 
566
          e->mProvider->readLine( e->mEditPoints, NULL, e->mSelectedLine );
 
567
 
 
568
          e->displayElement( e->mSelectedLine, e->mSymb[QgsGrassEdit::SYMB_HIGHLIGHT], e->mSize );
509
569
 
510
570
          double xl, yl; // nearest point on the line
511
571
 
512
572
          // Note first segment is 1!
513
 
          e->mSelectedPart = Vect_line_distance ( e->mEditPoints, point.x(), point.y(), 0.0, 0, 
514
 
                                               &xl, &yl, NULL, NULL, NULL, NULL );
 
573
          e->mSelectedPart = Vect_line_distance( e->mEditPoints, point.x(), point.y(), 0.0, 0,
 
574
                                                 &xl, &yl, NULL, NULL, NULL, NULL );
515
575
 
516
 
          double dist1 = Vect_points_distance ( xl, yl, 0.0, e->mEditPoints->x[e->mSelectedPart-1], 
517
 
              e->mEditPoints->y[e->mSelectedPart-1], 0.0, 0);
518
 
          double dist2 = Vect_points_distance ( xl, yl, 0.0, e->mEditPoints->x[e->mSelectedPart], 
519
 
              e->mEditPoints->y[e->mSelectedPart], 0.0, 0);
 
576
          double dist1 = Vect_points_distance( xl, yl, 0.0, e->mEditPoints->x[e->mSelectedPart-1],
 
577
                                               e->mEditPoints->y[e->mSelectedPart-1], 0.0, 0 );
 
578
          double dist2 = Vect_points_distance( xl, yl, 0.0, e->mEditPoints->x[e->mSelectedPart],
 
579
                                               e->mEditPoints->y[e->mSelectedPart], 0.0, 0 );
520
580
 
521
581
          if ( dist1 < dist2 ) e->mSelectedPart--;
522
582
 
523
 
          e->displayDynamic ( e->mEditPoints->x[e->mSelectedPart], e->mEditPoints->y[e->mSelectedPart], 
524
 
                              QgsVertexMarker::ICON_BOX, e->mSize );
 
583
          e->displayDynamic( e->mEditPoints->x[e->mSelectedPart], e->mEditPoints->y[e->mSelectedPart],
 
584
                             QgsVertexMarker::ICON_BOX, e->mSize );
525
585
 
526
 
          e->setCanvasPropmt( QObject::tr("Delete vertex"), "", QObject::tr("Release vertex") );
527
 
        } else {
528
 
          e->setCanvasPropmt( QObject::tr("Select vertex"), "", "" );
 
586
          e->setCanvasPrompt( tr( "Delete vertex" ), "", tr( "Release vertex" ) );
 
587
        }
 
588
        else
 
589
        {
 
590
          e->setCanvasPrompt( tr( "Select vertex" ), "", "" );
529
591
        }
530
592
      }
531
593
      break;
532
594
 
533
595
    case Qt::RightButton:
534
596
      e->eraseDynamic();
535
 
      e->displayElement ( e->mSelectedLine, e->mSymb[e->mLineSymb[e->mSelectedLine]], e->mSize );
 
597
      e->displayElement( e->mSelectedLine, e->mSymb[e->mLineSymb[e->mSelectedLine]], e->mSize );
536
598
      e->mSelectedLine = 0;
537
 
      Vect_reset_line ( e->mEditPoints );
 
599
      Vect_reset_line( e->mEditPoints );
538
600
 
539
 
      e->setCanvasPropmt( QObject::tr("Select vertex"), "", "" );
 
601
      e->setCanvasPrompt( tr( "Select vertex" ), "", "" );
540
602
      break;
541
603
 
542
 
    case Qt::MidButton:
 
604
    default:
 
605
      // ignore others
543
606
      break;
544
607
  }
545
608
}
548
611
// MOVE LINE
549
612
// ------------------------------------------------------------------
550
613
 
551
 
QgsGrassEditMoveLine::QgsGrassEditMoveLine(QgsGrassEdit* edit)
552
 
  : QgsGrassEditTool(edit)
 
614
QgsGrassEditMoveLine::QgsGrassEditMoveLine( QgsGrassEdit* edit )
 
615
    : QgsGrassEditTool( edit )
553
616
{
554
 
  e->setCanvasPropmt( QObject::tr("Select element"), "", "" );
 
617
  e->setCanvasPrompt( tr( "Select element" ), "", "" );
555
618
}
556
 
    
557
 
void QgsGrassEditMoveLine::mouseClick(QgsPoint & point, Qt::ButtonState button)
 
619
 
 
620
void QgsGrassEditMoveLine::mouseClick( QgsPoint & point, Qt::MouseButton button )
558
621
{
559
622
  double thresh = e->threshold();
560
 
  
561
 
  switch ( button ) {
 
623
 
 
624
  switch ( button )
 
625
  {
562
626
    case Qt::LeftButton:
563
 
      // Move previously selected line 
564
 
      if ( e->mSelectedLine > 0 ) {
 
627
      // Move previously selected line
 
628
      if ( e->mSelectedLine > 0 )
 
629
      {
565
630
        e->eraseDynamic();
566
 
        e->eraseElement ( e->mSelectedLine );
 
631
        e->eraseElement( e->mSelectedLine );
567
632
 
568
633
        // Transform coordinates
569
 
        int type = e->mProvider->readLine ( e->mPoints, e->mCats, e->mSelectedLine );
570
 
        for ( int i = 0; i < e->mPoints->n_points; i++ ) {
571
 
          e->mPoints->x[i] += point.x() - e->mLastPoint.x(); 
572
 
          e->mPoints->y[i] += point.y() - e->mLastPoint.y(); 
 
634
        int type = e->mProvider->readLine( e->mPoints, e->mCats, e->mSelectedLine );
 
635
        for ( int i = 0; i < e->mPoints->n_points; i++ )
 
636
        {
 
637
          e->mPoints->x[i] += point.x() - e->mLastPoint.x();
 
638
          e->mPoints->y[i] += point.y() - e->mLastPoint.y();
573
639
        }
574
640
 
575
 
        e->mProvider->rewriteLine ( e->mSelectedLine, type, e->mPoints, e->mCats );
 
641
        e->mProvider->rewriteLine( e->mSelectedLine, type, e->mPoints, e->mCats );
576
642
        e->updateSymb();
577
643
        e->displayUpdated();
578
644
 
579
645
        e->mSelectedLine = 0;
580
 
        Vect_reset_line ( e->mEditPoints );
 
646
        Vect_reset_line( e->mEditPoints );
581
647
 
582
 
        e->setCanvasPropmt( QObject::tr("Select element"), "", "" );
583
 
      } else {
 
648
        e->setCanvasPrompt( tr( "Select element" ), "", "" );
 
649
      }
 
650
      else
 
651
      {
584
652
        // Select new/next line
585
 
        e->mSelectedLine = e->mProvider->findLine ( point.x(), point.y(), GV_POINT|GV_CENTROID, thresh );
586
 
 
587
 
        if ( e->mSelectedLine == 0 ) 
588
 
          e->mSelectedLine = e->mProvider->findLine ( point.x(), point.y(), GV_LINE|GV_BOUNDARY, thresh );
589
 
 
590
 
        if ( e->mSelectedLine ) { // highlite
591
 
          e->mProvider->readLine ( e->mEditPoints, NULL, e->mSelectedLine );
592
 
          e->displayElement ( e->mSelectedLine, e->mSymb[QgsGrassEdit::SYMB_HIGHLIGHT], e->mSize );
593
 
          e->setCanvasPropmt( QObject::tr("New location"), "", QObject::tr("Release selected") );
594
 
        } else { 
595
 
          e->setCanvasPropmt( QObject::tr("Select element"), "", "" );
 
653
        e->mSelectedLine = e->mProvider->findLine( point.x(), point.y(), GV_POINT | GV_CENTROID, thresh );
 
654
 
 
655
        if ( e->mSelectedLine == 0 )
 
656
          e->mSelectedLine = e->mProvider->findLine( point.x(), point.y(), GV_LINE | GV_BOUNDARY, thresh );
 
657
 
 
658
        if ( e->mSelectedLine )   // highlite
 
659
        {
 
660
          e->mProvider->readLine( e->mEditPoints, NULL, e->mSelectedLine );
 
661
          e->displayElement( e->mSelectedLine, e->mSymb[QgsGrassEdit::SYMB_HIGHLIGHT], e->mSize );
 
662
          e->setCanvasPrompt( tr( "New location" ), "", tr( "Release selected" ) );
 
663
        }
 
664
        else
 
665
        {
 
666
          e->setCanvasPrompt( tr( "Select element" ), "", "" );
596
667
        }
597
668
      }
598
669
      break;
599
670
 
600
671
    case Qt::RightButton:
601
672
      e->eraseDynamic();
602
 
      e->displayElement ( e->mSelectedLine, e->mSymb[e->mLineSymb[e->mSelectedLine]], e->mSize );
 
673
      e->displayElement( e->mSelectedLine, e->mSymb[e->mLineSymb[e->mSelectedLine]], e->mSize );
603
674
      e->mSelectedLine = 0;
604
 
      e->setCanvasPropmt( QObject::tr("Select element"), "", "" );
 
675
      e->setCanvasPrompt( tr( "Select element" ), "", "" );
605
676
      break;
606
677
 
607
 
    case Qt::MidButton:
 
678
    default:
 
679
      // ignore others
608
680
      break;
609
681
  }
610
682
}
611
683
 
612
 
void QgsGrassEditMoveLine::mouseMove(QgsPoint & newPoint)
 
684
void QgsGrassEditMoveLine::mouseMove( QgsPoint & newPoint )
613
685
{
614
 
  // Move previously selected line 
615
 
  if ( e->mSelectedLine > 0 ) {
 
686
  // Move previously selected line
 
687
  if ( e->mSelectedLine > 0 )
 
688
  {
616
689
    // Transform coordinates
617
 
    Vect_reset_line ( e->mPoints );
618
 
    Vect_append_points ( e->mPoints, e->mEditPoints, GV_FORWARD );
 
690
    Vect_reset_line( e->mPoints );
 
691
    Vect_append_points( e->mPoints, e->mEditPoints, GV_FORWARD );
619
692
 
620
 
    for ( int i = 0; i < e->mPoints->n_points; i++ ) {
621
 
      e->mPoints->x[i] += newPoint.x() - e->mLastPoint.x(); 
622
 
      e->mPoints->y[i] += newPoint.y() - e->mLastPoint.y(); 
 
693
    for ( int i = 0; i < e->mPoints->n_points; i++ )
 
694
    {
 
695
      e->mPoints->x[i] += newPoint.x() - e->mLastPoint.x();
 
696
      e->mPoints->y[i] += newPoint.y() - e->mLastPoint.y();
623
697
    }
624
698
 
625
 
    e->displayDynamic ( e->mPoints );
 
699
    e->displayDynamic( e->mPoints );
626
700
  }
627
701
}
628
702
 
631
705
// DELETE LINE
632
706
// ------------------------------------------------------------------
633
707
 
634
 
QgsGrassEditDeleteLine::QgsGrassEditDeleteLine(QgsGrassEdit* edit)
635
 
  : QgsGrassEditTool(edit)
 
708
QgsGrassEditDeleteLine::QgsGrassEditDeleteLine( QgsGrassEdit* edit )
 
709
    : QgsGrassEditTool( edit )
636
710
{
637
 
  e->setCanvasPropmt( QObject::tr("Select element"), "", "" );
 
711
  e->setCanvasPrompt( tr( "Select element" ), "", "" );
638
712
}
639
 
    
640
 
void QgsGrassEditDeleteLine::mouseClick(QgsPoint & point, Qt::ButtonState button)
 
713
 
 
714
void QgsGrassEditDeleteLine::mouseClick( QgsPoint & point, Qt::MouseButton button )
641
715
{
642
716
  double thresh = e->threshold();
643
 
  
644
 
  switch ( button ) {
 
717
 
 
718
  switch ( button )
 
719
  {
645
720
    case Qt::LeftButton:
646
 
      // Delete previously selected line 
647
 
      if ( e->mSelectedLine > 0 ) {
648
 
        e->eraseElement ( e->mSelectedLine );
649
 
        e->mProvider->readLine ( NULL, e->mCats, e->mSelectedLine );
650
 
        e->mProvider->deleteLine ( e->mSelectedLine );
 
721
      // Delete previously selected line
 
722
      if ( e->mSelectedLine > 0 )
 
723
      {
 
724
        e->eraseElement( e->mSelectedLine );
 
725
        e->mProvider->readLine( NULL, e->mCats, e->mSelectedLine );
 
726
        e->mProvider->deleteLine( e->mSelectedLine );
651
727
 
652
728
        // Check orphan records
653
 
        for ( int i = 0 ; i < e->mCats->n_cats; i++ ) {
654
 
          e->checkOrphan ( e->mCats->field[i], e->mCats->cat[i] );
 
729
        for ( int i = 0 ; i < e->mCats->n_cats; i++ )
 
730
        {
 
731
          e->checkOrphan( e->mCats->field[i], e->mCats->cat[i] );
655
732
        }
656
733
 
657
734
        e->updateSymb();
659
736
      }
660
737
 
661
738
      // Select new/next line
662
 
      e->mSelectedLine = e->mProvider->findLine ( point.x(), point.y(), GV_POINT|GV_CENTROID, thresh );
663
 
 
664
 
      if ( e->mSelectedLine == 0 ) 
665
 
        e->mSelectedLine = e->mProvider->findLine ( point.x(), point.y(), GV_LINE|GV_BOUNDARY, thresh );
666
 
      
667
 
      if ( e->mSelectedLine ) { // highlite, propmt
668
 
        e->displayElement ( e->mSelectedLine, e->mSymb[QgsGrassEdit::SYMB_HIGHLIGHT], e->mSize );
669
 
        e->setCanvasPropmt( QObject::tr("Delete selected / select next"), "", QObject::tr("Release selected") );
670
 
      } else {
671
 
        e->setCanvasPropmt( QObject::tr("Select element"), "", "" );
 
739
      e->mSelectedLine = e->mProvider->findLine( point.x(), point.y(), GV_POINT | GV_CENTROID, thresh );
 
740
 
 
741
      if ( e->mSelectedLine == 0 )
 
742
        e->mSelectedLine = e->mProvider->findLine( point.x(), point.y(), GV_LINE | GV_BOUNDARY, thresh );
 
743
 
 
744
      if ( e->mSelectedLine )   // highlite, propmt
 
745
      {
 
746
        e->displayElement( e->mSelectedLine, e->mSymb[QgsGrassEdit::SYMB_HIGHLIGHT], e->mSize );
 
747
        e->setCanvasPrompt( tr( "Delete selected / select next" ), "", tr( "Release selected" ) );
 
748
      }
 
749
      else
 
750
      {
 
751
        e->setCanvasPrompt( tr( "Select element" ), "", "" );
672
752
      }
673
753
      break;
674
754
 
675
755
    case Qt::RightButton:
676
 
      e->displayElement ( e->mSelectedLine, e->mSymb[e->mLineSymb[e->mSelectedLine]], e->mSize );
 
756
      e->displayElement( e->mSelectedLine, e->mSymb[e->mLineSymb[e->mSelectedLine]], e->mSize );
677
757
      e->mSelectedLine = 0;
678
 
      e->setCanvasPropmt( QObject::tr("Select element"), "", "" );
 
758
      e->setCanvasPrompt( tr( "Select element" ), "", "" );
679
759
      break;
680
760
 
681
 
    case Qt::MidButton:
 
761
    default:
 
762
      // ignore others
682
763
      break;
683
764
  }
684
765
}
687
768
// SPLIT LINE
688
769
// ------------------------------------------------------------------
689
770
 
690
 
QgsGrassEditSplitLine::QgsGrassEditSplitLine(QgsGrassEdit* edit)
691
 
  : QgsGrassEditTool(edit)
 
771
QgsGrassEditSplitLine::QgsGrassEditSplitLine( QgsGrassEdit* edit )
 
772
    : QgsGrassEditTool( edit )
692
773
{
693
 
  e->setCanvasPropmt( QObject::tr("Select position on line"), "", "" );
 
774
  e->setCanvasPrompt( tr( "Select position on line" ), "", "" );
694
775
}
695
 
    
696
 
void QgsGrassEditSplitLine::mouseClick(QgsPoint & point, Qt::ButtonState button)
 
776
 
 
777
void QgsGrassEditSplitLine::mouseClick( QgsPoint & point, Qt::MouseButton button )
697
778
{
698
779
  double thresh = e->threshold();
699
 
  
700
 
  switch ( button ) {
 
780
 
 
781
  switch ( button )
 
782
  {
701
783
    case Qt::LeftButton:
702
 
      // Split previously selected line 
703
 
      if ( e->mSelectedLine > 0 ) {
 
784
      // Split previously selected line
 
785
      if ( e->mSelectedLine > 0 )
 
786
      {
704
787
        e->eraseDynamic();
705
 
        e->eraseElement ( e->mSelectedLine );
 
788
        e->eraseElement( e->mSelectedLine );
706
789
 
707
 
        int type = e->mProvider->readLine ( e->mPoints, e->mCats, e->mSelectedLine );
 
790
        int type = e->mProvider->readLine( e->mPoints, e->mCats, e->mSelectedLine );
708
791
 
709
792
        double xl, yl;
710
 
        Vect_line_distance ( e->mPoints, e->mLastPoint.x(), e->mLastPoint.y(), 0.0, 0, 
711
 
                             &xl, &yl, NULL, NULL, NULL, NULL );
 
793
        Vect_line_distance( e->mPoints, e->mLastPoint.x(), e->mLastPoint.y(), 0.0, 0,
 
794
                            &xl, &yl, NULL, NULL, NULL, NULL );
712
795
 
713
796
        e->mPoints->n_points = e->mSelectedPart;
714
 
        Vect_append_point ( e->mPoints, xl, yl, 0.0 );
715
 
        e->mProvider->rewriteLine ( e->mSelectedLine, type, e->mPoints, e->mCats );
 
797
        Vect_append_point( e->mPoints, xl, yl, 0.0 );
 
798
        e->mProvider->rewriteLine( e->mSelectedLine, type, e->mPoints, e->mCats );
716
799
        e->updateSymb();
717
800
        e->displayUpdated();
718
801
 
719
 
        Vect_reset_line ( e->mPoints );
720
 
        Vect_append_point ( e->mPoints, xl, yl, 0.0 );
721
 
        for ( int i = e->mSelectedPart; i < e->mEditPoints->n_points; i++ ) {
722
 
          Vect_append_point ( e->mPoints, e->mEditPoints->x[i], e->mEditPoints->y[i], 0.0 );
 
802
        Vect_reset_line( e->mPoints );
 
803
        Vect_append_point( e->mPoints, xl, yl, 0.0 );
 
804
        for ( int i = e->mSelectedPart; i < e->mEditPoints->n_points; i++ )
 
805
        {
 
806
          Vect_append_point( e->mPoints, e->mEditPoints->x[i], e->mEditPoints->y[i], 0.0 );
723
807
        }
724
808
 
725
 
        e->mProvider->writeLine ( type, e->mPoints, e->mCats );
 
809
        e->mProvider->writeLine( type, e->mPoints, e->mCats );
726
810
 
727
811
        e->updateSymb();
728
812
        e->displayUpdated();
729
813
 
730
814
        e->mSelectedLine = 0;
731
 
        Vect_reset_line ( e->mEditPoints );
732
 
        e->setCanvasPropmt( QObject::tr("Select position on line"), "", "" );
733
 
      } else {
 
815
        Vect_reset_line( e->mEditPoints );
 
816
        e->setCanvasPrompt( tr( "Select position on line" ), "", "" );
 
817
      }
 
818
      else
 
819
      {
734
820
        // Select new/next line
735
 
        e->mSelectedLine = e->mProvider->findLine ( point.x(), point.y(), GV_LINES, thresh );
736
 
 
737
 
        if ( e->mSelectedLine ) { // highlite
738
 
          e->mProvider->readLine ( e->mEditPoints, NULL, e->mSelectedLine );
739
 
 
740
 
          e->displayElement ( e->mSelectedLine, e->mSymb[QgsGrassEdit::SYMB_HIGHLIGHT], e->mSize );
 
821
        e->mSelectedLine = e->mProvider->findLine( point.x(), point.y(), GV_LINES, thresh );
 
822
 
 
823
        if ( e->mSelectedLine )   // highlite
 
824
        {
 
825
          e->mProvider->readLine( e->mEditPoints, NULL, e->mSelectedLine );
 
826
 
 
827
          e->displayElement( e->mSelectedLine, e->mSymb[QgsGrassEdit::SYMB_HIGHLIGHT], e->mSize );
741
828
 
742
829
          double xl, yl; // nearest point on the line
743
830
 
744
 
              // Note first segment is 1!
745
 
          e->mSelectedPart = Vect_line_distance ( e->mEditPoints, point.x(), point.y(), 0.0, 0, 
746
 
                                               &xl, &yl, NULL, NULL, NULL, NULL );
747
 
 
748
 
          e->displayDynamic ( xl, yl, QgsVertexMarker::ICON_X, e->mSize );
749
 
 
750
 
          e->setCanvasPropmt( QObject::tr("Split the line"), "", QObject::tr("Release the line") );
751
 
        } else {
752
 
          e->setCanvasPropmt( QObject::tr("Select point on line"), "", "" );
 
831
          // Note first segment is 1!
 
832
          e->mSelectedPart = Vect_line_distance( e->mEditPoints, point.x(), point.y(), 0.0, 0,
 
833
                                                 &xl, &yl, NULL, NULL, NULL, NULL );
 
834
 
 
835
          e->displayDynamic( xl, yl, QgsVertexMarker::ICON_X, e->mSize );
 
836
 
 
837
          e->setCanvasPrompt( tr( "Split the line" ), "", tr( "Release the line" ) );
 
838
        }
 
839
        else
 
840
        {
 
841
          e->setCanvasPrompt( tr( "Select point on line" ), "", "" );
753
842
        }
754
843
 
755
844
      }
757
846
 
758
847
    case Qt::RightButton:
759
848
      e->eraseDynamic();
760
 
      e->displayElement ( e->mSelectedLine, e->mSymb[e->mLineSymb[e->mSelectedLine]], e->mSize );
 
849
      e->displayElement( e->mSelectedLine, e->mSymb[e->mLineSymb[e->mSelectedLine]], e->mSize );
761
850
      e->mSelectedLine = 0;
762
 
      Vect_reset_line ( e->mEditPoints );
 
851
      Vect_reset_line( e->mEditPoints );
763
852
 
764
 
      e->setCanvasPropmt( QObject::tr("Select point on line"), "", "" );
 
853
      e->setCanvasPrompt( tr( "Select point on line" ), "", "" );
765
854
      break;
766
855
 
767
 
    case Qt::MidButton:
 
856
    default:
 
857
      // ignore others
768
858
      break;
769
859
  }
770
860
}
774
864
// EDIT ATTRIBUTES
775
865
// ------------------------------------------------------------------
776
866
 
777
 
QgsGrassEditAttributes::QgsGrassEditAttributes(QgsGrassEdit* edit)
778
 
  : QgsGrassEditTool(edit)
 
867
QgsGrassEditAttributes::QgsGrassEditAttributes( QgsGrassEdit* edit )
 
868
    : QgsGrassEditTool( edit )
779
869
{
780
 
  e->setCanvasPropmt( QObject::tr("Select element"), "", "" );
 
870
  e->setCanvasPrompt( tr( "Select element" ), "", "" );
781
871
}
782
 
    
783
 
void QgsGrassEditAttributes::mouseClick(QgsPoint & point, Qt::ButtonState button)
 
872
 
 
873
void QgsGrassEditAttributes::mouseClick( QgsPoint & point, Qt::MouseButton button )
784
874
{
785
875
  double thresh = e->threshold();
786
 
  
787
 
  // Redraw previously selected line 
788
 
  if ( e->mSelectedLine > 0 ) {
789
 
    e->displayElement ( e->mSelectedLine, e->mSymb[e->mLineSymb[e->mSelectedLine]], e->mSize );
 
876
 
 
877
  // Redraw previously selected line
 
878
  if ( e->mSelectedLine > 0 )
 
879
  {
 
880
    e->displayElement( e->mSelectedLine, e->mSymb[e->mLineSymb[e->mSelectedLine]], e->mSize );
790
881
  }
791
882
 
792
883
  // Select new/next line
793
 
  e->mSelectedLine = e->mProvider->findLine ( point.x(), point.y(), GV_POINT|GV_CENTROID, thresh );
794
 
 
795
 
  if ( e->mSelectedLine == 0 ) 
796
 
    e->mSelectedLine = e->mProvider->findLine ( point.x(), point.y(), GV_LINE|GV_BOUNDARY, thresh );
797
 
 
798
 
#ifdef QGISDEBUG
799
 
      std::cerr << "mSelectedLine = " << e->mSelectedLine << std::endl;
800
 
#endif
801
 
 
802
 
  if ( e->mAttributes ) 
 
884
  e->mSelectedLine = e->mProvider->findLine( point.x(), point.y(), GV_POINT | GV_CENTROID, thresh );
 
885
 
 
886
  if ( e->mSelectedLine == 0 )
 
887
    e->mSelectedLine = e->mProvider->findLine( point.x(), point.y(), GV_LINE | GV_BOUNDARY, thresh );
 
888
 
 
889
  QgsDebugMsg( QString( "mSelectedLine = %1" ).arg( e->mSelectedLine ) );
 
890
 
 
891
  if ( e->mAttributes )
803
892
  {
804
 
      e->mAttributes->setLine ( 0 );
805
 
      e->mAttributes->clear();
806
 
      e->mAttributes->raise();
 
893
    e->mAttributes->setLine( 0 );
 
894
    e->mAttributes->clear();
 
895
    e->mAttributes->raise();
807
896
  }
808
897
 
809
 
  if ( e->mSelectedLine ) { // highlite
810
 
    e->displayElement ( e->mSelectedLine, e->mSymb[QgsGrassEdit::SYMB_HIGHLIGHT], e->mSize );
811
 
 
812
 
    e->mProvider->readLine ( NULL, e->mCats, e->mSelectedLine );
813
 
 
814
 
    if ( !e->mAttributes ) 
 
898
  if ( e->mSelectedLine )   // highlite
 
899
  {
 
900
    e->displayElement( e->mSelectedLine, e->mSymb[QgsGrassEdit::SYMB_HIGHLIGHT], e->mSize );
 
901
 
 
902
    e->mProvider->readLine( NULL, e->mCats, e->mSelectedLine );
 
903
 
 
904
    if ( !e->mAttributes )
815
905
    {
816
 
        e->mAttributes = new QgsGrassAttributes ( e, e->mProvider, e->mSelectedLine, e->mQgisApp );
 
906
      e->mAttributes = new QgsGrassAttributes( e, e->mProvider, e->mSelectedLine, e->mIface->mainWindow() );
817
907
    }
818
908
    else
819
909
    {
820
 
      e->mAttributes->setLine ( e->mSelectedLine );
 
910
      e->mAttributes->setLine( e->mSelectedLine );
821
911
    }
822
 
    for ( int i = 0; i < e->mCats->n_cats; i++ ) {
823
 
      e->addAttributes ( e->mCats->field[i], e->mCats->cat[i] );
 
912
    for ( int i = 0; i < e->mCats->n_cats; i++ )
 
913
    {
 
914
      e->addAttributes( e->mCats->field[i], e->mCats->cat[i] );
824
915
    }
825
916
    e->mAttributes->show();
826
917
    e->mAttributes->raise();
827
918
  }
828
919
 
 
920
  e->mAttributes->setCategoryMode( static_cast<QgsGrassEdit::CatMode>( e->mCatModeBox->currentIndex() ), e->mCatEntry->text() );
829
921
}