Engauge Digitizer  2
DigitizeStateSelect.cpp
1 /******************************************************************************************************
2  * (C) 2014 markummitchell@github.com. This file is part of Engauge Digitizer, which is released *
3  * under GNU General Public License version 2 (GPLv2) or (at your option) any later version. See file *
4  * LICENSE or go to gnu.org/licenses for details. Distribution requires prior written permission. *
5  ******************************************************************************************************/
6 
7 #include "CallbackScaleBar.h"
8 #include "CmdEditPointAxis.h"
9 #include "CmdEditPointGraph.h"
10 #include "CmdMediator.h"
11 #include "CmdMoveBy.h"
12 #include "DataKey.h"
13 #include "DigitizeStateContext.h"
14 #include "DigitizeStateSelect.h"
15 #include "DlgEditPointAxis.h"
16 #include "DlgEditPointGraph.h"
17 #include "DlgEditScale.h"
18 #include "EngaugeAssert.h"
19 #include "GraphicsItemsExtractor.h"
20 #include "GraphicsItemType.h"
21 #include "GraphicsScene.h"
22 #include "GraphicsView.h"
23 #include "Logger.h"
24 #include "MainWindow.h"
25 #include <QCursor>
26 #include <QGraphicsItem>
27 #include <QImage>
28 #include <QMessageBox>
29 #include <QObject>
30 #include <QSize>
31 #include <QtToString.h>
32 #include "Transformation.h"
33 #include "Version.h"
34 
35 const QString MOVE_TEXT_DOWN (QObject::tr ("Move down"));
36 const QString MOVE_TEXT_LEFT (QObject::tr ("Move left"));
37 const QString MOVE_TEXT_RIGHT (QObject::tr ("Move right"));
38 const QString MOVE_TEXT_UP (QObject::tr ("Move up"));
39 
42 {
43 }
44 
45 DigitizeStateSelect::~DigitizeStateSelect ()
46 {
47 }
48 
50 {
52 }
53 
54 void DigitizeStateSelect::addHoverHighlighting()
55 {
56  LOG4CPP_INFO_S ((*mainCat)) << "DigitizeStateSelect::addHoverHighlighting";
57 
58  QList<QGraphicsItem*> items = context().mainWindow().scene().items();
59  QList<QGraphicsItem*>::iterator itr;
60  for (itr = items.begin (); itr != items.end (); itr++) {
61 
62  QGraphicsItem *item = *itr;
63  if (item->data (DATA_KEY_GRAPHICS_ITEM_TYPE) == GRAPHICS_ITEM_TYPE_POINT) {
64  item->setAcceptHoverEvents(true);
65  }
66  }
67 }
68 
70  DigitizeState /* previousState */)
71 {
72  LOG4CPP_INFO_S ((*mainCat)) << "DigitizeStateSelect::begin";
73 
74  setCursor(cmdMediator);
75  context().setDragMode(QGraphicsView::RubberBandDrag);
76 
77  addHoverHighlighting();
79 }
80 
81 bool DigitizeStateSelect::canPaste (const Transformation & /* transformation */,
82  const QSize & /* viewSize */) const
83 {
84  return false;
85 }
86 
87 QCursor DigitizeStateSelect::cursor(CmdMediator * /* cmdMediator */) const
88 {
89  LOG4CPP_DEBUG_S ((*mainCat)) << "DigitizeStateSelect::cursor";
90 
91  return QCursor (Qt::ArrowCursor);
92 }
93 
95 {
96  LOG4CPP_INFO_S ((*mainCat)) << "DigitizeStateSelect::end";
97 
98  removeHoverHighlighting();
99 }
100 
102  const QString &pointIdentifier)
103 {
104  LOG4CPP_INFO_S ((*mainCat)) << "DigitizeStateSelect::handleContextMenuEventAxis "
105  << " point=" << pointIdentifier.toLatin1 ().data ();
106 
107  if (cmdMediator->document().documentAxesPointsRequired() == DOCUMENT_AXES_POINTS_REQUIRED_2) {
108  handleContextMenuEventAxis2 (cmdMediator);
109  } else {
110  handleContextMenuEventAxis34 (cmdMediator,
111  pointIdentifier);
112  }
113 }
114 
115 void DigitizeStateSelect::handleContextMenuEventAxis2 (CmdMediator *cmdMediator)
116 {
117  LOG4CPP_DEBUG_S ((*mainCat)) << "DigitizeStateSelect::handleContextMenuEventAxis2";
118 
119  const bool IS_NOT_X_ONLY = false;
120 
121  // The point identifier we want is not necessarily the one edited but is the one with the
122  // nonzero x or y (but not both) coordinate
123  QString pointIdentifier = scaleBarPointIdentifier (cmdMediator);
124 
125  QPointF posScreen = cmdMediator->document().positionScreen (pointIdentifier);
126  QPointF posGraphBefore = cmdMediator->document().positionGraph (pointIdentifier);
127 
128  // Ask user for scale length
129  double scaleLength = scaleBarLength (cmdMediator);
130  DlgEditScale *dlg = new DlgEditScale (context().mainWindow(),
131  cmdMediator->document().modelCoords(),
132  cmdMediator->document().modelGeneral(),
134  &scaleLength);
135  int rtn = dlg->exec ();
136 
137  scaleLength = dlg->scaleLength (); // This call returns new value for scale length
138  delete dlg;
139 
140  if (rtn == QDialog::Accepted) {
141 
142  // User wants to edit the scale length, which is effectively editing this axis point, but let's perform sanity checks first
143 
144  bool isError;
145  QString errorMessage;
146 
147  bool isXNonzero = (posGraphBefore.x() != 0); // Identify which coordinate is to be edited
148  QPointF posGraphAfter (isXNonzero ? scaleLength : 0,
149  isXNonzero ? 0 : scaleLength);
150  context().mainWindow().cmdMediator()->document().checkEditPointAxis(pointIdentifier,
151  posScreen,
152  posGraphAfter,
153  isError,
154  errorMessage);
155 
156  if (isError) {
157 
158  QMessageBox::warning (0,
159  engaugeWindowTitle(),
160  errorMessage);
161 
162  } else {
163 
164  // Create a command to change the scale length
165  CmdEditPointAxis *cmd = new CmdEditPointAxis (context().mainWindow(),
166  cmdMediator->document(),
167  pointIdentifier,
168  posGraphBefore,
169  posGraphAfter,
170  IS_NOT_X_ONLY);
171  context().appendNewCmd(cmdMediator,
172  cmd);
173  }
174  }
175 }
176 
177 void DigitizeStateSelect::handleContextMenuEventAxis34 (CmdMediator *cmdMediator,
178  const QString &pointIdentifier)
179 {
180  LOG4CPP_DEBUG_S ((*mainCat)) << "DigitizeStateSelect::handleContextMenuEventAxis34";
181 
182  QPointF posScreen = cmdMediator->document().positionScreen (pointIdentifier);
183  QPointF posGraphBefore = cmdMediator->document().positionGraph (pointIdentifier);
184  bool isXOnly = cmdMediator->document().isXOnly (pointIdentifier);
185 
186  // Ask user for coordinates
187  double x = posGraphBefore.x();
188  double y = posGraphBefore.y();
189 
190  DlgEditPointAxis *dlg = new DlgEditPointAxis (context().mainWindow(),
191  cmdMediator->document().modelCoords(),
192  cmdMediator->document().modelGeneral(),
195  cmdMediator->document().documentAxesPointsRequired(),
196  isXOnly,
197  &x,
198  &y);
199  int rtn = dlg->exec ();
200 
201  QPointF posGraphAfter = dlg->posGraph (isXOnly); // This call returns new values for isXOnly and the graph position
202  delete dlg;
203 
204  if (rtn == QDialog::Accepted) {
205 
206  // User wants to edit this axis point, but let's perform sanity checks first
207 
208  bool isError;
209  QString errorMessage;
210 
211  context().mainWindow().cmdMediator()->document().checkEditPointAxis(pointIdentifier,
212  posScreen,
213  posGraphAfter,
214  isError,
215  errorMessage);
216 
217  if (isError) {
218 
219  QMessageBox::warning (0,
220  engaugeWindowTitle(),
221  errorMessage);
222 
223  } else {
224 
225  // Create a command to edit the point
226  CmdEditPointAxis *cmd = new CmdEditPointAxis (context().mainWindow(),
227  cmdMediator->document(),
228  pointIdentifier,
229  posGraphBefore,
230  posGraphAfter,
231  isXOnly);
232  context().appendNewCmd(cmdMediator,
233  cmd);
234  }
235  }
236 }
237 
239  const QStringList &pointIdentifiers)
240 {
241  LOG4CPP_INFO_S ((*mainCat)) << "DigitizeStateSelect::handleContextMenuEventGraph "
242  << "points=" << pointIdentifiers.join(",").toLatin1 ().data ();
243 
244  double *x = 0, *y = 0;
245 
246  if (pointIdentifiers.count() == 1) {
247 
248  // There is exactly one point so pass its coordinates to the dialog
249  x = new double;
250  y = new double;
251 
252  QPointF posScreenBefore = cmdMediator->document().positionScreen (pointIdentifiers.first());
253  QPointF posGraphBefore;
255  posGraphBefore);
256 
257  // Ask user for coordinates
258  *x = posGraphBefore.x();
259  *y = posGraphBefore.y();
260  }
261 
262  DlgEditPointGraph *dlg = new DlgEditPointGraph (context().mainWindow(),
263  cmdMediator->document().modelCoords(),
264  cmdMediator->document().modelGeneral(),
267  x,
268  y);
269  if (x != 0) {
270  delete x;
271  x = 0;
272  }
273 
274  if (y != 0) {
275  delete y;
276  y = 0;
277  }
278 
279  int rtn = dlg->exec ();
280 
281  bool isXGiven, isYGiven;
282  double xGiven, yGiven;
283  dlg->posGraph (isXGiven, xGiven, isYGiven, yGiven); // One or both coordinates are returned
284  delete dlg;
285 
286  if (rtn == QDialog::Accepted) {
287 
288  // Create a command to edit the point
289  CmdEditPointGraph *cmd = new CmdEditPointGraph (context().mainWindow(),
290  cmdMediator->document(),
291  pointIdentifiers,
292  isXGiven,
293  isYGiven,
294  xGiven,
295  yGiven);
296  context().appendNewCmd(cmdMediator,
297  cmd);
298  }
299 }
300 
302 {
303  LOG4CPP_INFO_S ((*mainCat)) << "DigitizeStateSelect::handleCurveChange";
304 }
305 
307  Qt::Key key,
308  bool atLeastOneSelectedItem)
309 {
310  LOG4CPP_INFO_S ((*mainCat)) << "DigitizeStateSelect::handleKeyPress"
311  << " key=" << QKeySequence (key).toString ().toLatin1 ().data ();
312 
313  if (atLeastOneSelectedItem) {
314 
315  if (key == Qt::Key_Down ||
316  key == Qt::Key_Up ||
317  key == Qt::Key_Left ||
318  key == Qt::Key_Right) {
319 
320  keyPressArrow (cmdMediator,
321  key);
322 
323  }
324  }
325 }
326 
328  QPointF /* posScreen */)
329 {
330 // LOG4CPP_DEBUG_S ((*mainCat)) << "DigitizeStateSelect::handleMouseMove";
331 }
332 
334  QPointF posScreen)
335 {
336  LOG4CPP_INFO_S ((*mainCat)) << "DigitizeStateSelect::handleMousePress"
337  << " posScreen=" << QPointFToString (posScreen).toLatin1 ().data ();
338 
339  // Note that GraphicsView has already called GraphicsPointAbstract::resetPositionHasChanged on all items
340 
341  m_movingStart = posScreen;
342 }
343 
345  QPointF posScreen)
346 {
347  LOG4CPP_INFO_S ((*mainCat)) << "DigitizeStateSelect::handleMouseRelease"
348  << " posScreen=" << QPointFToString (posScreen).toLatin1 ().data ();
349 
350  QPointF deltaScreen = posScreen - m_movingStart;
351  QStringList positionHasChangedIdentifers = context().mainWindow().scene().positionHasChangedPointIdentifiers();
352 
353  bool positionHasChanged = (positionHasChangedIdentifers.count () > 0);
354 
355  if (positionHasChanged && (
356  deltaScreen.x () != 0 ||
357  deltaScreen.y () != 0)) {
358 
359  QString moveText = moveTextFromDeltaScreen (deltaScreen);
360 
361  // Create command to move points
362  CmdMoveBy *cmd = new CmdMoveBy (context().mainWindow(),
363  cmdMediator->document(),
364  deltaScreen,
365  moveText,
366  positionHasChangedIdentifers);
367  context().appendNewCmd (cmdMediator,
368  cmd);
369 
370  } else {
371 
372  // Selection probably changed so update the MainWindow controls (especially Cut)
374 
375  }
376 }
377 
378 void DigitizeStateSelect::keyPressArrow (CmdMediator *cmdMediator,
379  Qt::Key key)
380 {
381  QPointF deltaScreen;
382  QString moveText;
383  switch (key) {
384  case Qt::Key_Down:
385  deltaScreen = QPointF (0, zoomedToUnzoomedScreenY ());
386  moveText = MOVE_TEXT_DOWN;
387  break;
388 
389  case Qt::Key_Left:
390  deltaScreen = QPointF (-1 * zoomedToUnzoomedScreenX (), 0);
391  moveText = MOVE_TEXT_LEFT;
392  break;
393 
394  case Qt::Key_Right:
395  deltaScreen = QPointF (zoomedToUnzoomedScreenX (), 0);
396  moveText = MOVE_TEXT_RIGHT;
397  break;
398 
399  case Qt::Key_Up:
400  deltaScreen = QPointF (0, -1 * zoomedToUnzoomedScreenY ());
401  moveText = MOVE_TEXT_UP;
402  break;
403 
404  default:
405  ENGAUGE_ASSERT (false);
406  }
407 
408  // Create command to move points
409  GraphicsItemsExtractor graphicsItemsExtractor;
410  const QList<QGraphicsItem*> &items = context().mainWindow().scene ().selectedItems();
411  CmdMoveBy *cmd = new CmdMoveBy (context().mainWindow(),
412  cmdMediator->document(),
413  deltaScreen,
414  moveText,
415  graphicsItemsExtractor.selectedPointIdentifiers (items));
416  context().appendNewCmd (cmdMediator,
417  cmd);
418 }
419 
420 QString DigitizeStateSelect::moveTextFromDeltaScreen (const QPointF &deltaScreen)
421 {
422  QString moveText;
423 
424  // x UP x -----> +x
425  // x x |
426  // LEFT x RIGHT |
427  // x x v
428  // x DOWN x +y
429  bool downOrRight = (deltaScreen.y () > -1.0 * deltaScreen.x ());
430  bool upOrRight = (deltaScreen.y () < deltaScreen.x ());
431  if (downOrRight && upOrRight) {
432  moveText = MOVE_TEXT_RIGHT;
433  } else if (downOrRight && !upOrRight) {
434  moveText = MOVE_TEXT_DOWN;
435  } else if (!downOrRight && upOrRight) {
436  moveText = MOVE_TEXT_UP;
437  } else {
438  moveText = MOVE_TEXT_LEFT;
439  }
440 
441  return moveText;
442 }
443 
444 void DigitizeStateSelect::removeHoverHighlighting()
445 {
446  LOG4CPP_INFO_S ((*mainCat)) << "DigitizeStateSelect::removeHoverHighlighting";
447 
448  QList<QGraphicsItem*> items = context().mainWindow().scene().items();
449  QList<QGraphicsItem*>::iterator itr;
450  for (itr = items.begin (); itr != items.end (); itr++) {
451 
452  QGraphicsItem *item = *itr;
453  if (item->data (DATA_KEY_GRAPHICS_ITEM_TYPE) == GRAPHICS_ITEM_TYPE_POINT) {
454  item->setAcceptHoverEvents(false);
455  }
456  }
457 }
458 
459 double DigitizeStateSelect::scaleBarLength (CmdMediator *cmdMediator) const
460 {
461  CallbackScaleBar ftor;
462 
463  Functor2wRet<const QString &, const Point&, CallbackSearchReturn> ftorWithCallback = functor_ret (ftor,
465  cmdMediator->iterateThroughCurvePointsAxes (ftorWithCallback);
466 
467  return ftor.scaleBarLength ();
468 }
469 
470 QString DigitizeStateSelect::scaleBarPointIdentifier (CmdMediator *cmdMediator) const
471 {
472  CallbackScaleBar ftor;
473 
474  Functor2wRet<const QString &, const Point&, CallbackSearchReturn> ftorWithCallback = functor_ret (ftor,
476  cmdMediator->iterateThroughCurvePointsAxes (ftorWithCallback);
477 
478  return ftor.scaleBarPointIdentifier();
479 }
480 
481 void DigitizeStateSelect::setHoverHighlighting(const MainWindowModel &modelMainWindow)
482 {
483  LOG4CPP_INFO_S ((*mainCat)) << "DigitizeStateSelect::addHoverHighlighting";
484 
485  // Set the opacity for all points. It should be already set for pre-existing points
486  QList<QGraphicsItem*> items = context().mainWindow().scene().items();
487  QList<QGraphicsItem*>::iterator itr;
488  for (itr = items.begin (); itr != items.end (); itr++) {
489 
490  QGraphicsItem *item = *itr;
491  if (item->data (DATA_KEY_GRAPHICS_ITEM_TYPE) == GRAPHICS_ITEM_TYPE_POINT) {
492  item->setOpacity (modelMainWindow.highlightOpacity());
493  }
494  }
495 }
496 
498 {
499  return "DigitizeStateSelect";
500 }
501 
503 {
504  LOG4CPP_INFO_S ((*mainCat)) << "DigitizeStateSelect::updateAfterPointAddition";
505 
506  addHoverHighlighting ();
507 }
508 
510  const DocumentModelDigitizeCurve & /*modelDigitizeCurve */)
511 {
512  LOG4CPP_INFO_S ((*mainCat)) << "DigitizeStateSelect::updateModelDigitizeCurve";
513 }
514 
516 {
517  LOG4CPP_INFO_S ((*mainCat)) << "DigitizeStateSelect::updateModelSegments";
518 }
519 
520 double DigitizeStateSelect::zoomedToUnzoomedScreenX () const
521 {
522  double m11 = context().mainWindow ().view ().transform().m11 ();
523  return 1.0 / m11;
524 }
525 
526 double DigitizeStateSelect::zoomedToUnzoomedScreenY () const
527 {
528  double m22 = context().mainWindow ().view ().transform().m22 ();
529  return 1.0 / m22;
530 }
Dialog box for editing the information of one axis point, in a graph with two axes.
CallbackSearchReturn callback(const QString &curveName, const Point &point)
Callback method.
Callback for identifying, for the scale bar of a map, various quantities.
virtual void handleKeyPress(CmdMediator *cmdMediator, Qt::Key key, bool atLeastOneSelectedItem)
Handle a key press that was intercepted earlier.
void setDragMode(QGraphicsView::DragMode dragMode)
Set QGraphicsView drag mode (in m_view). Called from DigitizeStateAbstractBase subclasses.
virtual QCursor cursor(CmdMediator *cmdMediator) const
Returns the state-specific cursor shape.
QString scaleBarPointIdentifier() const
Identified axis point.
virtual void updateModelSegments(const DocumentModelSegments &modelSegments)
Update the segments given the new settings.
void updateAfterMouseRelease()
Call MainWindow::updateControls (which is private) after the very specific case - a mouse press/relea...
Dialog box for editing the information of the map scale.
Definition: DlgEditScale.h:22
Command for editing the graph coordinates of one or more graph points.
virtual void handleContextMenuEventAxis(CmdMediator *cmdMediator, const QString &pointIdentifier)
Handle a right click, on an axis point, that was intercepted earlier.
virtual void handleCurveChange(CmdMediator *cmdMediator)
Handle the selection of a new curve. At a minimum, DigitizeStateSegment will generate a new set of Se...
virtual void handleMouseRelease(CmdMediator *cmdMediator, QPointF posScreen)
Handle a mouse release that was intercepted earlier.
void updateViewsOfSettings(const QString &activeCurve)
Update curve-specific view of settings. Private version gets active curve name from DigitizeStateCont...
DocumentModelGeneral modelGeneral() const
Get method for DocumentModelGeneral.
Definition: Document.cpp:717
virtual bool canPaste(const Transformation &transformation, const QSize &viewSize) const
Return true if there is good data in the clipboard for pasting, and that is compatible with the curre...
DocumentAxesPointsRequired documentAxesPointsRequired() const
Get method for DocumentAxesPointsRequired.
Definition: Document.cpp:360
Command for moving all selected Points by a specified translation.
Definition: CmdMoveBy.h:18
virtual void handleContextMenuEventGraph(CmdMediator *cmdMediator, const QStringList &pointIdentifiers)
Handle a right click, on a graph point, that was intercepted earlier.
virtual void handleMousePress(CmdMediator *cmdMediator, QPointF posScreen)
Handle a mouse press that was intercepted earlier.
QStringList positionHasChangedPointIdentifiers() const
Return a list of identifiers for the points that have moved since the last call to resetPositionHasCh...
double highlightOpacity() const
Get method for highlight opacity.
CmdMediator * cmdMediator()
Accessor for commands to process the Document.
Definition: MainWindow.cpp:337
Document & document()
Provide the Document to commands, primarily for undo/redo processing.
Definition: CmdMediator.cpp:72
virtual void updateAfterPointAddition()
Update graphics attributes after possible new points. This is useful for highlight opacity...
DigitizeStateContext & context()
Reference to the DigitizeStateContext that contains all the DigitizeStateAbstractBase subclasses...
virtual QString state() const
State name for debugging.
MainWindow & mainWindow()
Reference to the MainWindow, without const.
void checkEditPointAxis(const QString &pointIdentifier, const QPointF &posScreen, const QPointF &posGraph, bool &isError, QString &errorMessage)
Check before calling editPointAxis.
Definition: Document.cpp:281
Transformation transformation() const
Return read-only copy of transformation.
This class consolidates utility routines that deal with graphics items that are getting extracted fro...
QPointF posGraph(bool &isXOnly) const
Return the graph coordinates position specified by the user. Only applies if dialog was accepted...
double scaleBarLength() const
Length of scale bar.
Model for DlgSettingsDigitizeCurve and CmdSettingsDigitizeCurve.
virtual void begin(CmdMediator *cmdMediator, DigitizeState previousState)
Method that is called at the exact moment a state is entered.
GraphicsView & view()
View for the QImage and QGraphicsItems, without const.
Affine transformation between screen and graph coordinates, based on digitized axis points...
GraphicsScene & scene()
Scene container for the QImage and QGraphicsItems.
void setCursor(CmdMediator *cmdMediator)
Update the cursor according to the current state.
Container for all DigitizeStateAbstractBase subclasses. This functions as the context class in a stan...
Model for DlgSettingsMainWindow.
void appendNewCmd(CmdMediator *cmdMediator, QUndoCommand *cmd)
Append just-created QUndoCommand to command stack. This is called from DigitizeStateAbstractBase subc...
virtual void end()
Method that is called at the exact moment a state is exited. Typically called just before begin for t...
QPointF positionScreen(const QString &pointIdentifier) const
See Curve::positionScreen.
Definition: Document.cpp:821
virtual void handleMouseMove(CmdMediator *cmdMediator, QPointF posScreen)
Handle a mouse move. This is part of an experiment to see if augmenting the cursor in Point Match mod...
QStringList selectedPointIdentifiers(const QList< QGraphicsItem *> &items) const
Return list of selected point identifiers.
DigitizeStateSelect(DigitizeStateContext &context)
Single constructor.
MainWindowModel modelMainWindow() const
Get method for main window model.
void transformScreenToRawGraph(const QPointF &coordScreen, QPointF &coordGraph) const
Transform from cartesian pixel screen coordinates to cartesian/polar graph coordinates.
virtual QString activeCurve() const
Name of the active Curve. This can include AXIS_CURVE_NAME.
Command queue stack.
Definition: CmdMediator.h:23
void posGraph(bool &isX, double &x, bool &isY, double &y) const
Return one or both coordinates. Only applies if dialog was accepted.
Dialog box for editing the information of one or more points.
Model for DlgSettingsSegments and CmdSettingsSegments.
Base class for all digitizing states. This serves as an interface to DigitizeStateContext.
void iterateThroughCurvePointsAxes(const Functor2wRet< const QString &, const Point &, CallbackSearchReturn > &ftorWithCallback)
See Curve::iterateThroughCurvePoints, for the single axes curve.
Definition: CmdMediator.cpp:87
QPointF positionGraph(const QString &pointIdentifier) const
See Curve::positionGraph.
Definition: Document.cpp:816
Command for editing the graph coordinates one axis point.
QString selectedGraphCurve() const
Curve name that is currently selected in m_cmbCurve.
double scaleLength() const
Return the scale bar length specified by the user. Only applies if dialog was accepted.
virtual void updateModelDigitizeCurve(CmdMediator *cmdMediator, const DocumentModelDigitizeCurve &modelDigitizeCurve)
Update the digitize curve settings.
DocumentModelCoords modelCoords() const
Get method for DocumentModelCoords.
Definition: Document.cpp:689
bool isXOnly(const QString &pointIdentifier) const
See Curve::isXOnly.
Definition: Document.cpp:438