Seamly2D
Code documentation
vabstractpattern.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  ** @file vabstractpattern.cpp
3  ** @author Douglas S Caskey
4  ** @date Mar 1, 2023
5  **
6  ** @copyright
7  ** Copyright (C) 2017 - 2023 Seamly, LLC
8  ** https://github.com/fashionfreedom/seamly2d
9  **
10  ** @brief
11  ** Seamly2D is free software: you can redistribute it and/or modify
12  ** it under the terms of the GNU General Public License as published by
13  ** the Free Software Foundation, either version 3 of the License, or
14  ** (at your option) any later version.
15  **
16  ** Seamly2D is distributed in the hope that it will be useful,
17  ** but WITHOUT ANY WARRANTY; without even the implied warranty of
18  ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  ** GNU General Public License for more details.
20  **
21  ** You should have received a copy of the GNU General Public License
22  ** along with Seamly2D. If not, see <http://www.gnu.org/licenses/>.
23  **************************************************************************/
24 
25 /************************************************************************
26  **
27  ** @file vabstractpattern.cpp
28  ** @author Roman Telezhynskyi <dismine(at)gmail.com>
29  ** @date 15 6, 2015
30  **
31  ** @brief
32  ** @copyright
33  ** This source code is part of the Valentina project, a pattern making
34  ** program, whose allow create and modeling patterns of clothing.
35  ** Copyright (C) 2015 Valentina project
36  ** <https://bitbucket.org/dismine/valentina> All Rights Reserved.
37  **
38  ** Valentina is free software: you can redistribute it and/or modify
39  ** it under the terms of the GNU General Public License as published by
40  ** the Free Software Foundation, either version 3 of the License, or
41  ** (at your option) any later version.
42  **
43  ** Valentina is distributed in the hope that it will be useful,
44  ** but WITHOUT ANY WARRANTY; without even the implied warranty of
45  ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
46  ** GNU General Public License for more details.
47  **
48  ** You should have received a copy of the GNU General Public License
49  ** along with Valentina. If not, see <http://www.gnu.org/licenses/>.
50  **
51  *************************************************************************/
52 
53 #include "vabstractpattern.h"
54 
55 #include <QDomNode>
56 #include <QDomNodeList>
57 #include <QLatin1String>
58 #include <QList>
59 #include <QMessageBox>
60 #include <QMessageLogger>
61 #include <QSet>
62 #include <QStaticStringData>
63 #include <QStringData>
64 #include <QStringDataPtr>
65 #include <QtDebug>
66 
67 #include "vdomdocument.h"
68 #include "vpatternconverter.h"
69 #include "vtoolrecord.h"
70 #include "../exception/vexceptionemptyparameter.h"
71 #include "../exception/vexceptionobjecterror.h"
72 #include "../exception/vexceptionconversionerror.h"
73 #include "../ifc/exception/vexceptionbadid.h"
74 #include "../ifc/ifcdef.h"
75 #include "../vmisc/vabstractapplication.h"
76 #include "../vmisc/vcommonsettings.h"
77 #include "../vpatterndb/vcontainer.h"
78 #include "../vpatterndb/vpiecenode.h"
79 #include "../qmuparser/qmutokenparser.h"
80 #include "../vtools/tools/vdatatool.h"
81 
82 class QDomElement;
83 
84 const QString VAbstractPattern::TagPattern = QStringLiteral("pattern");
85 const QString VAbstractPattern::TagCalculation = QStringLiteral("calculation");
86 const QString VAbstractPattern::TagModeling = QStringLiteral("modeling");
87 const QString VAbstractPattern::TagPieces = QStringLiteral("pieces");
88 const QString VAbstractPattern::TagPiece = QStringLiteral("piece");
89 const QString VAbstractPattern::TagDescription = QStringLiteral("description");
90 const QString VAbstractPattern::TagNotes = QStringLiteral("notes");
91 const QString VAbstractPattern::TagImage = QStringLiteral("image");
92 const QString VAbstractPattern::TagMeasurements = QStringLiteral("measurements");
93 const QString VAbstractPattern::TagIncrements = QStringLiteral("increments");
94 const QString VAbstractPattern::TagIncrement = QStringLiteral("increment");
95 const QString VAbstractPattern::TagDraftBlock = QStringLiteral("draftBlock");
96 const QString VAbstractPattern::TagGroups = QStringLiteral("groups");
97 const QString VAbstractPattern::TagGroup = QStringLiteral("group");
98 const QString VAbstractPattern::TagGroupItem = QStringLiteral("item");
99 const QString VAbstractPattern::TagPoint = QStringLiteral("point");
100 const QString VAbstractPattern::TagSpline = QStringLiteral("spline");
101 const QString VAbstractPattern::TagArc = QStringLiteral("arc");
102 const QString VAbstractPattern::TagElArc = QStringLiteral("elArc");
103 const QString VAbstractPattern::TagTools = QStringLiteral("tools");
104 const QString VAbstractPattern::TagOperation = QStringLiteral("operation");
105 const QString VAbstractPattern::TagGradation = QStringLiteral("gradation");
106 const QString VAbstractPattern::TagHeights = QStringLiteral("heights");
107 const QString VAbstractPattern::TagSizes = QStringLiteral("sizes");
108 const QString VAbstractPattern::TagData = QStringLiteral("data");
109 const QString VAbstractPattern::TagPatternInfo = QStringLiteral("patternInfo");
110 const QString VAbstractPattern::TagPatternName = QStringLiteral("patternName");
111 const QString VAbstractPattern::TagPatternNum = QStringLiteral("patternNumber");
112 const QString VAbstractPattern::TagCustomerName = QStringLiteral("customer");
113 const QString VAbstractPattern::TagCompanyName = QStringLiteral("company");
114 const QString VAbstractPattern::TagPatternLabel = QStringLiteral("patternLabel");
115 const QString VAbstractPattern::TagGrainline = QStringLiteral("grainline");
116 const QString VAbstractPattern::TagPath = QStringLiteral("path");
117 const QString VAbstractPattern::TagNodes = QStringLiteral("nodes");
118 const QString VAbstractPattern::TagNode = QStringLiteral("node");
119 const QString VAbstractPattern::TagLine = QStringLiteral("line");
120 
121 const QString VAbstractPattern::AttrName = QStringLiteral("name");
122 const QString VAbstractPattern::AttrVisible = QStringLiteral("visible");
123 const QString VAbstractPattern::AttrGroupLocked = QStringLiteral("locked");
124 const QString VAbstractPattern::AttrGroupColor = QStringLiteral("groupColor");
125 const QString VAbstractPattern::AttrObject = QStringLiteral("object");
126 const QString VAbstractPattern::AttrTool = QStringLiteral("tool");
127 const QString VAbstractPattern::AttrType = QStringLiteral("type");
128 const QString VAbstractPattern::AttrLetter = QStringLiteral("letter");
129 const QString VAbstractPattern::AttrAnnotation = QStringLiteral("annotation");
130 const QString VAbstractPattern::AttrOrientation = QStringLiteral("orientation");
131 const QString VAbstractPattern::AttrRotationWay = QStringLiteral("rotationWay");
132 const QString VAbstractPattern::AttrTilt = QStringLiteral("tilt");
133 const QString VAbstractPattern::AttrFoldPosition = QStringLiteral("foldPosition");
134 const QString VAbstractPattern::AttrQuantity = QStringLiteral("quantity");
135 const QString VAbstractPattern::AttrOnFold = QStringLiteral("onFold");
136 const QString VAbstractPattern::AttrDateFormat = QStringLiteral("dateFormat");
137 const QString VAbstractPattern::AttrTimeFormat = QStringLiteral("timeFormat");
138 const QString VAbstractPattern::AttrArrows = QStringLiteral("arrows");
139 const QString VAbstractPattern::AttrNodeReverse = QStringLiteral("reverse");
140 const QString VAbstractPattern::AttrNodeExcluded = QStringLiteral("excluded");
141 const QString VAbstractPattern::AttrNodeIsNotch = QStringLiteral("notch");
142 const QString VAbstractPattern::AttrNodeNotchType = QStringLiteral("notchType");
143 const QString VAbstractPattern::AttrNodeNotchSubType = QStringLiteral("notchSubtype");
144 const QString VAbstractPattern::AttrNodeShowNotch = QStringLiteral("showNotch");
145 const QString VAbstractPattern::AttrNodeShowSecondNotch = QStringLiteral("showSecondNotch");
146 const QString VAbstractPattern::AttrNodeNotchLength = QStringLiteral("notchLength");
147 const QString VAbstractPattern::AttrNodeNotchWidth = QStringLiteral("notchWidth");
148 const QString VAbstractPattern::AttrNodeNotchAngle = QStringLiteral("notchAngle");
149 const QString VAbstractPattern::AttrNodeNotchCount = QStringLiteral("notchCount");
150 const QString VAbstractPattern::AttrSABefore = QStringLiteral("before");
151 const QString VAbstractPattern::AttrSAAfter = QStringLiteral("after");
152 const QString VAbstractPattern::AttrStart = QStringLiteral("start");
153 const QString VAbstractPattern::AttrPath = QStringLiteral("path");
154 const QString VAbstractPattern::AttrEnd = QStringLiteral("end");
155 const QString VAbstractPattern::AttrIncludeAs = QStringLiteral("includeAs");
156 const QString VAbstractPattern::AttrWidth = QStringLiteral("width");
157 const QString VAbstractPattern::AttrRotation = QStringLiteral("rotation");
158 
159 const QString VAbstractPattern::AttrAll = QStringLiteral("all");
160 
161 const QString VAbstractPattern::AttrH50 = QStringLiteral("h50");
162 const QString VAbstractPattern::AttrH56 = QStringLiteral("h56");
163 const QString VAbstractPattern::AttrH62 = QStringLiteral("h62");
164 const QString VAbstractPattern::AttrH68 = QStringLiteral("h68");
165 const QString VAbstractPattern::AttrH74 = QStringLiteral("h74");
166 const QString VAbstractPattern::AttrH80 = QStringLiteral("h80");
167 const QString VAbstractPattern::AttrH86 = QStringLiteral("h86");
168 const QString VAbstractPattern::AttrH92 = QStringLiteral("h92");
169 const QString VAbstractPattern::AttrH98 = QStringLiteral("h98");
170 const QString VAbstractPattern::AttrH104 = QStringLiteral("h104");
171 const QString VAbstractPattern::AttrH110 = QStringLiteral("h110");
172 const QString VAbstractPattern::AttrH116 = QStringLiteral("h116");
173 const QString VAbstractPattern::AttrH122 = QStringLiteral("h122");
174 const QString VAbstractPattern::AttrH128 = QStringLiteral("h128");
175 const QString VAbstractPattern::AttrH134 = QStringLiteral("h134");
176 const QString VAbstractPattern::AttrH140 = QStringLiteral("h140");
177 const QString VAbstractPattern::AttrH146 = QStringLiteral("h146");
178 const QString VAbstractPattern::AttrH152 = QStringLiteral("h152");
179 const QString VAbstractPattern::AttrH158 = QStringLiteral("h158");
180 const QString VAbstractPattern::AttrH164 = QStringLiteral("h164");
181 const QString VAbstractPattern::AttrH170 = QStringLiteral("h170");
182 const QString VAbstractPattern::AttrH176 = QStringLiteral("h176");
183 const QString VAbstractPattern::AttrH182 = QStringLiteral("h182");
184 const QString VAbstractPattern::AttrH188 = QStringLiteral("h188");
185 const QString VAbstractPattern::AttrH194 = QStringLiteral("h194");
186 const QString VAbstractPattern::AttrH200 = QStringLiteral("h200");
187 
188 const QString VAbstractPattern::AttrS22 = QStringLiteral("s22");
189 const QString VAbstractPattern::AttrS24 = QStringLiteral("s24");
190 const QString VAbstractPattern::AttrS26 = QStringLiteral("s26");
191 const QString VAbstractPattern::AttrS28 = QStringLiteral("s28");
192 const QString VAbstractPattern::AttrS30 = QStringLiteral("s30");
193 const QString VAbstractPattern::AttrS32 = QStringLiteral("s32");
194 const QString VAbstractPattern::AttrS34 = QStringLiteral("s34");
195 const QString VAbstractPattern::AttrS36 = QStringLiteral("s36");
196 const QString VAbstractPattern::AttrS38 = QStringLiteral("s38");
197 const QString VAbstractPattern::AttrS40 = QStringLiteral("s40");
198 const QString VAbstractPattern::AttrS42 = QStringLiteral("s42");
199 const QString VAbstractPattern::AttrS44 = QStringLiteral("s44");
200 const QString VAbstractPattern::AttrS46 = QStringLiteral("s46");
201 const QString VAbstractPattern::AttrS48 = QStringLiteral("s48");
202 const QString VAbstractPattern::AttrS50 = QStringLiteral("s50");
203 const QString VAbstractPattern::AttrS52 = QStringLiteral("s52");
204 const QString VAbstractPattern::AttrS54 = QStringLiteral("s54");
205 const QString VAbstractPattern::AttrS56 = QStringLiteral("s56");
206 const QString VAbstractPattern::AttrS58 = QStringLiteral("s58");
207 const QString VAbstractPattern::AttrS60 = QStringLiteral("s60");
208 const QString VAbstractPattern::AttrS62 = QStringLiteral("s62");
209 const QString VAbstractPattern::AttrS64 = QStringLiteral("s64");
210 const QString VAbstractPattern::AttrS66 = QStringLiteral("s66");
211 const QString VAbstractPattern::AttrS68 = QStringLiteral("s68");
212 const QString VAbstractPattern::AttrS70 = QStringLiteral("s70");
213 const QString VAbstractPattern::AttrS72 = QStringLiteral("s72");
214 
215 const QString VAbstractPattern::AttrCustom = QStringLiteral("custom");
216 const QString VAbstractPattern::AttrDefHeight = QStringLiteral("defHeight");
217 const QString VAbstractPattern::AttrDefSize = QStringLiteral("defSize");
218 const QString VAbstractPattern::AttrExtension = QStringLiteral("extension");
219 
220 const QString VAbstractPattern::IncrementName = QStringLiteral("name");
221 const QString VAbstractPattern::IncrementFormula = QStringLiteral("formula");
222 const QString VAbstractPattern::IncrementDescription = QStringLiteral("description");
223 
224 const QString VAbstractPattern::NodeArc = QStringLiteral("NodeArc");
225 const QString VAbstractPattern::NodeElArc = QStringLiteral("NodeElArc");
226 const QString VAbstractPattern::NodePoint = QStringLiteral("NodePoint");
227 const QString VAbstractPattern::NodeSpline = QStringLiteral("NodeSpline");
228 const QString VAbstractPattern::NodeSplinePath = QStringLiteral("NodeSplinePath");
229 
230 QHash<quint32, VDataTool*> VAbstractPattern::tools = QHash<quint32, VDataTool*>();
231 QVector<VLabelTemplateLine> VAbstractPattern::patternLabelLines = QVector<VLabelTemplateLine>();
232 bool VAbstractPattern::patternLabelWasChanged = false;
233 
234 namespace
235 {
236 void ReadExpressionAttribute(QVector<VFormulaField> &expressions, const QDomElement &element, const QString &attribute)
237 {
238  VFormulaField formula;
239  try
240  {
241  formula.expression = VDomDocument::GetParametrString(element, attribute);
242  }
243  catch (VExceptionEmptyParameter &e)
244  {
245  Q_UNUSED(e)
246  return;
247  }
248 
249  formula.element = element;
250  formula.attribute = attribute;
251 
252  expressions.append(formula);
253 }
254 }
255 
256 //---------------------------------------------------------------------------------------------------------------------
257 VAbstractPattern::VAbstractPattern(QObject *parent)
258  : QObject(parent)
259  , VDomDocument()
260  , activeDraftBlock(QString())
261  , m_DefaultLineColor(qApp->Settings()->getDefaultLineColor())
262  , m_DefaultLineWeight(qApp->Settings()->getDefaultLineWeight())
263  , m_DefaultLineType(qApp->Settings()->getDefaultLineType())
264  , lastSavedExportFormat(QString())
265  , cursor(0)
266  , toolsOnRemove(QVector<VDataTool*>())
267  , history(QVector<VToolRecord>())
268  , patternPieces(QStringList())
269  , modified(false)
270 {}
271 
272 //---------------------------------------------------------------------------------------------------------------------
273 QStringList VAbstractPattern::ListMeasurements() const
274 {
275  QSet<QString> measurements;
276  QSet<QString> others;
277 
278  const QStringList increments = ListIncrements();
279  for (int i=0; i < increments.size(); ++i)
280  {
281  others.insert(increments.at(i));
282  }
283 
284  const QVector<VFormulaField> expressions = ListExpressions();
285  for (int i=0; i < expressions.size(); ++i)
286  {
287  // Eval formula
288  QScopedPointer<qmu::QmuTokenParser> cal(new qmu::QmuTokenParser(expressions.at(i).expression, false, false));
289  const QMap<int, QString> tokens = cal->GetTokens();// Tokens (variables, measurements)
290  delete cal.take();
291 
292  const QList<QString> tValues = tokens.values();
293  for (int j = 0; j < tValues.size(); ++j)
294  {
295  if (tValues.at(j) == QChar('-'))
296  {
297  continue;
298  }
299 
300  if (measurements.contains(tValues.at(j)))
301  {
302  continue;
303  }
304 
305  if (others.contains(tValues.at(j)))
306  {
307  continue;
308  }
309 
310  if (IsVariable(tValues.at(j)) || IsPostfixOperator(tValues.at(j)) || IsFunction(tValues.at(j)))
311  {
312  others.insert(tValues.at(j));
313  }
314  else
315  {
316  measurements.insert(tValues.at(j));
317  }
318  }
319  }
320 
321  return QStringList(measurements.values());
322 }
323 
324 //---------------------------------------------------------------------------------------------------------------------
325 /**
326  * @brief changeActiveDraftBlock set new active draft block name.
327  * @param name new name.
328  * @param parse parser file mode.
329  */
330 void VAbstractPattern::changeActiveDraftBlock(const QString &name, const Document &parse)
331 {
332  Q_ASSERT_X(not name.isEmpty(), Q_FUNC_INFO, "name draft block is empty");
333  if (draftBlockNameExists(name))
334  {
335  this->activeDraftBlock = name;
336  if (parse == Document::FullParse)
337  {
338  emit activeDraftBlockChanged(name);
339  }
340  }
341 }
342 
343 //---------------------------------------------------------------------------------------------------------------------
344 /**
345  * @brief getActiveDraftBlockName return current draft block name.
346  * @return draft block name.
347  */
348 QString VAbstractPattern::getActiveDraftBlockName() const
349 {
350  return activeDraftBlock;
351 }
352 
353 //---------------------------------------------------------------------------------------------------------------------
354 /**
355  * @brief getActiveDraftElement return draftBlock element for current draft block.
356  * @param element draftBlock element.
357  * @return true if found.
358  */
359 bool VAbstractPattern::getActiveDraftElement(QDomElement &element) const
360 {
361  if (activeDraftBlock.isEmpty() == false)
362  {
363  const QDomNodeList elements = this->documentElement().elementsByTagName(TagDraftBlock);
364  if (elements.size() == 0)
365  {
366  return false;
367  }
368  for ( qint32 i = 0; i < elements.count(); i++ )
369  {
370  element = elements.at( i ).toElement();
371  if (element.isNull() == false)
372  {
373  const QString fieldName = element.attribute( AttrName );
374  if ( fieldName == activeDraftBlock )
375  {
376  return true;
377  }
378  }
379  }
380  element = QDomElement();
381  }
382  return false;
383 }
384 
385 //---------------------------------------------------------------------------------------------------------------------
386 /**
387  * @brief draftBlockNameExists check if draft block with this name exists.
388  * @param name draft block name.
389  * @return true if exist.
390  */
391 bool VAbstractPattern::draftBlockNameExists(const QString &name) const
392 {
393  Q_ASSERT_X(not name.isEmpty(), Q_FUNC_INFO, "draft block name is empty");
394  const QDomNodeList elements = this->documentElement().elementsByTagName(TagDraftBlock);
395  if (elements.size() == 0)
396  {
397  return false;
398  }
399  for ( qint32 i = 0; i < elements.count(); i++ )
400  {
401  const QDomElement elem = elements.at( i ).toElement();
402  if (elem.isNull() == false)
403  {
404  if ( GetParametrString(elem, AttrName) == name )
405  {
406  return true;
407  }
408  }
409  }
410  return false;
411 }
412 
413 //---------------------------------------------------------------------------------------------------------------------
414 /**
415  * @brief getActiveNodeElement find element in current draft block by name.
416  * @param name name tag.
417  * @param element element.
418  * @return true if found.
419  */
420 bool VAbstractPattern::getActiveNodeElement(const QString &name, QDomElement &element) const
421 {
422  Q_ASSERT_X(not name.isEmpty(), Q_FUNC_INFO, "draft block name is empty");
423  QDomElement draftBlockElement;
424  if (getActiveDraftElement(draftBlockElement))
425  {
426  const QDomNodeList listElement = draftBlockElement.elementsByTagName(name);
427  if (listElement.size() != 1)
428  {
429  return false;
430  }
431  element = listElement.at( 0 ).toElement();
432  if (element.isNull() == false)
433  {
434  return true;
435  }
436  else
437  {
438  return false;
439  }
440  }
441  return false;
442 }
443 
444 //---------------------------------------------------------------------------------------------------------------------
445 void VAbstractPattern::parseGroups(const QDomElement &domElement)
446 {
447  Q_ASSERT_X(not domElement.isNull(), Q_FUNC_INFO, "domElement is null");
448 
449  QMap<quint32, quint32> itemTool;
450  QMap<quint32, bool> itemVisibility;
451 
452  QDomNode domNode = domElement.firstChild();
453  while (domNode.isNull() == false)
454  {
455  if (domNode.isElement())
456  {
457  const QDomElement domElement = domNode.toElement();
458  if (domElement.isNull() == false)
459  {
460  if (domElement.tagName() == TagGroup)
461  {
462  VContainer::UpdateId(GetParametrUInt(domElement, AttrId, NULL_ID_STR));
463 
464  const QPair<bool, QMap<quint32, quint32> > groupData = parseItemElement(domElement);
465  const QMap<quint32, quint32> group = groupData.second;
466  auto i = group.constBegin();
467  while (i != group.constEnd())
468  {
469  if (not itemTool.contains(i.key()))
470  {
471  itemTool.insert(i.key(), i.value());
472  }
473 
474  const bool previous = itemVisibility.value(i.key(), false);
475  itemVisibility.insert(i.key(), previous || groupData.first);
476  ++i;
477  }
478  }
479  }
480  }
481  domNode = domNode.nextSibling();
482  }
483 
484  auto i = itemTool.constBegin();
485  while (i != itemTool.constEnd())
486  {
487  if (tools.contains(i.value()))
488  {
489  VDataTool* tool = tools.value(i.value());
490  tool->GroupVisibility(i.key(), itemVisibility.value(i.key(), true));
491  }
492  ++i;
493  }
494 }
495 
496 //---------------------------------------------------------------------------------------------------------------------
497 int VAbstractPattern::draftBlockCount() const
498 {
499  const QDomElement rootElement = this->documentElement();
500  if (rootElement.isNull())
501  {
502  return 0;
503  }
504 
505  return rootElement.elementsByTagName(TagDraftBlock).count();
506 }
507 
508 //---------------------------------------------------------------------------------------------------------------------
509 QDomElement VAbstractPattern::getDraftBlockElement(const QString &name)
510 {
511  if (name.isEmpty() == false)
512  {
513  const QDomNodeList elements = this->documentElement().elementsByTagName(TagDraftBlock);
514  if (elements.size() == 0)
515  {
516  return QDomElement();
517  }
518  for ( qint32 i = 0; i < elements.count(); i++ )
519  {
520  QDomElement element = elements.at( i ).toElement();
521  if (element.isNull() == false)
522  {
523  if ( element.attribute( AttrName ) == name )
524  {
525  return element;
526  }
527  }
528  }
529  }
530  return QDomElement();
531 }
532 
533 //---------------------------------------------------------------------------------------------------------------------
534 /**
535  * @brief renameDraftBlock change draft block name.
536  * @param oldName old draft block name.
537  * @param newName new draft block name.
538  * @return true if success.
539  */
540 bool VAbstractPattern::renameDraftBlock(const QString &oldName, const QString &newName)
541 {
542  Q_ASSERT_X(not newName.isEmpty(), Q_FUNC_INFO, "new name draft block is empty");
543  Q_ASSERT_X(not oldName.isEmpty(), Q_FUNC_INFO, "old name draft block is empty");
544 
545  if (draftBlockNameExists(oldName) == false)
546  {
547  qDebug()<<"Do not exist draft block with name"<<oldName;
548  return false;
549  }
550 
551  if (draftBlockNameExists(newName))
552  {
553  qDebug()<<"Already exist draft block with name"<<newName;
554  return false;
555  }
556 
557  QDomElement ppElement = getDraftBlockElement(oldName);
558  if (ppElement.isElement())
559  {
560  if (activeDraftBlock == oldName)
561  {
562  activeDraftBlock = newName;
563  }
564  ppElement.setAttribute(AttrName, newName);
565  emit patternChanged(false);//For situation when we change name directly, without undocommands.
566  emit draftBlockNameChanged(oldName, newName);
567  return true;
568  }
569  else
570  {
571  qDebug()<<"Can't find draft block node with name"<<oldName<<Q_FUNC_INFO;
572  return false;
573  }
574 }
575 
576 //---------------------------------------------------------------------------------------------------------------------
577 /**
578  * @brief appendDraftBlock add new draft block.
579  *
580  * Method check if not exist draft block with the same name and change name active draft block name, send signal
581  * about change draft block. Doen't add draft block to file structure. This task make SPoint tool.
582  * @param name draft block name.
583  * @return true if success.
584  */
585 bool VAbstractPattern::appendDraftBlock(const QString &name)
586 {
587  Q_ASSERT_X(not name.isEmpty(), Q_FUNC_INFO, "name draft block is empty");
588  if (name.isEmpty())
589  {
590  return false;
591  }
592  if (draftBlockNameExists(name) == false)
593  {
594  setActiveDraftBlock(name);
595  return true;
596  }
597  return false;
598 }
599 
600 //---------------------------------------------------------------------------------------------------------------------
601 quint32 VAbstractPattern::getCursor() const
602 {
603  return cursor;
604 }
605 
606 //---------------------------------------------------------------------------------------------------------------------
607 void VAbstractPattern::setCursor(const quint32 &value)
608 {
609  if (cursor != value)
610  {
611  cursor = value;
612  emit ChangedCursor(cursor);
613  }
614 }
615 
616 
617 //---------------------------------------------------------------------------------------------------------------------
618 void VAbstractPattern::setDefaultPen(Pen pen)
619 {
620  m_DefaultLineColor = pen.color;
621  m_DefaultLineWeight = pen.lineWeight;
622  m_DefaultLineType = pen.lineType;
623 }
624 
625 //---------------------------------------------------------------------------------------------------------------------
626 QString VAbstractPattern::getDefaultLineColor() const
627 {
628  return m_DefaultLineColor;
629 }
630 
631 //---------------------------------------------------------------------------------------------------------------------
632 qreal VAbstractPattern::getDefaultLineWeight() const
633 {
634  return m_DefaultLineWeight;
635 }
636 
637 //---------------------------------------------------------------------------------------------------------------------
638 QString VAbstractPattern::getDefaultLineType() const
639 {
640  return m_DefaultLineType;
641 }
642 
643 //---------------------------------------------------------------------------------------------------------------------
644 /**
645  * @brief getTool return tool from tool list.
646  * @param id tool id.
647  * @return tool.
648  */
649 VDataTool *VAbstractPattern::getTool(quint32 id)
650 {
651  ToolExists(id);
652  return tools.value(id);
653 }
654 
655 //---------------------------------------------------------------------------------------------------------------------
656 /**
657  * @brief AddTool add tool to list tools.
658  * @param id tool id.
659  * @param tool tool.
660  */
661 void VAbstractPattern::AddTool(quint32 id, VDataTool *tool)
662 {
663  Q_ASSERT_X(id != 0, Q_FUNC_INFO, "id == 0");
664  SCASSERT(tool != nullptr)
665  tools.insert(id, tool);
666 }
667 
668 //---------------------------------------------------------------------------------------------------------------------
669 void VAbstractPattern::RemoveTool(quint32 id)
670 {
671  tools.remove(id);
672 }
673 
674 //---------------------------------------------------------------------------------------------------------------------
675 VPiecePath VAbstractPattern::ParsePieceNodes(const QDomElement &domElement)
676 {
677  VPiecePath path;
678  const QDomNodeList nodeList = domElement.childNodes();
679  for (qint32 i = 0; i < nodeList.size(); ++i)
680  {
681  const QDomElement element = nodeList.at(i).toElement();
682  if (not element.isNull())
683  {
684  path.Append(ParseSANode(element));
685  }
686  }
687  return path;
688 }
689 
690 //---------------------------------------------------------------------------------------------------------------------
691 QVector<CustomSARecord> VAbstractPattern::ParsePieceCSARecords(const QDomElement &domElement)
692 {
693  QVector<CustomSARecord> records;
694  const QDomNodeList nodeList = domElement.childNodes();
695  for (qint32 i = 0; i < nodeList.size(); ++i)
696  {
697  const QDomElement element = nodeList.at(i).toElement();
698  if (not element.isNull())
699  {
700  CustomSARecord record;
701  record.startPoint = GetParametrUInt(element, VAbstractPattern::AttrStart, NULL_ID_STR);
702  record.path = GetParametrUInt(element, VAbstractPattern::AttrPath, NULL_ID_STR);
703  record.endPoint = GetParametrUInt(element, VAbstractPattern::AttrEnd, NULL_ID_STR);
704  record.reverse = getParameterBool(element, VAbstractPattern::AttrNodeReverse, falseStr);
705  record.includeType = static_cast<PiecePathIncludeType>(GetParametrUInt(element,
706  VAbstractPattern::AttrIncludeAs,
707  "1"));
708  records.append(record);
709  }
710  }
711  return records;
712 }
713 
714 //---------------------------------------------------------------------------------------------------------------------
715 QVector<quint32> VAbstractPattern::ParsePieceInternalPaths(const QDomElement &domElement)
716 {
717  QVector<quint32> records;
718  const QDomNodeList nodeList = domElement.childNodes();
719  for (qint32 i = 0; i < nodeList.size(); ++i)
720  {
721  const QDomElement element = nodeList.at(i).toElement();
722  if (not element.isNull())
723  {
724  const quint32 path = GetParametrUInt(element, VAbstractPattern::AttrPath, NULL_ID_STR);
725  if (path > NULL_ID)
726  {
727  records.append(path);
728  }
729  }
730  }
731  return records;
732 }
733 
734 //---------------------------------------------------------------------------------------------------------------------
735 QVector<quint32> VAbstractPattern::ParsePieceAnchors(const QDomElement &domElement)
736 {
737  QVector<quint32> records;
738  const QDomNodeList nodeList = domElement.childNodes();
739  for (qint32 i = 0; i < nodeList.size(); ++i)
740  {
741  const QDomElement element = nodeList.at(i).toElement();
742  if (not element.isNull())
743  {
744  const quint32 path = element.text().toUInt();
745  if (path > NULL_ID)
746  {
747  records.append(path);
748  }
749  }
750  }
751  return records;
752 }
753 
754 //---------------------------------------------------------------------------------------------------------------------
755 VPieceNode VAbstractPattern::ParseSANode(const QDomElement &domElement)
756 {
757  const quint32 id = VDomDocument::GetParametrUInt(domElement, AttrIdObject, NULL_ID_STR);
758  const bool reverse = VDomDocument::GetParametrUInt(domElement, VAbstractPattern::AttrNodeReverse, "0");
759  const bool excluded = VDomDocument::getParameterBool(domElement, VAbstractPattern::AttrNodeExcluded, falseStr);
760  const QString saBefore = VDomDocument::GetParametrString(domElement, VAbstractPattern::AttrSABefore,
761  currentSeamAllowance);
762  const QString saAfter = VDomDocument::GetParametrString(domElement, VAbstractPattern::AttrSAAfter,
763  currentSeamAllowance);
764  const PieceNodeAngle angle = static_cast<PieceNodeAngle>(VDomDocument::GetParametrUInt(domElement, AttrAngle, "0"));
765 
766  const bool notch = VDomDocument::getParameterBool(domElement, VAbstractPattern::AttrNodeIsNotch, falseStr);
767  const NotchType notchType = stringToNotchType(VDomDocument::GetParametrString(domElement,
768  VAbstractPattern::AttrNodeNotchType,strSlit));
769  const NotchSubType notchSubType = stringToNotchSubType(VDomDocument::GetParametrString(domElement,
770  VAbstractPattern::AttrNodeNotchSubType, strStraightforward));
771 
772  const bool showNotch = VDomDocument::getParameterBool(domElement, VAbstractPattern::AttrNodeShowNotch,
773  trueStr);
774  const bool showSecond = VDomDocument::getParameterBool(domElement, VAbstractPattern::AttrNodeShowSecondNotch,
775  trueStr);
776  const qreal notchLength = VDomDocument::GetParametrDouble(domElement, VAbstractPattern::AttrNodeNotchLength,
777  QString::number(qApp->Settings()->getDefaultNotchLength()));
778  const qreal notchWidth = VDomDocument::GetParametrDouble(domElement, VAbstractPattern::AttrNodeNotchWidth,
779  QString::number(qApp->Settings()->getDefaultNotchWidth()));
780  const qreal notchAngle = VDomDocument::GetParametrDouble(domElement, VAbstractPattern::AttrNodeNotchAngle, ".00");
781  const quint32 notchCount = VDomDocument::GetParametrUInt(domElement, VAbstractPattern::AttrNodeNotchCount, "1");
782 
783 
784  const QString t = VDomDocument::GetParametrString(domElement, AttrType, VAbstractPattern::NodePoint);
785  Tool tool;
786 
787  const QStringList types = QStringList() << VAbstractPattern::NodePoint
788  << VAbstractPattern::NodeArc
789  << VAbstractPattern::NodeSpline
790  << VAbstractPattern::NodeSplinePath
791  << VAbstractPattern::NodeElArc;
792 
793  switch (types.indexOf(t))
794  {
795  case 0: // VAbstractPattern::NodePoint
796  tool = Tool::NodePoint;
797  break;
798  case 1: // VAbstractPattern::NodeArc
799  tool = Tool::NodeArc;
800  break;
801  case 2: // VAbstractPattern::NodeSpline
802  tool = Tool::NodeSpline;
803  break;
804  case 3: // VAbstractPattern::NodeSplinePath
805  tool = Tool::NodeSplinePath;
806  break;
807  case 4: // NodeElArc
808  tool = Tool::NodeElArc;
809  break;
810  default:
811  VException e(QObject::tr("Wrong tag name '%1'.").arg(t));
812  throw e;
813  }
814  VPieceNode node(id, tool, reverse);
815  node.setBeforeSAFormula(saBefore);
816  node.setAfterSAFormula(saAfter);
817  node.SetAngleType(angle);
818  node.SetExcluded(excluded);
819  node.setNotch(notch);
820  node.setNotchType(notchType);
821  node.setNotchSubType(notchSubType);
822  node.setShowNotch(showNotch);
823  node.setShowSeamlineNotch(showSecond);
824  node.setNotchLength(notchLength);
825  node.setNotchWidth(notchWidth);
826  node.setNotchAngle(notchAngle);
827  node.setNotchCount(notchCount);
828  return node;
829 }
830 
831 //---------------------------------------------------------------------------------------------------------------------
832 void VAbstractPattern::AddToolOnRemove(VDataTool *tool)
833 {
834  SCASSERT(tool != nullptr)
835  toolsOnRemove.append(tool);
836 }
837 
838 //---------------------------------------------------------------------------------------------------------------------
839 /**
840  * @brief getHistory return list with list of history records.
841  * @return list of history records.
842  */
843 QVector<VToolRecord> *VAbstractPattern::getHistory()
844 {
845  return &history;
846 }
847 
848 //---------------------------------------------------------------------------------------------------------------------
849 QVector<VToolRecord> VAbstractPattern::getBlockHistory() const
850 {
851  QVector<VToolRecord> draftBlockHistory;
852  for (qint32 i = 0; i< history.size(); ++i)
853  {
854  const VToolRecord tool = history.at(i);
855  if (tool.getDraftBlockName() != getActiveDraftBlockName())
856  {
857  continue;
858  }
859  draftBlockHistory.append(tool);
860  }
861  return draftBlockHistory;
862 }
863 
864 //---------------------------------------------------------------------------------------------------------------------
865 QMap<quint32, Tool> VAbstractPattern::getGroupObjHistory() const
866 {
867  QMap<quint32, Tool> draftBlockHistory;
868  for (qint32 i = 0; i< history.size(); ++i)
869  {
870  const VToolRecord tool = history.at(i);
871  if (tool.getDraftBlockName() != getActiveDraftBlockName())
872  {
873  continue;
874  }
875  draftBlockHistory.insert(tool.getId(), tool.getTypeTool());
876  }
877  return draftBlockHistory;
878 }
879 
880 //---------------------------------------------------------------------------------------------------------------------
881 QString VAbstractPattern::MPath() const
882 {
883  return UniqueTagText(TagMeasurements);
884 }
885 
886 //---------------------------------------------------------------------------------------------------------------------
887 void VAbstractPattern::SetMPath(const QString &path)
888 {
889  if (setTagText(TagMeasurements, path))
890  {
891  emit patternChanged(false);
892  patternLabelWasChanged = true;
893  }
894  else
895  {
896  qDebug()<<"Can't save path to measurements"<<Q_FUNC_INFO;
897  }
898 }
899 
900 //---------------------------------------------------------------------------------------------------------------------
901 quint32 VAbstractPattern::SiblingNodeId(const quint32 &nodeId) const
902 {
903  quint32 siblingId = NULL_ID;
904 
905  const QVector<VToolRecord> history = getBlockHistory();
906  for (qint32 i = 0; i < history.size(); ++i)
907  {
908  const VToolRecord tool = history.at(i);
909  if (nodeId == tool.getId())
910  {
911  if (i == 0)
912  {
913  siblingId = NULL_ID;
914  }
915  else
916  {
917  for (qint32 j = i; j > 0; --j)
918  {
919  const VToolRecord tool = history.at(j-1);
920  switch ( tool.getTypeTool() )
921  {
922  case Tool::Piece:
923  case Tool::Union:
924  case Tool::NodeArc:
925  case Tool::NodeElArc:
926  case Tool::NodePoint:
927  case Tool::NodeSpline:
928  case Tool::NodeSplinePath:
929  continue;
930  default:
931  siblingId = tool.getId();
932  j = 0;// break loop
933  break;
934  }
935  }
936  }
937  }
938  }
939  return siblingId;
940 }
941 
942 //---------------------------------------------------------------------------------------------------------------------
943 QStringList VAbstractPattern::getPatternPieces() const
944 {
945  return patternPieces;
946 }
947 
948 //---------------------------------------------------------------------------------------------------------------------
949 QMap<GHeights, bool> VAbstractPattern::GetGradationHeights() const
950 {
951  QMap<GHeights, bool> map;
952 
953  map.insert(GHeights::ALL, true);
954  map.insert(GHeights::H50, true);
955  map.insert(GHeights::H56, true);
956  map.insert(GHeights::H62, true);
957  map.insert(GHeights::H68, true);
958  map.insert(GHeights::H74, true);
959  map.insert(GHeights::H80, true);
960  map.insert(GHeights::H86, true);
961  map.insert(GHeights::H92, true);
962  map.insert(GHeights::H98, true);
963  map.insert(GHeights::H104, true);
964  map.insert(GHeights::H110, true);
965  map.insert(GHeights::H116, true);
966  map.insert(GHeights::H122, true);
967  map.insert(GHeights::H128, true);
968  map.insert(GHeights::H134, true);
969  map.insert(GHeights::H140, true);
970  map.insert(GHeights::H146, true);
971  map.insert(GHeights::H152, true);
972  map.insert(GHeights::H158, true);
973  map.insert(GHeights::H164, true);
974  map.insert(GHeights::H170, true);
975  map.insert(GHeights::H176, true);
976  map.insert(GHeights::H182, true);
977  map.insert(GHeights::H188, true);
978  map.insert(GHeights::H194, true);
979  map.insert(GHeights::H200, true);
980 
981  QDomNodeList tags = elementsByTagName(TagGradation);
982  if (tags.size() == 0)
983  {
984  return map;
985  }
986 
987  QStringList gTags = QStringList() << TagHeights << TagSizes;
988  QDomNode domNode = tags.at(0).firstChild();
989  while (domNode.isNull() == false)
990  {
991  if (domNode.isElement())
992  {
993  const QDomElement domElement = domNode.toElement();
994  if (domElement.isNull() == false)
995  {
996  const QString defValue = trueStr;
997  switch (gTags.indexOf(domElement.tagName()))
998  {
999  case 0: // TagHeights
1000  if (getParameterBool(domElement, AttrAll, defValue))
1001  {
1002  return map;
1003  }
1004  else
1005  {
1006  map.insert(GHeights::ALL, false);
1007  }
1008 
1009  map.insert(GHeights::H50, getParameterBool(domElement, AttrH50, defValue));
1010  map.insert(GHeights::H56, getParameterBool(domElement, AttrH56, defValue));
1011  map.insert(GHeights::H62, getParameterBool(domElement, AttrH62, defValue));
1012  map.insert(GHeights::H68, getParameterBool(domElement, AttrH68, defValue));
1013  map.insert(GHeights::H74, getParameterBool(domElement, AttrH74, defValue));
1014  map.insert(GHeights::H80, getParameterBool(domElement, AttrH80, defValue));
1015  map.insert(GHeights::H86, getParameterBool(domElement, AttrH86, defValue));
1016  map.insert(GHeights::H92, getParameterBool(domElement, AttrH92, defValue));
1017  map.insert(GHeights::H98, getParameterBool(domElement, AttrH98, defValue));
1018  map.insert(GHeights::H104, getParameterBool(domElement, AttrH104, defValue));
1019  map.insert(GHeights::H110, getParameterBool(domElement, AttrH110, defValue));
1020  map.insert(GHeights::H116, getParameterBool(domElement, AttrH116, defValue));
1021  map.insert(GHeights::H122, getParameterBool(domElement, AttrH122, defValue));
1022  map.insert(GHeights::H128, getParameterBool(domElement, AttrH128, defValue));
1023  map.insert(GHeights::H134, getParameterBool(domElement, AttrH134, defValue));
1024  map.insert(GHeights::H140, getParameterBool(domElement, AttrH140, defValue));
1025  map.insert(GHeights::H146, getParameterBool(domElement, AttrH146, defValue));
1026  map.insert(GHeights::H152, getParameterBool(domElement, AttrH152, defValue));
1027  map.insert(GHeights::H158, getParameterBool(domElement, AttrH158, defValue));
1028  map.insert(GHeights::H164, getParameterBool(domElement, AttrH164, defValue));
1029  map.insert(GHeights::H170, getParameterBool(domElement, AttrH170, defValue));
1030  map.insert(GHeights::H176, getParameterBool(domElement, AttrH176, defValue));
1031  map.insert(GHeights::H182, getParameterBool(domElement, AttrH182, defValue));
1032  map.insert(GHeights::H188, getParameterBool(domElement, AttrH188, defValue));
1033  map.insert(GHeights::H194, getParameterBool(domElement, AttrH194, defValue));
1034  map.insert(GHeights::H200, getParameterBool(domElement, AttrH200, defValue));
1035  return map;
1036  case 1: // TagSizes
1037  default:
1038  break;
1039  }
1040  }
1041  }
1042  domNode = domNode.nextSibling();
1043  }
1044  return map;
1045 }
1046 
1047 //---------------------------------------------------------------------------------------------------------------------
1048 void VAbstractPattern::SetGradationHeights(const QMap<GHeights, bool> &options)
1049 {
1050  CheckTagExists(TagGradation);
1051  QDomNodeList tags = elementsByTagName(TagGradation);
1052  if (tags.isEmpty())
1053  {
1054  qDebug()<<"Can't save tag "<<TagGradation<<Q_FUNC_INFO;
1055  return;
1056  }
1057 
1058  QStringList gTags = QStringList() << TagHeights << TagSizes;
1059  QDomNode domNode = tags.at(0).firstChild();
1060  while (domNode.isNull() == false)
1061  {
1062  if (domNode.isElement())
1063  {
1064  QDomElement domElement = domNode.toElement();
1065  if (domElement.isNull() == false)
1066  {
1067  switch (gTags.indexOf(domElement.tagName()))
1068  {
1069  case 0: // TagHeights
1070  SetAttribute(domElement, AttrAll, options.value(GHeights::ALL));
1071  if (options.value(GHeights::ALL))
1072  {
1073  domElement.removeAttribute(AttrH50);
1074  domElement.removeAttribute(AttrH56);
1075  domElement.removeAttribute(AttrH62);
1076  domElement.removeAttribute(AttrH68);
1077  domElement.removeAttribute(AttrH74);
1078  domElement.removeAttribute(AttrH80);
1079  domElement.removeAttribute(AttrH86);
1080  domElement.removeAttribute(AttrH92);
1081  domElement.removeAttribute(AttrH98);
1082  domElement.removeAttribute(AttrH104);
1083  domElement.removeAttribute(AttrH110);
1084  domElement.removeAttribute(AttrH116);
1085  domElement.removeAttribute(AttrH122);
1086  domElement.removeAttribute(AttrH128);
1087  domElement.removeAttribute(AttrH134);
1088  domElement.removeAttribute(AttrH140);
1089  domElement.removeAttribute(AttrH146);
1090  domElement.removeAttribute(AttrH152);
1091  domElement.removeAttribute(AttrH158);
1092  domElement.removeAttribute(AttrH164);
1093  domElement.removeAttribute(AttrH170);
1094  domElement.removeAttribute(AttrH176);
1095  domElement.removeAttribute(AttrH182);
1096  domElement.removeAttribute(AttrH188);
1097  domElement.removeAttribute(AttrH194);
1098  domElement.removeAttribute(AttrH200);
1099  }
1100  else
1101  {
1102  SetAttribute(domElement, AttrH50, options.value(GHeights::H50));
1103  SetAttribute(domElement, AttrH56, options.value(GHeights::H56));
1104  SetAttribute(domElement, AttrH62, options.value(GHeights::H62));
1105  SetAttribute(domElement, AttrH68, options.value(GHeights::H68));
1106  SetAttribute(domElement, AttrH74, options.value(GHeights::H74));
1107  SetAttribute(domElement, AttrH80, options.value(GHeights::H80));
1108  SetAttribute(domElement, AttrH86, options.value(GHeights::H86));
1109  SetAttribute(domElement, AttrH92, options.value(GHeights::H92));
1110  SetAttribute(domElement, AttrH98, options.value(GHeights::H98));
1111  SetAttribute(domElement, AttrH104, options.value(GHeights::H104));
1112  SetAttribute(domElement, AttrH110, options.value(GHeights::H110));
1113  SetAttribute(domElement, AttrH116, options.value(GHeights::H116));
1114  SetAttribute(domElement, AttrH122, options.value(GHeights::H122));
1115  SetAttribute(domElement, AttrH128, options.value(GHeights::H128));
1116  SetAttribute(domElement, AttrH134, options.value(GHeights::H134));
1117  SetAttribute(domElement, AttrH140, options.value(GHeights::H140));
1118  SetAttribute(domElement, AttrH146, options.value(GHeights::H146));
1119  SetAttribute(domElement, AttrH152, options.value(GHeights::H152));
1120  SetAttribute(domElement, AttrH158, options.value(GHeights::H158));
1121  SetAttribute(domElement, AttrH164, options.value(GHeights::H164));
1122  SetAttribute(domElement, AttrH170, options.value(GHeights::H170));
1123  SetAttribute(domElement, AttrH176, options.value(GHeights::H176));
1124  SetAttribute(domElement, AttrH182, options.value(GHeights::H182));
1125  SetAttribute(domElement, AttrH188, options.value(GHeights::H188));
1126  SetAttribute(domElement, AttrH194, options.value(GHeights::H194));
1127  SetAttribute(domElement, AttrH200, options.value(GHeights::H200));
1128  }
1129 
1130  modified = true;
1131  emit patternChanged(false);
1132  return;
1133  case 1: // TagSizes
1134  default:
1135  break;
1136  }
1137  }
1138  }
1139  domNode = domNode.nextSibling();
1140  }
1141 }
1142 
1143 //---------------------------------------------------------------------------------------------------------------------
1144 QMap<GSizes, bool> VAbstractPattern::GetGradationSizes() const
1145 {
1146  QMap<GSizes, bool> map;
1147  map.insert(GSizes::ALL, true);
1148  map.insert(GSizes::S22, true);
1149  map.insert(GSizes::S24, true);
1150  map.insert(GSizes::S26, true);
1151  map.insert(GSizes::S28, true);
1152  map.insert(GSizes::S30, true);
1153  map.insert(GSizes::S32, true);
1154  map.insert(GSizes::S34, true);
1155  map.insert(GSizes::S36, true);
1156  map.insert(GSizes::S38, true);
1157  map.insert(GSizes::S40, true);
1158  map.insert(GSizes::S42, true);
1159  map.insert(GSizes::S44, true);
1160  map.insert(GSizes::S46, true);
1161  map.insert(GSizes::S48, true);
1162  map.insert(GSizes::S50, true);
1163  map.insert(GSizes::S52, true);
1164  map.insert(GSizes::S54, true);
1165  map.insert(GSizes::S56, true);
1166  map.insert(GSizes::S58, true);
1167  map.insert(GSizes::S60, true);
1168  map.insert(GSizes::S62, true);
1169  map.insert(GSizes::S64, true);
1170  map.insert(GSizes::S66, true);
1171  map.insert(GSizes::S68, true);
1172  map.insert(GSizes::S70, true);
1173  map.insert(GSizes::S72, true);
1174 
1175  QDomNodeList tags = elementsByTagName(TagGradation);
1176  if (tags.size() == 0)
1177  {
1178  return map;
1179  }
1180 
1181  QStringList gTags = QStringList() << TagHeights << TagSizes;
1182  QDomNode domNode = tags.at(0).firstChild();
1183  while (domNode.isNull() == false)
1184  {
1185  if (domNode.isElement())
1186  {
1187  const QDomElement domElement = domNode.toElement();
1188  if (domElement.isNull() == false)
1189  {
1190  const QString defValue = trueStr;
1191  switch (gTags.indexOf(domElement.tagName()))
1192  {
1193  case 1: // TagSizes
1194  if (getParameterBool(domElement, AttrAll, defValue))
1195  {
1196  return map;
1197  }
1198  else
1199  {
1200  map.insert(GSizes::ALL, false);
1201  }
1202 
1203  map.insert(GSizes::S22, getParameterBool(domElement, AttrS22, defValue));
1204  map.insert(GSizes::S24, getParameterBool(domElement, AttrS24, defValue));
1205  map.insert(GSizes::S26, getParameterBool(domElement, AttrS26, defValue));
1206  map.insert(GSizes::S28, getParameterBool(domElement, AttrS28, defValue));
1207  map.insert(GSizes::S30, getParameterBool(domElement, AttrS30, defValue));
1208  map.insert(GSizes::S32, getParameterBool(domElement, AttrS32, defValue));
1209  map.insert(GSizes::S34, getParameterBool(domElement, AttrS34, defValue));
1210  map.insert(GSizes::S36, getParameterBool(domElement, AttrS36, defValue));
1211  map.insert(GSizes::S38, getParameterBool(domElement, AttrS38, defValue));
1212  map.insert(GSizes::S40, getParameterBool(domElement, AttrS40, defValue));
1213  map.insert(GSizes::S42, getParameterBool(domElement, AttrS42, defValue));
1214  map.insert(GSizes::S44, getParameterBool(domElement, AttrS44, defValue));
1215  map.insert(GSizes::S46, getParameterBool(domElement, AttrS46, defValue));
1216  map.insert(GSizes::S48, getParameterBool(domElement, AttrS48, defValue));
1217  map.insert(GSizes::S50, getParameterBool(domElement, AttrS50, defValue));
1218  map.insert(GSizes::S52, getParameterBool(domElement, AttrS52, defValue));
1219  map.insert(GSizes::S54, getParameterBool(domElement, AttrS54, defValue));
1220  map.insert(GSizes::S56, getParameterBool(domElement, AttrS56, defValue));
1221  map.insert(GSizes::S58, getParameterBool(domElement, AttrS58, defValue));
1222  map.insert(GSizes::S60, getParameterBool(domElement, AttrS60, defValue));
1223  map.insert(GSizes::S62, getParameterBool(domElement, AttrS62, defValue));
1224  map.insert(GSizes::S64, getParameterBool(domElement, AttrS64, defValue));
1225  map.insert(GSizes::S66, getParameterBool(domElement, AttrS66, defValue));
1226  map.insert(GSizes::S68, getParameterBool(domElement, AttrS68, defValue));
1227  map.insert(GSizes::S70, getParameterBool(domElement, AttrS70, defValue));
1228  map.insert(GSizes::S72, getParameterBool(domElement, AttrS72, defValue));
1229  return map;
1230  case 0: // TagHeights
1231  default:
1232  break;
1233  }
1234  }
1235  }
1236  domNode = domNode.nextSibling();
1237  }
1238  return map;
1239 }
1240 
1241 //---------------------------------------------------------------------------------------------------------------------
1242 void VAbstractPattern::SetGradationSizes(const QMap<GSizes, bool> &options)
1243 {
1244  CheckTagExists(TagGradation);
1245  QDomNodeList tags = elementsByTagName(TagGradation);
1246  if (tags.isEmpty())
1247  {
1248  qDebug()<<"Can't save tag "<<TagGradation<<Q_FUNC_INFO;
1249  return;
1250  }
1251 
1252  QStringList gTags = QStringList() << TagHeights << TagSizes;
1253  QDomNode domNode = tags.at(0).firstChild();
1254  while (domNode.isNull() == false)
1255  {
1256  if (domNode.isElement())
1257  {
1258  QDomElement domElement = domNode.toElement();
1259  if (domElement.isNull() == false)
1260  {
1261  switch (gTags.indexOf(domElement.tagName()))
1262  {
1263  case 1: // TagSizes
1264  SetAttribute(domElement, AttrAll, options.value(GSizes::ALL));
1265  if (options.value(GSizes::ALL))
1266  {
1267  domElement.removeAttribute(AttrS22);
1268  domElement.removeAttribute(AttrS24);
1269  domElement.removeAttribute(AttrS26);
1270  domElement.removeAttribute(AttrS28);
1271  domElement.removeAttribute(AttrS30);
1272  domElement.removeAttribute(AttrS32);
1273  domElement.removeAttribute(AttrS34);
1274  domElement.removeAttribute(AttrS36);
1275  domElement.removeAttribute(AttrS38);
1276  domElement.removeAttribute(AttrS40);
1277  domElement.removeAttribute(AttrS42);
1278  domElement.removeAttribute(AttrS44);
1279  domElement.removeAttribute(AttrS46);
1280  domElement.removeAttribute(AttrS48);
1281  domElement.removeAttribute(AttrS50);
1282  domElement.removeAttribute(AttrS52);
1283  domElement.removeAttribute(AttrS54);
1284  domElement.removeAttribute(AttrS56);
1285  domElement.removeAttribute(AttrS58);
1286  domElement.removeAttribute(AttrS60);
1287  domElement.removeAttribute(AttrS62);
1288  domElement.removeAttribute(AttrS64);
1289  domElement.removeAttribute(AttrS66);
1290  domElement.removeAttribute(AttrS68);
1291  domElement.removeAttribute(AttrS70);
1292  domElement.removeAttribute(AttrS72);
1293  }
1294  else
1295  {
1296  SetAttribute(domElement, AttrS22, options.value(GSizes::S22));
1297  SetAttribute(domElement, AttrS24, options.value(GSizes::S24));
1298  SetAttribute(domElement, AttrS26, options.value(GSizes::S26));
1299  SetAttribute(domElement, AttrS28, options.value(GSizes::S28));
1300  SetAttribute(domElement, AttrS30, options.value(GSizes::S30));
1301  SetAttribute(domElement, AttrS32, options.value(GSizes::S32));
1302  SetAttribute(domElement, AttrS34, options.value(GSizes::S34));
1303  SetAttribute(domElement, AttrS36, options.value(GSizes::S36));
1304  SetAttribute(domElement, AttrS38, options.value(GSizes::S38));
1305  SetAttribute(domElement, AttrS40, options.value(GSizes::S40));
1306  SetAttribute(domElement, AttrS42, options.value(GSizes::S42));
1307  SetAttribute(domElement, AttrS44, options.value(GSizes::S44));
1308  SetAttribute(domElement, AttrS46, options.value(GSizes::S46));
1309  SetAttribute(domElement, AttrS48, options.value(GSizes::S48));
1310  SetAttribute(domElement, AttrS50, options.value(GSizes::S50));
1311  SetAttribute(domElement, AttrS52, options.value(GSizes::S52));
1312  SetAttribute(domElement, AttrS54, options.value(GSizes::S54));
1313  SetAttribute(domElement, AttrS56, options.value(GSizes::S56));
1314  SetAttribute(domElement, AttrS58, options.value(GSizes::S58));
1315  SetAttribute(domElement, AttrS60, options.value(GSizes::S60));
1316  SetAttribute(domElement, AttrS62, options.value(GSizes::S62));
1317  SetAttribute(domElement, AttrS64, options.value(GSizes::S64));
1318  SetAttribute(domElement, AttrS66, options.value(GSizes::S66));
1319  SetAttribute(domElement, AttrS68, options.value(GSizes::S68));
1320  SetAttribute(domElement, AttrS70, options.value(GSizes::S70));
1321  SetAttribute(domElement, AttrS72, options.value(GSizes::S72));
1322  }
1323 
1324  modified = true;
1325  emit patternChanged(false);
1326  return;
1327  case 0: // TagHeights
1328  default:
1329  break;
1330  }
1331  }
1332  }
1333  domNode = domNode.nextSibling();
1334  }
1335 }
1336 
1337 //---------------------------------------------------------------------------------------------------------------------
1338 QString VAbstractPattern::GetDescription() const
1339 {
1340  return UniqueTagText(TagDescription);
1341 }
1342 
1343 //---------------------------------------------------------------------------------------------------------------------
1344 void VAbstractPattern::SetDescription(const QString &text)
1345 {
1346  CheckTagExists(TagDescription);
1347  setTagText(TagDescription, text);
1348  modified = true;
1349  emit patternChanged(false);
1350 }
1351 
1352 //---------------------------------------------------------------------------------------------------------------------
1353 QString VAbstractPattern::GetNotes() const
1354 {
1355  return UniqueTagText(TagNotes);
1356 }
1357 
1358 //---------------------------------------------------------------------------------------------------------------------
1359 void VAbstractPattern::SetNotes(const QString &text)
1360 {
1361  CheckTagExists(TagNotes);
1362  setTagText(TagNotes, text);
1363  modified = true;
1364  emit patternChanged(false);
1365 }
1366 
1367 //---------------------------------------------------------------------------------------------------------------------
1368 QString VAbstractPattern::GetPatternName() const
1369 {
1370  return UniqueTagText(TagPatternName);
1371 }
1372 
1373 //---------------------------------------------------------------------------------------------------------------------
1374 void VAbstractPattern::SetPatternName(const QString &qsName)
1375 {
1376  CheckTagExists(TagPatternName);
1377  setTagText(TagPatternName, qsName);
1378  patternLabelWasChanged = true;
1379  modified = true;
1380  emit patternChanged(false);
1381 }
1382 
1383 //---------------------------------------------------------------------------------------------------------------------
1384 QString VAbstractPattern::GetCompanyName() const
1385 {
1386  return UniqueTagText(TagCompanyName);
1387 }
1388 
1389 //---------------------------------------------------------------------------------------------------------------------
1390 void VAbstractPattern::SetCompanyName(const QString &qsName)
1391 {
1392  CheckTagExists(TagCompanyName);
1393  setTagText(TagCompanyName, qsName);
1394  patternLabelWasChanged = true;
1395  modified = true;
1396  emit patternChanged(false);
1397 }
1398 
1399 //---------------------------------------------------------------------------------------------------------------------
1400 QString VAbstractPattern::GetPatternNumber() const
1401 {
1402  return UniqueTagText(TagPatternNum);
1403 }
1404 
1405 //---------------------------------------------------------------------------------------------------------------------
1406 void VAbstractPattern::SetPatternNumber(const QString &qsNum)
1407 {
1408  CheckTagExists(TagPatternNum);
1409  setTagText(TagPatternNum, qsNum);
1410  patternLabelWasChanged = true;
1411  modified = true;
1412  emit patternChanged(false);
1413 }
1414 
1415 //---------------------------------------------------------------------------------------------------------------------
1416 QString VAbstractPattern::GetCustomerName() const
1417 {
1418  return UniqueTagText(TagCustomerName);
1419 }
1420 
1421 //---------------------------------------------------------------------------------------------------------------------
1422 void VAbstractPattern::SetCustomerName(const QString &qsName)
1423 {
1424  CheckTagExists(TagCustomerName);
1425  setTagText(TagCustomerName, qsName);
1426  patternLabelWasChanged = true;
1427  modified = true;
1428  emit patternChanged(false);
1429 }
1430 
1431 //---------------------------------------------------------------------------------------------------------------------
1432 QString VAbstractPattern::GetLabelDateFormat() const
1433 {
1434  QString globalLabelDateFormat = qApp->Settings()->GetLabelDateFormat();
1435 
1436  const QDomNodeList list = elementsByTagName(TagPatternLabel);
1437  if (list.isEmpty())
1438  {
1439  return globalLabelDateFormat;
1440  }
1441 
1442  QDomElement tag = list.at(0).toElement();
1443  return GetParametrString(tag, AttrDateFormat, globalLabelDateFormat);
1444 }
1445 
1446 //---------------------------------------------------------------------------------------------------------------------
1447 void VAbstractPattern::SetLabelDateFormat(const QString &format)
1448 {
1449  QDomElement tag = CheckTagExists(TagPatternLabel);
1450  SetAttribute(tag, AttrDateFormat, format);
1451  patternLabelWasChanged = true;
1452  modified = true;
1453  emit patternChanged(false);
1454 }
1455 
1456 //---------------------------------------------------------------------------------------------------------------------
1457 QString VAbstractPattern::GetLabelTimeFormat() const
1458 {
1459  QString globalLabelTimeFormat = qApp->Settings()->GetLabelTimeFormat();
1460 
1461  const QDomNodeList list = elementsByTagName(TagPatternLabel);
1462  if (list.isEmpty())
1463  {
1464  return globalLabelTimeFormat;
1465  }
1466 
1467  QDomElement tag = list.at(0).toElement();
1468  return GetParametrString(tag, AttrTimeFormat, globalLabelTimeFormat);
1469 }
1470 
1471 //---------------------------------------------------------------------------------------------------------------------
1472 void VAbstractPattern::SetLabelTimeFormat(const QString &format)
1473 {
1474  QDomElement tag = CheckTagExists(TagPatternLabel);
1475  SetAttribute(tag, AttrTimeFormat, format);
1476  patternLabelWasChanged = true;
1477  modified = true;
1478  emit patternChanged(false);
1479 }
1480 
1481 //---------------------------------------------------------------------------------------------------------------------
1482 void VAbstractPattern::setPatternLabelTemplate(const QVector<VLabelTemplateLine> &lines)
1483 {
1484  QDomElement tag = CheckTagExists(TagPatternLabel);
1485  RemoveAllChildren(tag);
1486  SetLabelTemplate(tag, lines);
1487  patternLabelLines = lines;
1488  patternLabelWasChanged = true;
1489  modified = true;
1490  emit patternChanged(false);
1491 }
1492 
1493 //---------------------------------------------------------------------------------------------------------------------
1494 QVector<VLabelTemplateLine> VAbstractPattern::getPatternLabelTemplate() const
1495 {
1496  if (patternLabelLines.isEmpty())
1497  {
1498  const QDomNodeList list = elementsByTagName(TagPatternLabel);
1499  if (list.isEmpty())
1500  {
1501  return QVector<VLabelTemplateLine>();
1502  }
1503 
1504  patternLabelLines = GetLabelTemplate(list.at(0).toElement());
1505  }
1506 
1507  return patternLabelLines;
1508 }
1509 
1510 //---------------------------------------------------------------------------------------------------------------------
1511 void VAbstractPattern::SetPatternWasChanged(bool changed)
1512 {
1513  patternLabelWasChanged = changed;
1514 }
1515 
1516 //---------------------------------------------------------------------------------------------------------------------
1517 bool VAbstractPattern::GetPatternWasChanged() const
1518 {
1519  return patternLabelWasChanged;
1520 }
1521 
1522 //---------------------------------------------------------------------------------------------------------------------
1523 QString VAbstractPattern::GetImage() const
1524 {
1525  return UniqueTagText(TagImage);
1526 }
1527 
1528 //---------------------------------------------------------------------------------------------------------------------
1529 QString VAbstractPattern::GetImageExtension() const
1530 {
1531  const QString defExt = QStringLiteral("PNG");
1532  const QDomNodeList nodeList = this->elementsByTagName(TagImage);
1533  if (nodeList.isEmpty())
1534  {
1535  return defExt;
1536  }
1537  else
1538  {
1539  const QDomNode domNode = nodeList.at(0);
1540  if (domNode.isNull() == false && domNode.isElement())
1541  {
1542  const QDomElement domElement = domNode.toElement();
1543  if (domElement.isNull() == false)
1544  {
1545  const QString ext = domElement.attribute(AttrExtension, defExt);
1546  return ext;
1547  }
1548  }
1549  }
1550  return defExt;
1551 }
1552 
1553 //---------------------------------------------------------------------------------------------------------------------
1554 void VAbstractPattern::SetImage(const QString &text, const QString &extension)
1555 {
1556  QDomElement imageElement = CheckTagExists(TagImage);
1557  setTagText(imageElement, text);
1558  CheckTagExists(TagImage).setAttribute(AttrExtension, extension);
1559  modified = true;
1560  emit patternChanged(false);
1561 }
1562 
1563 //---------------------------------------------------------------------------------------------------------------------
1564 void VAbstractPattern::DeleteImage()
1565 {
1566  QDomElement pattern = documentElement();
1567  pattern.removeChild(CheckTagExists(TagImage));
1568  modified = true;
1569  emit patternChanged(false);
1570 }
1571 
1572 //---------------------------------------------------------------------------------------------------------------------
1573 QString VAbstractPattern::GetVersion() const
1574 {
1575  return UniqueTagText(TagVersion, VPatternConverter::PatternMaxVerStr);
1576 }
1577 
1578 //---------------------------------------------------------------------------------------------------------------------
1579 void VAbstractPattern::SetVersion()
1580 {
1581  setTagText(TagVersion, VPatternConverter::PatternMaxVerStr);
1582  emit patternChanged(false);
1583 }
1584 
1585 //---------------------------------------------------------------------------------------------------------------------
1586 /**
1587  * @brief getOpItems get vector of operation tool obects.
1588  * @param toolId operation tool id.
1589  * @param itemType type of item - either source or destination.
1590  * @return vector of item element object ids.
1591  */
1592 QVector<quint32> VAbstractPattern::getOpItems(const quint32 &toolId, const QString &itemType)
1593 {
1594  QVector<quint32> items;
1595  quint32 objId;
1596  const QDomElement domElement = elementById(toolId);
1597  const QDomNodeList nodeList = domElement.childNodes();
1598  for (qint32 i = 0; i < nodeList.size(); ++i)
1599  {
1600  const QDomElement dataElement = nodeList.at(i).toElement();
1601  if (!dataElement.isNull() && dataElement.tagName() == itemType)
1602  {
1603  const QDomNodeList srcList = dataElement.childNodes();
1604  for (qint32 j = 0; j < srcList.size(); ++j)
1605  {
1606  const QDomElement element = srcList.at(j).toElement();
1607  if (!element.isNull())
1608  {
1609  objId = VDomDocument::GetParametrUInt(element, AttrIdObject, NULL_ID_STR);
1610  items.append(objId);
1611  }
1612  }
1613  }
1614  }
1615 
1616  return items;
1617 }
1618 
1619 //---------------------------------------------------------------------------------------------------------------------
1620 QVector<quint32> VAbstractPattern::getDartItems(const quint32 &toolId)
1621 {
1622  QVector<quint32> items;
1623  quint32 objId;
1624  const QDomElement domElement = elementById(toolId);
1625 
1626  objId = VDomDocument::GetParametrUInt(domElement, AttrPoint1, NULL_ID_STR);
1627  items.append(objId);
1628 
1629  objId = VDomDocument::GetParametrUInt(domElement, AttrPoint2, NULL_ID_STR);
1630  items.append(objId);
1631 
1632  return items;
1633 }
1634 
1635 //---------------------------------------------------------------------------------------------------------------------
1636 /**
1637  * @brief haveLiteChange we have unsaved change.
1638  */
1639 void VAbstractPattern::haveLiteChange()
1640 {
1641  emit patternChanged(false);
1642 }
1643 
1644 //---------------------------------------------------------------------------------------------------------------------
1645 void VAbstractPattern::NeedFullParsing()
1646 {
1647  emit UndoCommand();
1648 }
1649 
1650 //---------------------------------------------------------------------------------------------------------------------
1651 void VAbstractPattern::ClearScene()
1652 {
1653  emit ClearMainWindow();
1654 }
1655 
1656 //---------------------------------------------------------------------------------------------------------------------
1657 void VAbstractPattern::updatePieceList(quint32 id)
1658 {
1659  emit UpdateInLayoutList(id);
1660 }
1661 
1662 //---------------------------------------------------------------------------------------------------------------------
1663 void VAbstractPattern::selectedPiece(quint32 id)
1664 {
1665  emit showPiece(id);
1666 }
1667 
1668 //---------------------------------------------------------------------------------------------------------------------
1669 void VAbstractPattern::ToolExists(const quint32 &id)
1670 {
1671  if (tools.contains(id) == false)
1672  {
1673  throw VExceptionBadId(tr("Can't find tool in table."), id);
1674  }
1675 }
1676 
1677 //---------------------------------------------------------------------------------------------------------------------
1678 VPiecePath VAbstractPattern::ParsePathNodes(const QDomElement &domElement)
1679 {
1680  VPiecePath path;
1681  const QDomNodeList nodeList = domElement.childNodes();
1682  for (qint32 i = 0; i < nodeList.size(); ++i)
1683  {
1684  const QDomElement element = nodeList.at(i).toElement();
1685  if (not element.isNull() && element.tagName() == VAbstractPattern::TagNode)
1686  {
1687  path.Append(ParseSANode(element));
1688  }
1689  }
1690  return path;
1691 }
1692 
1693 //---------------------------------------------------------------------------------------------------------------------
1694 /**
1695  * @brief setActiveDraftBlock set current draft block.
1696  * @param name draft block name.
1697  */
1698 void VAbstractPattern::setActiveDraftBlock(const QString &name)
1699 {
1700  Q_ASSERT_X(not name.isEmpty(), Q_FUNC_INFO, "name draft block is empty");
1701  this->activeDraftBlock = name;
1702  emit activeDraftBlockChanged(name);
1703 }
1704 
1705 //---------------------------------------------------------------------------------------------------------------------
1706 QDomElement VAbstractPattern::CheckTagExists(const QString &tag)
1707 {
1708  const QDomNodeList list = elementsByTagName(tag);
1709  QDomElement element;
1710  if (list.isEmpty())
1711  {
1712  const QStringList tags = QStringList() << TagUnit << TagImage << TagDescription << TagNotes
1713  << TagGradation << TagPatternName << TagPatternNum << TagCompanyName
1714  << TagCustomerName << TagPatternLabel;
1715  switch (tags.indexOf(tag))
1716  {
1717  case 1: //TagImage
1718  element = createElement(TagImage);
1719  break;
1720  case 2: //TagDescription
1721  element = createElement(TagDescription);
1722  break;
1723  case 3: //TagNotes
1724  element = createElement(TagNotes);
1725  break;
1726  case 4: //TagGradation
1727  {
1728  element = createElement(TagGradation);
1729 
1730  QDomElement heights = createElement(TagHeights);
1731  heights.setAttribute(AttrAll, QLatin1String("true"));
1732  element.appendChild(heights);
1733 
1734  QDomElement sizes = createElement(TagSizes);
1735  sizes.setAttribute(AttrAll, QLatin1String("true"));
1736  element.appendChild(sizes);
1737  break;
1738  }
1739  case 5: // TagPatternName
1740  element = createElement(TagPatternName);
1741  break;
1742  case 6: // TagPatternNum
1743  element = createElement(TagPatternNum);
1744  break;
1745  case 7: // TagCompanyName
1746  element = createElement(TagCompanyName);
1747  break;
1748  case 8: // TagCustomerName
1749  element = createElement(TagCustomerName);
1750  break;
1751  case 9: // TagPatternLabel
1752  element = createElement(TagPatternLabel);
1753  break;
1754  case 0: //TagUnit (Mandatory tag)
1755  default:
1756  return QDomElement();
1757  }
1758  InsertTag(tags, element);
1759  return element;
1760  }
1761  return list.at(0).toElement();
1762 }
1763 
1764 //---------------------------------------------------------------------------------------------------------------------
1765 void VAbstractPattern::InsertTag(const QStringList &tags, const QDomElement &element)
1766 {
1767  QDomElement pattern = documentElement();
1768  for (int i = tags.indexOf(element.tagName())-1; i >= 0; --i)
1769  {
1770  const QDomNodeList list = elementsByTagName(tags.at(i));
1771  if (not list.isEmpty())
1772  {
1773  pattern.insertAfter(element, list.at(0));
1774  break;
1775  }
1776  }
1777  SetVersion();
1778 }
1779 
1780 //---------------------------------------------------------------------------------------------------------------------
1781 int VAbstractPattern::getActiveDraftBlockIndex() const
1782 {
1783  const QDomNodeList blockList = elementsByTagName(TagDraftBlock);
1784 
1785  int index = 0;
1786  if (not blockList.isEmpty())
1787  {
1788  for (int i = 0; i < blockList.size(); ++i)
1789  {
1790  QDomElement node = blockList.at(i).toElement();
1791  if (node.attribute(AttrName) == activeDraftBlock)
1792  {
1793  index = i;
1794  break;
1795  }
1796  }
1797  }
1798 
1799  return index;
1800 }
1801 
1802 //---------------------------------------------------------------------------------------------------------------------
1803 QStringList VAbstractPattern::ListIncrements() const
1804 {
1805  QStringList increments;
1806  const QDomNodeList list = elementsByTagName(TagIncrement);
1807  for (int i=0; i < list.size(); ++i)
1808  {
1809  const QDomElement dom = list.at(i).toElement();
1810 
1811  try
1812  {
1813  increments.append(GetParametrString(dom, IncrementName));
1814  }
1815  catch (VExceptionEmptyParameter &e)
1816  {
1817  Q_UNUSED(e)
1818  }
1819  }
1820 
1821  return increments;
1822 }
1823 
1824 //---------------------------------------------------------------------------------------------------------------------
1825 QVector<VFormulaField> VAbstractPattern::ListExpressions() const
1826 {
1827  QVector<VFormulaField> list;
1828 
1829  // If new tool bring absolutely new type and has formula(s) create new method to cover it.
1830  // Note. Tool Union Details also contains formulas, but we don't use them for union and keep only to simplifying
1831  // working with nodes. Same code for saving reading.
1832  list << ListPointExpressions();
1833  list << ListArcExpressions();
1834  list << ListElArcExpressions();
1835  list << ListSplineExpressions();
1836  list << ListIncrementExpressions();
1837  list << ListOperationExpressions();
1838  list << ListPathExpressions();
1839  list << ListPieceExpressions();
1840 
1841  return list;
1842 }
1843 
1844 //---------------------------------------------------------------------------------------------------------------------
1845 QVector<VFormulaField> VAbstractPattern::ListPointExpressions() const
1846 {
1847  // Check if new tool doesn't bring new attribute with a formula.
1848  // If no just increment a number.
1849  // If new tool bring absolutely new type and has formula(s) create new method to cover it.
1850  Q_STATIC_ASSERT(static_cast<int>(Tool::LAST_ONE_DO_NOT_USE) == 53);
1851 
1852  QVector<VFormulaField> expressions;
1853  const QDomNodeList list = elementsByTagName(TagPoint);
1854  for (int i=0; i < list.size(); ++i)
1855  {
1856  const QDomElement dom = list.at(i).toElement();
1857 
1858  // Each tag can contains several attributes.
1859  ReadExpressionAttribute(expressions, dom, AttrLength);
1860  ReadExpressionAttribute(expressions, dom, AttrAngle);
1861  ReadExpressionAttribute(expressions, dom, AttrC1Radius);
1862  ReadExpressionAttribute(expressions, dom, AttrC2Radius);
1863  ReadExpressionAttribute(expressions, dom, AttrCRadius);
1864  ReadExpressionAttribute(expressions, dom, AttrRadius);
1865  }
1866 
1867  return expressions;
1868 }
1869 
1870 //---------------------------------------------------------------------------------------------------------------------
1871 QVector<VFormulaField> VAbstractPattern::ListArcExpressions() const
1872 {
1873  // Check if new tool doesn't bring new attribute with a formula.
1874  // If no just increment number.
1875  // If new tool bring absolutely new type and has formula(s) create new method to cover it.
1876  Q_STATIC_ASSERT(static_cast<int>(Tool::LAST_ONE_DO_NOT_USE) == 53);
1877 
1878  QVector<VFormulaField> expressions;
1879  const QDomNodeList list = elementsByTagName(TagArc);
1880  for (int i=0; i < list.size(); ++i)
1881  {
1882  const QDomElement dom = list.at(i).toElement();
1883 
1884  // Each tag can contains several attributes.
1885  ReadExpressionAttribute(expressions, dom, AttrAngle1);
1886  ReadExpressionAttribute(expressions, dom, AttrAngle2);
1887  ReadExpressionAttribute(expressions, dom, AttrRadius);
1888  ReadExpressionAttribute(expressions, dom, AttrLength);
1889  }
1890 
1891  return expressions;
1892 }
1893 
1894 //---------------------------------------------------------------------------------------------------------------------
1895 QVector<VFormulaField> VAbstractPattern::ListElArcExpressions() const
1896 {
1897  // Check if new tool doesn't bring new attribute with a formula.
1898  // If no just increment number.
1899  // If new tool bring absolutely new type and has formula(s) create new method to cover it.
1900  Q_STATIC_ASSERT(static_cast<int>(Tool::LAST_ONE_DO_NOT_USE) == 53);
1901 
1902  QVector<VFormulaField> expressions;
1903  const QDomNodeList list = elementsByTagName(TagElArc);
1904  for (int i=0; i < list.size(); ++i)
1905  {
1906  const QDomElement dom = list.at(i).toElement();
1907 
1908  // Each tag can contains several attributes.
1909  ReadExpressionAttribute(expressions, dom, AttrRadius1);
1910  ReadExpressionAttribute(expressions, dom, AttrRadius2);
1911  ReadExpressionAttribute(expressions, dom, AttrAngle1);
1912  ReadExpressionAttribute(expressions, dom, AttrAngle2);
1913  ReadExpressionAttribute(expressions, dom, AttrRotationAngle);
1914  }
1915 
1916  return expressions;
1917 }
1918 
1919 //---------------------------------------------------------------------------------------------------------------------
1920 QVector<VFormulaField> VAbstractPattern::ListSplineExpressions() const
1921 {
1922  QVector<VFormulaField> expressions;
1923  expressions << ListPathPointExpressions();
1924  return expressions;
1925 }
1926 
1927 //---------------------------------------------------------------------------------------------------------------------
1928 QVector<VFormulaField> VAbstractPattern::ListPathPointExpressions() const
1929 {
1930  // Check if new tool doesn't bring new attribute with a formula.
1931  // If no just increment number.
1932  // If new tool bring absolutely new type and has formula(s) create new method to cover it.
1933  Q_STATIC_ASSERT(static_cast<int>(Tool::LAST_ONE_DO_NOT_USE) == 53);
1934 
1935  QVector<VFormulaField> expressions;
1936  const QDomNodeList list = elementsByTagName(AttrPathPoint);
1937  for (int i=0; i < list.size(); ++i)
1938  {
1939  const QDomElement dom = list.at(i).toElement();
1940 
1941  // Each tag can contains several attributes.
1942  ReadExpressionAttribute(expressions, dom, AttrKAsm1);
1943  ReadExpressionAttribute(expressions, dom, AttrKAsm2);
1944  ReadExpressionAttribute(expressions, dom, AttrAngle);
1945  }
1946 
1947  return expressions;
1948 }
1949 
1950 //---------------------------------------------------------------------------------------------------------------------
1951 QVector<VFormulaField> VAbstractPattern::ListIncrementExpressions() const
1952 {
1953  QVector<VFormulaField> expressions;
1954  const QDomNodeList list = elementsByTagName(TagIncrement);
1955  for (int i=0; i < list.size(); ++i)
1956  {
1957  const QDomElement dom = list.at(i).toElement();
1958 
1959  ReadExpressionAttribute(expressions, dom, IncrementFormula);
1960  }
1961 
1962  return expressions;
1963 }
1964 
1965 //---------------------------------------------------------------------------------------------------------------------
1966 QVector<VFormulaField> VAbstractPattern::ListOperationExpressions() const
1967 {
1968  // Check if new tool doesn't bring new attribute with a formula.
1969  // If no just increment number.
1970  // If new tool bring absolutely new type and has formula(s) create new method to cover it.
1971  Q_STATIC_ASSERT(static_cast<int>(Tool::LAST_ONE_DO_NOT_USE) == 53);
1972 
1973  QVector<VFormulaField> expressions;
1974  const QDomNodeList list = elementsByTagName(TagOperation);
1975  for (int i=0; i < list.size(); ++i)
1976  {
1977  const QDomElement dom = list.at(i).toElement();
1978 
1979  // Each tag can contains several attributes.
1980  ReadExpressionAttribute(expressions, dom, AttrAngle);
1981  ReadExpressionAttribute(expressions, dom, AttrLength);
1982  }
1983 
1984  return expressions;
1985 }
1986 
1987 //---------------------------------------------------------------------------------------------------------------------
1988 QVector<VFormulaField> VAbstractPattern::ListNodesExpressions(const QDomElement &nodes) const
1989 {
1990  // Check if new tool doesn't bring new attribute with a formula.
1991  // If no just increment number.
1992  // If new tool bring absolutely new type and has formula(s) create new method to cover it.
1993  Q_STATIC_ASSERT(static_cast<int>(Tool::LAST_ONE_DO_NOT_USE) == 53);
1994 
1995  QVector<VFormulaField> expressions;
1996 
1997  const QDomNodeList nodeList = nodes.childNodes();
1998  for (qint32 i = 0; i < nodeList.size(); ++i)
1999  {
2000  const QDomElement element = nodeList.at(i).toElement();
2001  if (not element.isNull() && element.tagName() == VAbstractPattern::TagNode)
2002  {
2003  ReadExpressionAttribute(expressions, element, VAbstractPattern::AttrSABefore);
2004  ReadExpressionAttribute(expressions, element, VAbstractPattern::AttrSAAfter);
2005  }
2006  }
2007  return expressions;
2008 }
2009 
2010 //---------------------------------------------------------------------------------------------------------------------
2011 QVector<VFormulaField> VAbstractPattern::ListPathExpressions() const
2012 {
2013  // Check if new tool doesn't bring new attribute with a formula.
2014  // If no just increment number.
2015  // If new tool bring absolutely new type and has formula(s) create new method to cover it.
2016  Q_STATIC_ASSERT(static_cast<int>(Tool::LAST_ONE_DO_NOT_USE) == 53);
2017 
2018  QVector<VFormulaField> expressions;
2019  const QDomNodeList list = elementsByTagName(TagPath);
2020  for (int i=0; i < list.size(); ++i)
2021  {
2022  const QDomElement dom = list.at(i).toElement();
2023  if (dom.isNull())
2024  {
2025  continue;
2026  }
2027 
2028  expressions << ListNodesExpressions(dom.firstChildElement(TagNodes));
2029  }
2030 
2031  return expressions;
2032 }
2033 
2034 //---------------------------------------------------------------------------------------------------------------------
2035 QVector<VFormulaField> VAbstractPattern::ListGrainlineExpressions(const QDomElement &element) const
2036 {
2037  QVector<VFormulaField> expressions;
2038  if (not element.isNull())
2039  {
2040  // Each tag can contains several attributes.
2041  ReadExpressionAttribute(expressions, element, AttrRotation);
2042  ReadExpressionAttribute(expressions, element, AttrLength);
2043  }
2044 
2045  return expressions;
2046 }
2047 
2048 //---------------------------------------------------------------------------------------------------------------------
2049 QVector<VFormulaField> VAbstractPattern::ListPieceExpressions() const
2050 {
2051  // Check if new tool doesn't bring new attribute with a formula.
2052  // If no just increment number.
2053  // If new tool bring absolutely new type and has formula(s) create new method to cover it.
2054  Q_STATIC_ASSERT(static_cast<int>(Tool::LAST_ONE_DO_NOT_USE) == 53);
2055 
2056  QVector<VFormulaField> expressions;
2057  const QDomNodeList list = elementsByTagName(TagPiece);
2058  for (int i=0; i < list.size(); ++i)
2059  {
2060  const QDomElement dom = list.at(i).toElement();
2061  if (dom.isNull())
2062  {
2063  continue;
2064  }
2065 
2066  // Each tag can contains several attributes.
2067  ReadExpressionAttribute(expressions, dom, AttrWidth);
2068 
2069  expressions << ListNodesExpressions(dom.firstChildElement(TagNodes));
2070  expressions << ListGrainlineExpressions(dom.firstChildElement(TagGrainline));
2071  }
2072 
2073  return expressions;
2074 }
2075 
2076 //---------------------------------------------------------------------------------------------------------------------
2077 bool VAbstractPattern::IsVariable(const QString &token) const
2078 {
2079  for (int i = 0; i < builInVariables.size(); ++i)
2080  {
2081  if (token.indexOf( builInVariables.at(i) ) == 0)
2082  {
2083  if (builInVariables.at(i) == currentLength || builInVariables.at(i) == currentSeamAllowance)
2084  {
2085  return token == builInVariables.at(i);
2086  }
2087  else
2088  {
2089  return true;
2090  }
2091  }
2092  }
2093 
2094  return false;
2095 }
2096 
2097 //---------------------------------------------------------------------------------------------------------------------
2098 bool VAbstractPattern::IsPostfixOperator(const QString &token) const
2099 {
2100  for (int i = 0; i < builInPostfixOperators.size(); ++i)
2101  {
2102  if (token.indexOf( builInPostfixOperators.at(i) ) == 0)
2103  {
2104  return true;
2105  }
2106  }
2107 
2108  return false;
2109 }
2110 
2111 //---------------------------------------------------------------------------------------------------------------------
2112 bool VAbstractPattern::IsFunction(const QString &token) const
2113 {
2114  for (int i = 0; i < builInFunctions.size(); ++i)
2115  {
2116  if (token.indexOf( builInFunctions.at(i) ) == 0)
2117  {
2118  return true;
2119  }
2120  }
2121 
2122  return false;
2123 }
2124 
2125 //---------------------------------------------------------------------------------------------------------------------
2126 QPair<bool, QMap<quint32, quint32> > VAbstractPattern::parseItemElement(const QDomElement &domElement)
2127 {
2128  Q_ASSERT_X(not domElement.isNull(), Q_FUNC_INFO, "domElement is null");
2129 
2130  try
2131  {
2132  const bool visible = getParameterBool(domElement, AttrVisible, trueStr);
2133 
2134  QMap<quint32, quint32> items;
2135 
2136  const QDomNodeList nodeList = domElement.childNodes();
2137  const qint32 num = nodeList.size();
2138  for (qint32 i = 0; i < num; ++i)
2139  {
2140  const QDomElement element = nodeList.at(i).toElement();
2141  if (not element.isNull() && element.tagName() == TagGroupItem)
2142  {
2143  const quint32 object = GetParametrUInt(element, AttrObject, NULL_ID_STR);
2144  const quint32 tool = GetParametrUInt(element, AttrTool, NULL_ID_STR);
2145  items.insert(object, tool);
2146  }
2147  }
2148 
2149  QPair<bool, QMap<quint32, quint32> > group;
2150  group.first = visible;
2151  group.second = items;
2152 
2153  return group;
2154  }
2155  catch (const VExceptionBadId &e)
2156  {
2157  VExceptionObjectError excep(tr("Error creating or updating group"), domElement);
2158  excep.AddMoreInformation(e.ErrorMessage());
2159  throw excep;
2160  }
2161 }
2162 
2163 //---------------------------------------------------------------------------------------------------------------------
2164 /*
2165  * @brief IsModified state of the document for cases that do not cover QUndoStack.
2166  * @return true if the document was modified without using QUndoStack.
2167  */
2168 bool VAbstractPattern::IsModified() const
2169 {
2170  return modified;
2171 }
2172 
2173 //---------------------------------------------------------------------------------------------------------------------
2174 void VAbstractPattern::SetModified(bool modified)
2175 {
2176  this->modified = modified;
2177 }
2178 
2179 //---------------------------------------------------------------------------------------------------------------------
2180 QDomElement VAbstractPattern::createGroups()
2181 {
2182  QDomElement draftBlock;
2183  if (getActiveDraftElement(draftBlock))
2184  {
2185  QDomElement groups = draftBlock.firstChildElement(TagGroups);
2186 
2187  if (groups.isNull())
2188  {
2189  groups = createElement(TagGroups);
2190  draftBlock.appendChild(groups);
2191  }
2192 
2193  return groups;
2194  }
2195  return QDomElement();
2196 }
2197 
2198 //---------------------------------------------------------------------------------------------------------------------
2199 QDomElement VAbstractPattern::createGroup(quint32 groupId, const QString &name, const QString &color, const QString &type,
2200  const QString &weight, const QMap<quint32, quint32> &groupData)
2201 {
2202  if (groupId == NULL_ID)
2203  {
2204  return QDomElement();
2205  }
2206 
2207  //Create new empty group
2208  QDomElement group = createElement(TagGroup);
2209  SetAttribute(group, AttrId, groupId);
2210  SetAttribute(group, AttrName, name);
2211  SetAttribute(group, AttrVisible, true);
2212  SetAttribute(group, AttrGroupLocked, false);
2213  SetAttribute(group, AttrGroupColor, color);
2214  SetAttribute(group, AttrLineType, type);
2215  SetAttribute(group, AttrLineWeight, weight);
2216 
2217  //Add objects to group
2218  if (!groupData.isEmpty())
2219  {
2220  auto i = groupData.constBegin();
2221  while (i != groupData.constEnd())
2222  {
2223  QDomElement item = createElement(TagGroupItem);
2224  item.setAttribute(AttrObject, i.key());
2225  item.setAttribute(AttrTool, i.value());
2226  group.appendChild(item);
2227  ++i;
2228  }
2229  return group;
2230  }
2231  else
2232  {
2233  return group;
2234  }
2235 }
2236 
2237 QDomElement VAbstractPattern::addGroupItems(const QString &name, const QMap<quint32, quint32> &groupData)
2238 {
2239  quint32 groupId = getGroupIdByName(name);
2240  const bool locked = getGroupLock(groupId);
2241  if (locked)
2242  {
2243  return QDomElement();
2244  }
2245 
2246  QDomElement group = getGroupByName(name);
2247 
2248  if (! getParameterBool(group, AttrGroupLocked, trueStr))
2249  {
2250  if (!groupData.isEmpty())
2251  {
2252  auto i = groupData.constBegin();
2253  while (i != groupData.constEnd())
2254  {
2255  QDomElement item = createElement(TagGroupItem);
2256  item.setAttribute(AttrObject, i.key());
2257  item.setAttribute(AttrTool, i.value());
2258  group.appendChild(item);
2259  ++i;
2260  }
2261  modified = true;
2262  emit patternChanged(false);
2263 
2264  emit updateGroups();
2265  }
2266  }
2267  return group;
2268 }
2269 
2270 //---------------------------------------------------------------------------------------------------------------------
2271 QString VAbstractPattern::getGroupName(quint32 id)
2272 {
2273  QString name = tr("New group");
2274  QDomElement groups = createGroups();
2275  if (not groups.isNull())
2276  {
2277  QDomElement group = elementById(id, TagGroup);
2278  if (group.isElement())
2279  {
2280  name = GetParametrString(group, AttrName, name);
2281  return name;
2282  }
2283  else
2284  {
2285  if (groups.childNodes().isEmpty())
2286  {
2287  QDomNode parent = groups.parentNode();
2288  parent.removeChild(groups);
2289  }
2290 
2291  qDebug("Can't get group by id = %u.", id);
2292  return name;
2293  }
2294  }
2295  else
2296  {
2297  qDebug("Can't get tag Groups.");
2298  return name;
2299  }
2300 }
2301 
2302 //---------------------------------------------------------------------------------------------------------------------
2303 void VAbstractPattern::setGroupName(quint32 id, const QString &name)
2304 {
2305  QDomElement groups = createGroups();
2306  if (not groups.isNull())
2307  {
2308  QDomElement group = elementById(id, TagGroup);
2309  if (group.isElement())
2310  {
2311  group.setAttribute(AttrName, name);
2312  modified = true;
2313  emit patternChanged(false);
2314  }
2315  else
2316  {
2317  if (groups.childNodes().isEmpty())
2318  {
2319  QDomNode parent = groups.parentNode();
2320  parent.removeChild(groups);
2321  }
2322 
2323  qDebug("Can't get group by id = %u.", id);
2324  }
2325  }
2326  else
2327  {
2328  qDebug("Can't get tag Groups.");
2329  }
2330 }
2331 
2332 //---------------------------------------------------------------------------------------------------------------------
2333 QMap<quint32, GroupAttributes> VAbstractPattern::getGroups()
2334 {
2335  GroupAttributes groupData;
2336  QMap<quint32, GroupAttributes> data;
2337 
2338  try
2339  {
2340  QDomElement groups = createGroups();
2341  if (not groups.isNull())
2342  {
2343  QDomNode domNode = groups.firstChild();
2344  while (domNode.isNull() == false)
2345  {
2346  if (domNode.isElement())
2347  {
2348  const QDomElement group = domNode.toElement();
2349  if (group.isNull() == false)
2350  {
2351  if (group.tagName() == TagGroup)
2352  {
2353  const quint32 id = GetParametrUInt(group, AttrId, "0");
2354  const QString name = GetParametrString(group, AttrName, tr("New group 2"));
2355  const bool visible = getParameterBool(group, AttrVisible, trueStr);
2356  const bool locked = getParameterBool(group, AttrGroupLocked, trueStr);
2357  const QString color = GetParametrString(group, AttrGroupColor, ColorBlack);
2358  const QString linetype = GetParametrString(group, AttrLineType, LineTypeSolidLine);
2359  const QString lineweight = GetParametrString(group, AttrLineWeight, "0.35");
2360 
2361  groupData.name = name;
2362  groupData.visible = visible;
2363  groupData.locked = locked;
2364  groupData.color = color;
2365  groupData.linetype = linetype;
2366  groupData.lineweight = lineweight;
2367  data.insert(id, groupData);
2368  }
2369  }
2370  }
2371  domNode = domNode.nextSibling();
2372  }
2373  emit patternHasGroups(true);
2374  }
2375  else
2376  {
2377  emit patternHasGroups(false);
2378  qDebug("Can't get tag Groups.");
2379  }
2380  }
2381  catch (const VExceptionConversionError &)
2382  {
2383  return QMap<quint32, GroupAttributes>();
2384  }
2385 
2386  return data;
2387 }
2388 
2389 
2390 /*---------------------------------------------------------------------------------------------------------------------
2391  * @brief Gets List of Groups for the current Draft Block
2392  *
2393  * @return AttrName - Group Name.
2394  * @throw VExceptionConversionError if group error.
2395  */
2396 
2397 QStringList VAbstractPattern::groupListByName()
2398 {
2399  QStringList groupList;
2400  try
2401  {
2402  QDomElement groups = createGroups();
2403  if (not groups.isNull())
2404  {
2405  QDomNode domNode = groups.firstChild();
2406  if (domNode.isNull() == false)
2407  {
2408  while (domNode.isNull() == false)
2409  {
2410  if (domNode.isElement())
2411  {
2412  const QDomElement group = domNode.toElement();
2413  if (group.isNull() == false)
2414  {
2415  if (group.tagName() == TagGroup)
2416  {
2417 
2418  groupList << GetParametrString(group, AttrName);
2419  }
2420  }
2421  }
2422  domNode = domNode.nextSibling();
2423  }
2424  emit patternHasGroups(true);
2425  }
2426  else
2427  {
2428  emit patternHasGroups(false);
2429  qDebug("Can't get tag Groups.");
2430  }
2431  }
2432 
2433  }
2434  catch (const VExceptionConversionError &)
2435  {
2436  return groupList;
2437  }
2438 
2439  return groupList;
2440 }
2441 
2442 /*---------------------------------------------------------------------------------------------------------------------
2443  * @brief Gets Dom Element for a given group name.
2444  *
2445  * @return group - group Dom Element.
2446  */
2447 QDomElement VAbstractPattern::getGroupByName(const QString &name)
2448 {
2449 
2450  QDomElement groups = createGroups();
2451  if (not groups.isNull())
2452  {
2453  QDomNode domNode = groups.firstChild();
2454  if (domNode.isNull() == false)
2455  {
2456  while (domNode.isNull() == false)
2457  {
2458  if (domNode.isElement())
2459  {
2460  const QDomElement group = domNode.toElement();
2461  if (group.isNull() == false)
2462  {
2463  if (group.tagName() == TagGroup)
2464  {
2465  const QString groupName = GetParametrString(group, AttrName);
2466  if (groupName == name)
2467  {
2468  return group;
2469  }
2470  }
2471  }
2472  }
2473  domNode = domNode.nextSibling();
2474  }
2475  emit patternHasGroups(true);
2476  }
2477  else
2478  {
2479  emit patternHasGroups(false);
2480  qDebug("Can't get tag Groups.");
2481  }
2482  }
2483  return groups;
2484 }
2485 
2486 /*---------------------------------------------------------------------------------------------------------------------
2487  * @brief Gets groupId for a given group name.
2488  *
2489  * @return groupId - group Id.
2490  */
2491 quint32 VAbstractPattern::getGroupIdByName(const QString &name)
2492 {
2493 
2494  QDomElement groups = createGroups();
2495  if (not groups.isNull())
2496  {
2497  QDomNode domNode = groups.firstChild();
2498  if (domNode.isNull() == false)
2499  {
2500  while (domNode.isNull() == false)
2501  {
2502  if (domNode.isElement())
2503  {
2504  const QDomElement group = domNode.toElement();
2505  if (group.isNull() == false)
2506  {
2507  if (group.tagName() == TagGroup)
2508  {
2509  const QString groupName = GetParametrString(group, AttrName);
2510  if (groupName == name)
2511  {
2512  const quint32 groupId = GetParametrUInt(group, AttrId, "0");
2513  return groupId;
2514  }
2515  }
2516  }
2517  }
2518  domNode = domNode.nextSibling();
2519  }
2520  }
2521  else
2522  {
2523  qDebug("Can't get tag Groups.");
2524  }
2525  }
2526  return quint32();
2527 }
2528 
2529 //---------------------------------------------------------------------------------------------------------------------
2530 /**
2531  * @brief Returns the groups that contain or do not contain the item identified by the toolid and the objectid
2532  * @param toolId
2533  * @param objectId
2534  * @param containsItem |true if the groups contain the given item, false if they don't contain the item
2535  * @return
2536  */
2537 QMap<quint32, QString> VAbstractPattern::getGroupsContainingItem(quint32 toolId, quint32 objectId, bool containsItem)
2538 {
2539  QMap<quint32, QString> data;
2540 
2541  if(objectId == 0)
2542  {
2543  objectId = toolId;
2544  }
2545 
2546  QDomElement groups = createGroups();
2547  if (not groups.isNull())
2548  {
2549  QDomNode domNode = groups.firstChild();
2550  while (domNode.isNull() == false) // iterate through the groups
2551  {
2552  if (domNode.isElement())
2553  {
2554  const QDomElement group = domNode.toElement();
2555  if (group.isNull() == false)
2556  {
2557  if (group.tagName() == TagGroup)
2558  {
2559  bool groupHasItem = hasGroupItem(group, toolId, objectId);
2560  if((containsItem && groupHasItem) || (not containsItem && not groupHasItem))
2561  {
2562  const quint32 groupId = GetParametrUInt(group, AttrId, "0");
2563  const QString name = GetParametrString(group, AttrName, tr("New group"));
2564  data.insert(groupId, name);
2565  }
2566  }
2567  }
2568  }
2569  domNode = domNode.nextSibling();
2570  }
2571  }
2572  else
2573  {
2574  qDebug("Can't get tag Groups.");
2575  }
2576 
2577  return data;
2578 }
2579 //---------------------------------------------------------------------------------------------------------------------
2580 /**
2581  * @brief Checks if the given group has the item with the given toolId and objectId
2582  * @param groupDomElement
2583  * @param toolId
2584  * @param objectId
2585  * @return
2586  */
2587 bool VAbstractPattern::hasGroupItem(const QDomElement &groupDomElement, quint32 toolId, quint32 objectId)
2588 {
2589  bool result = false;
2590 
2591  QDomNode itemNode = groupDomElement.firstChild();
2592  while (itemNode.isNull() == false) // iterate through the items of the group
2593  {
2594  if (itemNode.isElement())
2595  {
2596  const QDomElement item = itemNode.toElement();
2597  if (item.isNull() == false)
2598  {
2599  quint32 toolIdIterate= GetParametrUInt(item, AttrTool, "0");
2600  quint32 objectIdIterate= GetParametrUInt(item, AttrObject, "0");
2601 
2602  if(toolIdIterate == toolId && objectIdIterate == objectId)
2603  {
2604  result = true;
2605  break;
2606  }
2607  }
2608  }
2609  itemNode = itemNode.nextSibling();
2610  }
2611  return result;
2612 }
2613 
2614 /**
2615  * @brief Deletes an item from the group containing the toolId
2616  * @param toolId
2617  */
2618 void VAbstractPattern::deleteToolFromGroup(quint32 toolId)
2619 {
2620  QMap<quint32,QString> groupsContainingItem = getGroupsContainingItem(toolId, 0, true);
2621  QStringList list = QStringList(groupsContainingItem.values());
2622  QString listGroupName = list.value(0);
2623  quint32 groupId = groupsContainingItem.key(listGroupName);
2624 
2625  const bool locked = getGroupLock(groupId);
2626  if (locked)
2627  {
2628  return;
2629  }
2630 
2631  QDomElement group = removeGroupItem(toolId, 0, groupId);
2632 }
2633 
2634 /**
2635  * @brief Adds an item to the given group with the given toolId and objectId
2636  * @param toolId
2637  */
2638 void VAbstractPattern::addToolToGroup(quint32 toolId, quint32 objectId, const QString &groupName)
2639 {
2640  quint32 groupId = getGroupIdByName(groupName);
2641  const bool locked = getGroupLock(groupId);
2642  if (locked)
2643  {
2644  return;
2645  }
2646 
2647  //Delete tool if contained in an existing group
2648  QMap<quint32,QString> groupsContainingItem = getGroupsContainingItem(toolId, objectId, true);
2649  QStringList list = QStringList(groupsContainingItem.values());
2650  QString listGroupName = list.value(0);
2651  groupId = groupsContainingItem.key(listGroupName);
2652 
2653  QDomElement group = removeGroupItem(toolId, objectId, groupId);
2654 
2655  //Add to new Group.
2656  QMap<quint32,QString> groupsNotContainingItem = getGroupsContainingItem(toolId, objectId, false);
2657  list = QStringList(groupsNotContainingItem.values());
2658 
2659  for(int i=0; i<list.count(); ++i)
2660  {
2661  const QString listGroupName = list.value(i);
2662  if (groupName == listGroupName)
2663  {
2664  const quint32 groupId = groupsNotContainingItem.key(list[i]);
2665  QDomElement group = addGroupItem(toolId, objectId, groupId);
2666  modified = true;
2667  emit patternChanged(false);
2668  emit updateGroups();
2669  QDomElement groups = createGroups();
2670  if (not groups.isNull())
2671  {
2672  parseGroups(groups);
2673  }
2674  break;
2675  }
2676  }
2677 
2678 }
2679 
2680 //---------------------------------------------------------------------------------------------------------------------
2681 /**
2682  * @brief Adds an item to the given group with the given toolId and objectId
2683  * @param toolId
2684  * @param objectId
2685  * @param groupId
2686  */
2687 QDomElement VAbstractPattern::addGroupItem(quint32 toolId, quint32 objectId, quint32 groupId)
2688 {
2689 
2690  const bool locked = getGroupLock(groupId);
2691  if (locked)
2692  {
2693  return QDomElement();
2694  }
2695 
2696  QDomElement group = elementById(groupId, TagGroup);
2697 
2698  if (!group.isNull())
2699  {
2700  if(objectId == 0)
2701  {
2702  objectId = toolId;
2703  }
2704 
2705  QDomElement item = createElement(TagGroupItem);
2706  item.setAttribute(AttrTool, toolId);
2707  item.setAttribute(AttrObject, objectId);
2708  group.appendChild(item);
2709 
2710  modified = true;
2711  emit patternChanged(false);
2712 
2713  emit updateGroups();
2714 
2715  QDomElement groups = createGroups();
2716  if (not groups.isNull())
2717  {
2718  parseGroups(groups);
2719  }
2720 
2721  return item;
2722  }
2723  else
2724  {
2725  qDebug() << "The group of id " << groupId << " doesn't exist";
2726  }
2727 
2728  return QDomElement();
2729 }
2730 
2731 //---------------------------------------------------------------------------------------------------------------------
2732 /**
2733  * @brief Removes the item of given toolId and objectId from the group of given groupId
2734  * @param toolId
2735  * @param objectId
2736  * @param groupId
2737  */
2738 QDomElement VAbstractPattern::removeGroupItem(quint32 toolId, quint32 objectId, quint32 groupId)
2739 {
2740  QDomElement group = elementById(groupId, TagGroup);
2741 
2742  const bool locked = getGroupLock(groupId);
2743  if (locked)
2744  {
2745  return QDomElement();
2746  }
2747 
2748  if (!group.isNull())
2749  {
2750  if(objectId == 0)
2751  {
2752  objectId = toolId;
2753  }
2754 
2755  QDomNode itemNode = group.firstChild();
2756  while (itemNode.isNull() == false) // iterate through the items of the group
2757  {
2758  if (itemNode.isElement())
2759  {
2760  const QDomElement item = itemNode.toElement();
2761  if (item.isNull() == false)
2762  {
2763  quint32 toolIdIterate= GetParametrUInt(item, AttrTool, "0");
2764  quint32 objectIdIterate= GetParametrUInt(item, AttrObject, "0");
2765 
2766  if(toolIdIterate == toolId && objectIdIterate == objectId)
2767  {
2768  group.removeChild(itemNode);
2769 
2770  // to signalised that the pattern was changed and need to be saved
2771  modified = true;
2772  emit patternChanged(false);
2773 
2774  // to update the group table of the gui
2775  emit updateGroups();
2776 
2777  // parse the groups to update the drawing, in case the item was removed from an invisible group
2778  QDomElement groups = createGroups();
2779  if (not groups.isNull())
2780  {
2781  parseGroups(groups);
2782  }
2783 
2784  return item;
2785  }
2786  }
2787  }
2788  itemNode = itemNode.nextSibling();
2789  }
2790  }
2791  else
2792  {
2793  qDebug() << "The group of id " << groupId << " doesn't exist";
2794  }
2795 
2796  return QDomElement();
2797 }
2798 
2799 //---------------------------------------------------------------------------------------------------------------------
2800 /**
2801  * @brief Returns true if the given group is empty
2802  * @param id
2803  * @return
2804  */
2805 bool VAbstractPattern::isGroupEmpty(quint32 id)
2806 {
2807  QDomElement group = elementById(id, TagGroup);
2808 
2809  if (group.isNull() == false)
2810  {
2811  return not group.hasChildNodes();
2812  }
2813  else
2814  {
2815  qDebug() << "The group of id " << id << " doesn't exist";
2816  return true;
2817  }
2818 }
2819 
2820 //---------------------------------------------------------------------------------------------------------------------
2821 bool VAbstractPattern::getGroupVisibility(quint32 id)
2822 {
2823  QDomElement group = elementById(id, TagGroup);
2824  if (group.isElement())
2825  {
2826  return getParameterBool(group, AttrVisible, trueStr);
2827  }
2828  else
2829  {
2830  qDebug("Can't get group by id = %u.", id);
2831  return true;
2832  }
2833 }
2834 
2835 //---------------------------------------------------------------------------------------------------------------------
2836 void VAbstractPattern::setGroupVisibility(quint32 id, bool visible)
2837 {
2838  QDomElement group = elementById(id, TagGroup);
2839  if (group.isElement())
2840  {
2841  SetAttribute(group, AttrVisible, visible);
2842  modified = true;
2843  emit patternChanged(false);
2844 
2845  QDomElement groups = createGroups();
2846  if (not groups.isNull())
2847  {
2848  parseGroups(groups);
2849  }
2850  }
2851  else
2852  {
2853  qDebug("Can't get group by id = %u.", id);
2854  }
2855 }
2856 
2857 
2858 /*---------------------------------------------------------------------------------------------------------------------
2859  * @brief Gets whether a Group is locked or not
2860  * @param id - Tool Id.
2861  * @return AttrGroupLocked - True if locked False if unlocked.
2862  * @return True if can't find group by id.
2863 */
2864 
2865 bool VAbstractPattern::getGroupLock(quint32 id)
2866 {
2867  QDomElement group = elementById(id, TagGroup);
2868  if (group.isElement())
2869  {
2870  return getParameterBool(group, AttrGroupLocked, trueStr);
2871  }
2872  else
2873  {
2874  qDebug("Can't get group by id = %u.", id);
2875  return true;
2876  }
2877 }
2878 
2879 //---------------------------------------------------------------------------------------------------------------------
2880 void VAbstractPattern::setGroupLock(quint32 id, bool locked)
2881 {
2882  QDomElement group = elementById(id, TagGroup);
2883  if (group.isElement())
2884  {
2885  SetAttribute(group, AttrGroupLocked, locked);
2886  modified = true;
2887  emit patternChanged(false);
2888  //qDebug("VAbstractPattern::setGroupLock - Group %u is locked.", id);
2889 
2890  QDomElement groups = createGroups();
2891  if (not groups.isNull())
2892  {
2893  parseGroups(groups);
2894  }
2895  }
2896  else
2897  {
2898  qDebug("Can't get group by id = %u.", id);
2899  }
2900 }
2901 
2902 /*---------------------------------------------------------------------------------------------------------------------
2903  * @brief Gets the Group color
2904  * @param id - Tool Id.
2905  * @return AttrGroupColor - Color of the group.
2906  * @return color - group color.
2907 */
2908 
2909 QString VAbstractPattern::getGroupColor(quint32 id)
2910 {
2911  QDomElement group = elementById(id, TagGroup);
2912  QString color;
2913  if (group.isElement())
2914  {
2915 
2916  color = GetParametrString(group, AttrGroupColor, ColorBlack);
2917  return color;
2918  }
2919  else
2920  {
2921  qDebug("Can't get group by id = %u.", id);
2922  return ColorBlack;
2923  }
2924 }
2925 
2926 //---------------------------------------------------------------------------------------------------------------------
2927 void VAbstractPattern::setGroupColor(quint32 id, QString color)
2928 {
2929  QDomElement group = elementById(id, TagGroup);
2930  if (group.isElement())
2931  {
2932  SetAttribute(group, AttrGroupColor, color);
2933  modified = true;
2934  emit patternChanged(false);
2935  }
2936  else
2937  {
2938  qDebug("Can't get group by id = %u.", id);
2939  }
2940 }
2941 
2942 /*---------------------------------------------------------------------------------------------------------------------
2943  * @brief Gets the Group Line Type
2944  * @param id - Tool Id.
2945  * @return AttrLineType - Line type of the group.
2946  * @return type - group line type.
2947 */
2948 
2949 QString VAbstractPattern::getGroupLineType(quint32 id)
2950 {
2951  QDomElement group = elementById(id, TagGroup);
2952  QString type;
2953  if (group.isElement())
2954  {
2955 
2956  type = GetParametrString(group, AttrLineType, LineTypeSolidLine);
2957  return type;
2958  }
2959  else
2960  {
2961  qDebug("Can't get group by id = %u.", id);
2962  return LineTypeSolidLine;
2963  }
2964 }
2965 
2966 //---------------------------------------------------------------------------------------------------------------------
2967 void VAbstractPattern::setGroupLineType(quint32 id, QString type)
2968 {
2969  QDomElement group = elementById(id, TagGroup);
2970  if (group.isElement())
2971  {
2972  SetAttribute(group, AttrLineType, type);
2973  modified = true;
2974  emit patternChanged(false);
2975  }
2976  else
2977  {
2978  qDebug("Can't get group by id = %u.", id);
2979  }
2980 }
2981 
2982 /*---------------------------------------------------------------------------------------------------------------------
2983  * @brief Gets the Group Line Weight
2984  * @param id - Tool Id.
2985  * @return AttrLineWeight - Linw weight of the group.
2986  * @return weight - group line weight.
2987 */
2988 
2989 QString VAbstractPattern::getGroupLineWeight(quint32 id)
2990 {
2991  QDomElement group = elementById(id, TagGroup);
2992  QString weight;
2993  if (group.isElement())
2994  {
2995 
2996  weight = GetParametrString(group, AttrLineWeight, "0.35");
2997  return weight;
2998  }
2999  else
3000  {
3001  qDebug("Can't get group by id = %u.", id);
3002  return ColorBlack;
3003  }
3004 }
3005 
3006 //---------------------------------------------------------------------------------------------------------------------
3007 void VAbstractPattern::setGroupLineWeight(quint32 id, QString weight)
3008 {
3009  QDomElement group = elementById(id, TagGroup);
3010  if (group.isElement())
3011  {
3012  SetAttribute(group, AttrLineWeight, weight);
3013  modified = true;
3014  emit patternChanged(false);
3015  }
3016  else
3017  {
3018  qDebug("Can't get group by id = %u.", id);
3019  }
3020 }
3021 
3022 /*---------------------------------------------------------------------------------------------------------------------
3023  * @brief Gets whether a group name already exists
3024  * @param groupName - group name.
3025  * @return exists - True id name exists False if it does not.
3026 */
3027 bool VAbstractPattern::groupNameExists(const QString &groupName)
3028 {
3029  QStringList groupList = groupListByName();
3030  bool exists = groupList.contains(groupName, Qt::CaseInsensitive);
3031  return exists;
3032 }
3033 
3034 QString VAbstractPattern::useGroupColor(quint32 toolId, QString color)
3035 {
3036  QMap<quint32,QString> groupsContainingItem = getGroupsContainingItem(toolId, 0, true);
3037  QStringList list = QStringList(groupsContainingItem.values());
3038  QString groupName = list.value(0);
3039 
3040  //qCDebug(vbstractPattern,"VAbstractPattern::useGroupColor - Group Name = %s",qUtf8Printable(groupName));
3041  //qCDebug(vbstractPattern,"VAbstractPattern::useGroupColor - Tool ID = %d",toolId);
3042  //qCDebug(vbstractPattern,"VAbstractPattern::useGroupColor - Tool Color = %s",qUtf8Printable(color));
3043  quint32 objectId = toolId;
3044  bool groupHasItem = hasGroupItem(getGroupByName(groupName), toolId, objectId);
3045  //qCDebug(vbstractPattern,"VAbstractPattern::useGroupColor - Group has item = %d",groupHasItem);
3046  if ((color == ColorByGroup) && groupHasItem)
3047  {
3048  QString groupColor = getGroupColor(getGroupIdByName(groupName));
3049  //qCDebug(vbstractPattern,"VAbstractPattern::useGroupColor - Group Color = %s",qUtf8Printable(groupColor));
3050  return groupColor;
3051  }
3052  else
3053  {
3054  return color;
3055  }
3056 }
3057 
3058 QString VAbstractPattern::useGroupLineType(quint32 toolId, QString type)
3059 {
3060  QMap<quint32,QString> groupsContainingItem = getGroupsContainingItem(toolId, 0, true);
3061  QStringList list = QStringList(groupsContainingItem.values());
3062  QString groupName = list.value(0);
3063 
3064  //qCDebug(vbstractPattern,"VAbstractPattern::useGroupLineType - Group Name = %s",qUtf8Printable(groupName));
3065  //qCDebug(vbstractPattern,"VAbstractPattern::useGroupLineType - Tool ID = %d",toolId);
3066  //qCDebug(vbstractPattern,"VAbstractPattern::useGroupLineType - Tool Color = %s",qUtf8Printable(type));
3067  quint32 objectId = toolId;
3068  bool groupHasItem = hasGroupItem(getGroupByName(groupName), toolId, objectId);
3069  //qCDebug(vbstractPattern,"VAbstractPattern::useGroupLineType - Group has item = %d",groupHasItem);
3070  if ((type == LineTypeByGroup) && groupHasItem)
3071  {
3072  QString groupLineType = getGroupLineType(getGroupIdByName(groupName));
3073  //qCDebug(vbstractPattern,"VAbstractPattern::useGroupLineType - Group Linetpe = %s",qUtf8Printable(groupLineType));
3074  return groupLineType;
3075  }
3076  else
3077  {
3078  return type;
3079  }
3080 }
3081 
3082 QString VAbstractPattern::useGroupLineWeight(quint32 toolId, QString weight)
3083 {
3084  QMap<quint32,QString> groupsContainingItem = getGroupsContainingItem(toolId, 0, true);
3085  QStringList list = QStringList(groupsContainingItem.values());
3086  QString groupName = list.value(0);
3087 
3088  quint32 objectId = toolId;
3089  bool groupHasItem = hasGroupItem(getGroupByName(groupName), toolId, objectId);
3090  if ((weight == LineWeightByGroup) && groupHasItem)
3091  {
3092  QString groupLineWeight = getGroupLineWeight(getGroupIdByName(groupName));
3093  return groupLineWeight;
3094  }
3095  else
3096  {
3097  return weight;
3098  }
3099 }
Pen
Definition: pen.h:37
Pen::color
QString color
Definition: pen_toolbar.h:51
Pen::lineWeight
qreal lineWeight
Definition: pen_toolbar.h:52
Pen::lineType
QString lineType
Definition: pen_toolbar.h:53
VAbstractPattern::AttrTimeFormat
static const QString AttrTimeFormat
Definition: vabstractpattern.h:326
VAbstractPattern::setGroupLock
void setGroupLock(quint32 id, bool locked)
Definition: vabstractpattern.cpp:2880
VAbstractPattern::SetPatternNumber
void SetPatternNumber(const QString &qsNum)
Definition: vabstractpattern.cpp:1406
VAbstractPattern::updatePieceList
void updatePieceList(quint32 id)
Definition: vabstractpattern.cpp:1657
VAbstractPattern::AttrS28
static const QString AttrS28
Definition: vabstractpattern.h:380
VAbstractPattern::TagNode
static const QString TagNode
Definition: vabstractpattern.h:307
VAbstractPattern::SetGradationHeights
void SetGradationHeights(const QMap< GHeights, bool > &options)
Definition: vabstractpattern.cpp:1048
VAbstractPattern::AttrLetter
static const QString AttrLetter
Definition: vabstractpattern.h:317
VAbstractPattern::AttrObject
static const QString AttrObject
Definition: vabstractpattern.h:314
VAbstractPattern::getGroupLock
bool getGroupLock(quint32 id)
Definition: vabstractpattern.cpp:2865
VAbstractPattern::AttrEnd
static const QString AttrEnd
Definition: vabstractpattern.h:343
VAbstractPattern::AttrS66
static const QString AttrS66
Definition: vabstractpattern.h:399
VAbstractPattern::IsFunction
bool IsFunction(const QString &token) const
Definition: vabstractpattern.cpp:2112
VAbstractPattern::SetImage
void SetImage(const QString &text, const QString &extension)
Definition: vabstractpattern.cpp:1554
VAbstractPattern::TagData
static const QString TagData
Definition: vabstractpattern.h:297
VAbstractPattern::setGroupColor
void setGroupColor(quint32 id, QString color)
Definition: vabstractpattern.cpp:2927
VAbstractPattern::getGroups
QMap< quint32, GroupAttributes > getGroups()
Definition: vabstractpattern.cpp:2333
VAbstractPattern::GetPatternWasChanged
bool GetPatternWasChanged() const
Definition: vabstractpattern.cpp:1517
VAbstractPattern::ListArcExpressions
QVector< VFormulaField > ListArcExpressions() const
Definition: vabstractpattern.cpp:1871
VAbstractPattern::TagSpline
static const QString TagSpline
Definition: vabstractpattern.h:289
VAbstractPattern::setGroupLineWeight
void setGroupLineWeight(quint32 id, QString weight)
Definition: vabstractpattern.cpp:3007
VAbstractPattern::deleteToolFromGroup
void deleteToolFromGroup(quint32 toolId)
Deletes an item from the group containing the toolId.
Definition: vabstractpattern.cpp:2618
VAbstractPattern::AddToolOnRemove
void AddToolOnRemove(VDataTool *tool)
Definition: vabstractpattern.cpp:832
VAbstractPattern::VAbstractPattern
VAbstractPattern(QObject *parent=nullptr)
Definition: vabstractpattern.cpp:257
VAbstractPattern::patternLabelLines
static QVector< VLabelTemplateLine > patternLabelLines
patternLabelLines list to speed up reading a template by many pieces.
Definition: vabstractpattern.h:498
VAbstractPattern::GetCompanyName
QString GetCompanyName() const
Definition: vabstractpattern.cpp:1384
VAbstractPattern::AttrS70
static const QString AttrS70
Definition: vabstractpattern.h:401
VAbstractPattern::AttrS60
static const QString AttrS60
Definition: vabstractpattern.h:396
VAbstractPattern::AttrS50
static const QString AttrS50
Definition: vabstractpattern.h:391
VAbstractPattern::draftBlockNameChanged
void draftBlockNameChanged(const QString &oldName, const QString &newName)
draftBlockNameChanged save new name draft block.
VAbstractPattern::AttrS36
static const QString AttrS36
Definition: vabstractpattern.h:384
VAbstractPattern::getPatternLabelTemplate
QVector< VLabelTemplateLine > getPatternLabelTemplate() const
Definition: vabstractpattern.cpp:1494
VAbstractPattern::AttrAnnotation
static const QString AttrAnnotation
Definition: vabstractpattern.h:318
VAbstractPattern::createGroups
QDomElement createGroups()
Definition: vabstractpattern.cpp:2180
VAbstractPattern::AttrS56
static const QString AttrS56
Definition: vabstractpattern.h:394
VAbstractPattern::AttrType
static const QString AttrType
Definition: vabstractpattern.h:316
VAbstractPattern::UpdateInLayoutList
void UpdateInLayoutList(quint32 id)
VAbstractPattern::AttrH50
static const QString AttrH50
Definition: vabstractpattern.h:350
VAbstractPattern::AttrH182
static const QString AttrH182
Definition: vabstractpattern.h:372
VAbstractPattern::AttrS54
static const QString AttrS54
Definition: vabstractpattern.h:393
VAbstractPattern::AttrGroupColor
static const QString AttrGroupColor
Definition: vabstractpattern.h:313
VAbstractPattern::removeGroupItem
QDomElement removeGroupItem(quint32 toolId, quint32 objectId, quint32 groupId)
Removes the item of given toolId and objectId from the group of given groupId.
Definition: vabstractpattern.cpp:2738
VAbstractPattern::AttrH158
static const QString AttrH158
Definition: vabstractpattern.h:368
VAbstractPattern::IsPostfixOperator
bool IsPostfixOperator(const QString &token) const
Definition: vabstractpattern.cpp:2098
VAbstractPattern::getGroupByName
QDomElement getGroupByName(const QString &name)
Definition: vabstractpattern.cpp:2447
VAbstractPattern::groupListByName
QStringList groupListByName()
Definition: vabstractpattern.cpp:2397
VAbstractPattern::AttrTilt
static const QString AttrTilt
Definition: vabstractpattern.h:321
VAbstractPattern::parseItemElement
QPair< bool, QMap< quint32, quint32 > > parseItemElement(const QDomElement &domElement)
Definition: vabstractpattern.cpp:2126
VAbstractPattern::TagPieces
static const QString TagPieces
Definition: vabstractpattern.h:276
VAbstractPattern::isGroupEmpty
bool isGroupEmpty(quint32 id)
Returns true if the given group is empty.
Definition: vabstractpattern.cpp:2805
VAbstractPattern::ChangedCursor
void ChangedCursor(quint32 id)
ChangedCursor change cursor position.
VAbstractPattern::ParsePieceAnchors
static QVector< quint32 > ParsePieceAnchors(const QDomElement &domElement)
Definition: vabstractpattern.cpp:735
VAbstractPattern::NodeArc
static const QString NodeArc
Definition: vabstractpattern.h:413
VAbstractPattern::AttrRotation
static const QString AttrRotation
Definition: vabstractpattern.h:346
VAbstractPattern::GetLabelDateFormat
QString GetLabelDateFormat() const
Definition: vabstractpattern.cpp:1432
VAbstractPattern::getDartItems
QVector< quint32 > getDartItems(const quint32 &toolId)
Definition: vabstractpattern.cpp:1620
VAbstractPattern::AttrNodeNotchType
static const QString AttrNodeNotchType
Definition: vabstractpattern.h:331
VAbstractPattern::TagDescription
static const QString TagDescription
Definition: vabstractpattern.h:278
VAbstractPattern::AttrS34
static const QString AttrS34
Definition: vabstractpattern.h:383
VAbstractPattern::SetModified
void SetModified(bool modified)
Definition: vabstractpattern.cpp:2174
VAbstractPattern::renameDraftBlock
bool renameDraftBlock(const QString &oldName, const QString &newName)
renameDraftBlock change draft block name.
Definition: vabstractpattern.cpp:540
VAbstractPattern::AttrS52
static const QString AttrS52
Definition: vabstractpattern.h:392
VAbstractPattern::AttrFoldPosition
static const QString AttrFoldPosition
Definition: vabstractpattern.h:322
VAbstractPattern::AttrStart
static const QString AttrStart
Definition: vabstractpattern.h:341
VAbstractPattern::draftBlockCount
int draftBlockCount() const
Definition: vabstractpattern.cpp:497
VAbstractPattern::NodePoint
static const QString NodePoint
Definition: vabstractpattern.h:415
VAbstractPattern::AttrCustom
static const QString AttrCustom
Definition: vabstractpattern.h:404
VAbstractPattern::AttrExtension
static const QString AttrExtension
Definition: vabstractpattern.h:407
VAbstractPattern::useGroupColor
QString useGroupColor(quint32 toolId, QString color)
Definition: vabstractpattern.cpp:3034
VAbstractPattern::AttrS26
static const QString AttrS26
Definition: vabstractpattern.h:379
VAbstractPattern::TagMeasurements
static const QString TagMeasurements
Definition: vabstractpattern.h:281
VAbstractPattern::IncrementDescription
static const QString IncrementDescription
Definition: vabstractpattern.h:411
VAbstractPattern::MPath
QString MPath() const
Definition: vabstractpattern.cpp:881
VAbstractPattern::AttrS62
static const QString AttrS62
Definition: vabstractpattern.h:397
VAbstractPattern::AttrAll
static const QString AttrAll
Definition: vabstractpattern.h:348
VAbstractPattern::GetPatternName
QString GetPatternName() const
Definition: vabstractpattern.cpp:1368
VAbstractPattern::GetPatternNumber
QString GetPatternNumber() const
Definition: vabstractpattern.cpp:1400
VAbstractPattern::AttrH134
static const QString AttrH134
Definition: vabstractpattern.h:364
VAbstractPattern::getPatternPieces
QStringList getPatternPieces() const
Definition: vabstractpattern.cpp:943
VAbstractPattern::AttrH68
static const QString AttrH68
Definition: vabstractpattern.h:353
VAbstractPattern::TagModeling
static const QString TagModeling
Definition: vabstractpattern.h:275
VAbstractPattern::SiblingNodeId
quint32 SiblingNodeId(const quint32 &nodeId) const
Definition: vabstractpattern.cpp:901
VAbstractPattern::TagArc
static const QString TagArc
Definition: vabstractpattern.h:290
VAbstractPattern::SetPatternWasChanged
void SetPatternWasChanged(bool changed)
Definition: vabstractpattern.cpp:1511
VAbstractPattern::TagPatternName
static const QString TagPatternName
Definition: vabstractpattern.h:299
VAbstractPattern::activeDraftBlock
QString activeDraftBlock
activeBlockName name current pattern peace.
Definition: vabstractpattern.h:473
VAbstractPattern::draftBlockNameExists
bool draftBlockNameExists(const QString &name) const
draftBlockNameExists check if draft block with this name exists.
Definition: vabstractpattern.cpp:391
VAbstractPattern::GetImageExtension
QString GetImageExtension() const
Definition: vabstractpattern.cpp:1529
VAbstractPattern::getGroupIdByName
quint32 getGroupIdByName(const QString &name)
Definition: vabstractpattern.cpp:2491
VAbstractPattern::setActiveDraftBlock
void setActiveDraftBlock(const QString &name)
setActiveDraftBlock set current draft block.
Definition: vabstractpattern.cpp:1698
VAbstractPattern::AttrH128
static const QString AttrH128
Definition: vabstractpattern.h:363
VAbstractPattern::AttrDefSize
static const QString AttrDefSize
Definition: vabstractpattern.h:406
VAbstractPattern::TagPattern
static const QString TagPattern
Definition: vabstractpattern.h:273
VAbstractPattern::getOpItems
QVector< quint32 > getOpItems(const quint32 &toolId, const QString &itemType)
getOpItems get vector of operation tool obects.
Definition: vabstractpattern.cpp:1592
VAbstractPattern::AttrOnFold
static const QString AttrOnFold
Definition: vabstractpattern.h:324
VAbstractPattern::AttrH140
static const QString AttrH140
Definition: vabstractpattern.h:365
VAbstractPattern::SetPatternName
void SetPatternName(const QString &qsName)
Definition: vabstractpattern.cpp:1374
VAbstractPattern::haveLiteChange
void haveLiteChange()
haveLiteChange we have unsaved change.
Definition: vabstractpattern.cpp:1639
VAbstractPattern::addToolToGroup
void addToolToGroup(quint32 toolId, quint32 objectId, const QString &groupName)
Adds an item to the given group with the given toolId and objectId.
Definition: vabstractpattern.cpp:2638
VAbstractPattern::getDraftBlockElement
QDomElement getDraftBlockElement(const QString &name)
Definition: vabstractpattern.cpp:509
VAbstractPattern::AttrS58
static const QString AttrS58
Definition: vabstractpattern.h:395
VAbstractPattern::AddTool
static void AddTool(quint32 id, VDataTool *tool)
AddTool add tool to list tools.
Definition: vabstractpattern.cpp:661
VAbstractPattern::appendDraftBlock
bool appendDraftBlock(const QString &name)
appendDraftBlock add new draft block.
Definition: vabstractpattern.cpp:585
VAbstractPattern::addGroupItem
QDomElement addGroupItem(quint32 toolId, quint32 objectId, quint32 groupId)
Adds an item to the given group with the given toolId and objectId.
Definition: vabstractpattern.cpp:2687
VAbstractPattern::setPatternLabelTemplate
void setPatternLabelTemplate(const QVector< VLabelTemplateLine > &lines)
Definition: vabstractpattern.cpp:1482
VAbstractPattern::AttrWidth
static const QString AttrWidth
Definition: vabstractpattern.h:345
VAbstractPattern::TagNotes
static const QString TagNotes
Definition: vabstractpattern.h:280
VAbstractPattern::AttrH92
static const QString AttrH92
Definition: vabstractpattern.h:357
VAbstractPattern::activeDraftBlockChanged
void activeDraftBlockChanged(const QString &newName)
activeDraftBlockChanged change active draft block.
VAbstractPattern::TagTools
static const QString TagTools
Definition: vabstractpattern.h:292
VAbstractPattern::getGroupName
QString getGroupName(quint32 id)
Definition: vabstractpattern.cpp:2271
VAbstractPattern::AttrH80
static const QString AttrH80
Definition: vabstractpattern.h:355
VAbstractPattern::patternChanged
void patternChanged(bool saved)
patternChanged emit if we have unsaved change.
VAbstractPattern::TagGroupItem
static const QString TagGroupItem
Definition: vabstractpattern.h:287
VAbstractPattern::ClearMainWindow
void ClearMainWindow()
VAbstractPattern::AttrH86
static const QString AttrH86
Definition: vabstractpattern.h:356
VAbstractPattern::SetCustomerName
void SetCustomerName(const QString &qsName)
Definition: vabstractpattern.cpp:1422
VAbstractPattern::AttrS40
static const QString AttrS40
Definition: vabstractpattern.h:386
VAbstractPattern::GetVersion
QString GetVersion() const
Definition: vabstractpattern.cpp:1573
VAbstractPattern::TagGroup
static const QString TagGroup
Definition: vabstractpattern.h:286
VAbstractPattern::AttrNodeNotchSubType
static const QString AttrNodeNotchSubType
Definition: vabstractpattern.h:332
VAbstractPattern::addGroupItems
QDomElement addGroupItems(const QString &name, const QMap< quint32, quint32 > &groupData)
Definition: vabstractpattern.cpp:2237
VAbstractPattern::AttrH74
static const QString AttrH74
Definition: vabstractpattern.h:354
VAbstractPattern::GetDescription
QString GetDescription() const
Definition: vabstractpattern.cpp:1338
VAbstractPattern::NodeSplinePath
static const QString NodeSplinePath
Definition: vabstractpattern.h:417
VAbstractPattern::AttrPath
static const QString AttrPath
Definition: vabstractpattern.h:342
VAbstractPattern::TagCustomerName
static const QString TagCustomerName
Definition: vabstractpattern.h:302
VAbstractPattern::AttrGroupLocked
static const QString AttrGroupLocked
Definition: vabstractpattern.h:312
VAbstractPattern::AttrH194
static const QString AttrH194
Definition: vabstractpattern.h:374
VAbstractPattern::TagPatternInfo
static const QString TagPatternInfo
Definition: vabstractpattern.h:298
VAbstractPattern::AttrS32
static const QString AttrS32
Definition: vabstractpattern.h:382
VAbstractPattern::createGroup
QDomElement createGroup(quint32 id, const QString &name, const QString &color, const QString &type, const QString &weight, const QMap< quint32, quint32 > &groupData)
Definition: vabstractpattern.cpp:2199
VAbstractPattern::TagHeights
static const QString TagHeights
Definition: vabstractpattern.h:295
VAbstractPattern::AttrH56
static const QString AttrH56
Definition: vabstractpattern.h:351
VAbstractPattern::history
QVector< VToolRecord > history
history history records.
Definition: vabstractpattern.h:487
VAbstractPattern::TagElArc
static const QString TagElArc
Definition: vabstractpattern.h:291
VAbstractPattern::AttrH110
static const QString AttrH110
Definition: vabstractpattern.h:360
VAbstractPattern::ListOperationExpressions
QVector< VFormulaField > ListOperationExpressions() const
Definition: vabstractpattern.cpp:1966
VAbstractPattern::NodeSpline
static const QString NodeSpline
Definition: vabstractpattern.h:416
VAbstractPattern::AttrH146
static const QString AttrH146
Definition: vabstractpattern.h:366
VAbstractPattern::getGroupVisibility
bool getGroupVisibility(quint32 id)
Definition: vabstractpattern.cpp:2821
VAbstractPattern::AttrNodeShowSecondNotch
static const QString AttrNodeShowSecondNotch
Definition: vabstractpattern.h:334
VAbstractPattern::AttrQuantity
static const QString AttrQuantity
Definition: vabstractpattern.h:323
VAbstractPattern::ListGrainlineExpressions
QVector< VFormulaField > ListGrainlineExpressions(const QDomElement &element) const
Definition: vabstractpattern.cpp:2035
VAbstractPattern::AttrS44
static const QString AttrS44
Definition: vabstractpattern.h:388
VAbstractPattern::ListPathPointExpressions
QVector< VFormulaField > ListPathPointExpressions() const
Definition: vabstractpattern.cpp:1928
VAbstractPattern::AttrRotationWay
static const QString AttrRotationWay
Definition: vabstractpattern.h:320
VAbstractPattern::parseGroups
void parseGroups(const QDomElement &domElement)
Definition: vabstractpattern.cpp:445
VAbstractPattern::tools
static QHash< quint32, VDataTool * > tools
tools list with pointer on tools.
Definition: vabstractpattern.h:496
VAbstractPattern::getGroupLineWeight
QString getGroupLineWeight(quint32 id)
Definition: vabstractpattern.cpp:2989
VAbstractPattern::AttrH164
static const QString AttrH164
Definition: vabstractpattern.h:369
VAbstractPattern::GetGradationHeights
QMap< GHeights, bool > GetGradationHeights() const
Definition: vabstractpattern.cpp:949
VAbstractPattern::AttrOrientation
static const QString AttrOrientation
Definition: vabstractpattern.h:319
VAbstractPattern::AttrSAAfter
static const QString AttrSAAfter
Definition: vabstractpattern.h:340
VAbstractPattern::ListElArcExpressions
QVector< VFormulaField > ListElArcExpressions() const
Definition: vabstractpattern.cpp:1895
VAbstractPattern::TagPatternLabel
static const QString TagPatternLabel
Definition: vabstractpattern.h:303
VAbstractPattern::selectedPiece
void selectedPiece(quint32 id)
Definition: vabstractpattern.cpp:1663
VAbstractPattern::AttrTool
static const QString AttrTool
Definition: vabstractpattern.h:315
VAbstractPattern::AttrH188
static const QString AttrH188
Definition: vabstractpattern.h:373
VAbstractPattern::ParsePathNodes
static VPiecePath ParsePathNodes(const QDomElement &domElement)
Definition: vabstractpattern.cpp:1678
VAbstractPattern::getBlockHistory
QVector< VToolRecord > getBlockHistory() const
Definition: vabstractpattern.cpp:849
VAbstractPattern::GetImage
QString GetImage() const
Definition: vabstractpattern.cpp:1523
VAbstractPattern::AttrS46
static const QString AttrS46
Definition: vabstractpattern.h:389
VAbstractPattern::TagLine
static const QString TagLine
Definition: vabstractpattern.h:308
VAbstractPattern::setGroupName
void setGroupName(quint32 id, const QString &name)
Definition: vabstractpattern.cpp:2303
VAbstractPattern::getTool
static VDataTool * getTool(quint32 id)
getTool return tool from tool list.
Definition: vabstractpattern.cpp:649
VAbstractPattern::TagIncrement
static const QString TagIncrement
Definition: vabstractpattern.h:283
VAbstractPattern::AttrNodeNotchLength
static const QString AttrNodeNotchLength
Definition: vabstractpattern.h:335
VAbstractPattern::TagGroups
static const QString TagGroups
Definition: vabstractpattern.h:285
VAbstractPattern::getActiveDraftElement
bool getActiveDraftElement(QDomElement &element) const
getActiveDraftElement return draftBlock element for current draft block.
Definition: vabstractpattern.cpp:359
VAbstractPattern::TagPatternNum
static const QString TagPatternNum
Definition: vabstractpattern.h:300
VAbstractPattern::RemoveTool
static void RemoveTool(quint32 id)
Definition: vabstractpattern.cpp:669
VAbstractPattern::cursor
quint32 cursor
cursor cursor keep id tool after which we will add new tool in file.
Definition: vabstractpattern.h:482
VAbstractPattern::setDefaultPen
void setDefaultPen(Pen pen)
Definition: vabstractpattern.cpp:618
VAbstractPattern::AttrNodeNotchCount
static const QString AttrNodeNotchCount
Definition: vabstractpattern.h:338
VAbstractPattern::AttrSABefore
static const QString AttrSABefore
Definition: vabstractpattern.h:339
VAbstractPattern::AttrH98
static const QString AttrH98
Definition: vabstractpattern.h:358
VAbstractPattern::ParseSANode
static VPieceNode ParseSANode(const QDomElement &domElement)
Definition: vabstractpattern.cpp:755
VAbstractPattern::AttrArrows
static const QString AttrArrows
Definition: vabstractpattern.h:327
VAbstractPattern::AttrS22
static const QString AttrS22
Definition: vabstractpattern.h:377
VAbstractPattern::AttrS38
static const QString AttrS38
Definition: vabstractpattern.h:385
VAbstractPattern::AttrH62
static const QString AttrH62
Definition: vabstractpattern.h:352
VAbstractPattern::ListMeasurements
QStringList ListMeasurements() const
Definition: vabstractpattern.cpp:273
VAbstractPattern::TagDraftBlock
static const QString TagDraftBlock
Definition: vabstractpattern.h:284
VAbstractPattern::ParsePieceCSARecords
static QVector< CustomSARecord > ParsePieceCSARecords(const QDomElement &domElement)
Definition: vabstractpattern.cpp:691
VAbstractPattern::GetCustomerName
QString GetCustomerName() const
Definition: vabstractpattern.cpp:1416
VAbstractPattern::ListIncrements
QStringList ListIncrements() const
Definition: vabstractpattern.cpp:1803
VAbstractPattern::setGroupLineType
void setGroupLineType(quint32 id, QString type)
Definition: vabstractpattern.cpp:2967
VAbstractPattern::GetGradationSizes
QMap< GSizes, bool > GetGradationSizes() const
Definition: vabstractpattern.cpp:1144
VAbstractPattern::getGroupLineType
QString getGroupLineType(quint32 id)
Definition: vabstractpattern.cpp:2949
VAbstractPattern::ParsePieceNodes
static VPiecePath ParsePieceNodes(const QDomElement &domElement)
Definition: vabstractpattern.cpp:675
VAbstractPattern::IsVariable
bool IsVariable(const QString &token) const
Definition: vabstractpattern.cpp:2077
VAbstractPattern::IncrementName
static const QString IncrementName
Definition: vabstractpattern.h:409
VAbstractPattern::NodeElArc
static const QString NodeElArc
Definition: vabstractpattern.h:414
VAbstractPattern::InsertTag
void InsertTag(const QStringList &tags, const QDomElement &element)
Definition: vabstractpattern.cpp:1765
VAbstractPattern::AttrS30
static const QString AttrS30
Definition: vabstractpattern.h:381
VAbstractPattern::useGroupLineWeight
QString useGroupLineWeight(quint32 toolId, QString weight)
Definition: vabstractpattern.cpp:3082
VAbstractPattern::getGroupObjHistory
QMap< quint32, Tool > getGroupObjHistory() const
Definition: vabstractpattern.cpp:865
VAbstractPattern::TagOperation
static const QString TagOperation
Definition: vabstractpattern.h:293
VAbstractPattern::AttrS64
static const QString AttrS64
Definition: vabstractpattern.h:398
VAbstractPattern::AttrIncludeAs
static const QString AttrIncludeAs
Definition: vabstractpattern.h:344
VAbstractPattern::showPiece
void showPiece(quint32 id)
VAbstractPattern::setCursor
void setCursor(const quint32 &value)
Definition: vabstractpattern.cpp:607
VAbstractPattern::AttrH104
static const QString AttrH104
Definition: vabstractpattern.h:359
VAbstractPattern::getDefaultLineType
QString getDefaultLineType() const
Definition: vabstractpattern.cpp:638
VAbstractPattern::AttrH200
static const QString AttrH200
Definition: vabstractpattern.h:375
VAbstractPattern::SetNotes
void SetNotes(const QString &text)
Definition: vabstractpattern.cpp:1359
VAbstractPattern::IncrementFormula
static const QString IncrementFormula
Definition: vabstractpattern.h:410
VAbstractPattern::AttrH176
static const QString AttrH176
Definition: vabstractpattern.h:371
VAbstractPattern::getActiveNodeElement
bool getActiveNodeElement(const QString &name, QDomElement &element) const
getActiveNodeElement find element in current draft block by name.
Definition: vabstractpattern.cpp:420
VAbstractPattern::SetCompanyName
void SetCompanyName(const QString &qsName)
Definition: vabstractpattern.cpp:1390
VAbstractPattern::useGroupLineType
QString useGroupLineType(quint32 toolId, QString type)
Definition: vabstractpattern.cpp:3058
VAbstractPattern::SetLabelDateFormat
void SetLabelDateFormat(const QString &format)
Definition: vabstractpattern.cpp:1447
VAbstractPattern::AttrH152
static const QString AttrH152
Definition: vabstractpattern.h:367
VAbstractPattern::AttrNodeReverse
static const QString AttrNodeReverse
Definition: vabstractpattern.h:328
VAbstractPattern::getActiveDraftBlockName
QString getActiveDraftBlockName() const
getActiveDraftBlockName return current draft block name.
Definition: vabstractpattern.cpp:348
VAbstractPattern::AttrS48
static const QString AttrS48
Definition: vabstractpattern.h:390
VAbstractPattern::getGroupsContainingItem
QMap< quint32, QString > getGroupsContainingItem(quint32 toolId, quint32 objectId, bool containsItem)
Returns the groups that contain or do not contain the item identified by the toolid and the objectid.
Definition: vabstractpattern.cpp:2537
VAbstractPattern::ListExpressions
QVector< VFormulaField > ListExpressions() const
Definition: vabstractpattern.cpp:1825
VAbstractPattern::getCursor
quint32 getCursor() const
Definition: vabstractpattern.cpp:601
VAbstractPattern::AttrNodeExcluded
static const QString AttrNodeExcluded
Definition: vabstractpattern.h:329
VAbstractPattern::groupNameExists
bool groupNameExists(const QString &groupName)
Definition: vabstractpattern.cpp:3027
VAbstractPattern::TagPath
static const QString TagPath
Definition: vabstractpattern.h:305
VAbstractPattern::TagPiece
static const QString TagPiece
Definition: vabstractpattern.h:277
VAbstractPattern::TagCompanyName
static const QString TagCompanyName
Definition: vabstractpattern.h:301
VAbstractPattern::AttrH116
static const QString AttrH116
Definition: vabstractpattern.h:361
VAbstractPattern::toolsOnRemove
QVector< VDataTool * > toolsOnRemove
Definition: vabstractpattern.h:484
VAbstractPattern::ListIncrementExpressions
QVector< VFormulaField > ListIncrementExpressions() const
Definition: vabstractpattern.cpp:1951
VAbstractPattern::AttrH122
static const QString AttrH122
Definition: vabstractpattern.h:362
VAbstractPattern::SetGradationSizes
void SetGradationSizes(const QMap< GSizes, bool > &options)
Definition: vabstractpattern.cpp:1242
VAbstractPattern::CheckTagExists
QDomElement CheckTagExists(const QString &tag)
Definition: vabstractpattern.cpp:1706
VAbstractPattern::AttrS24
static const QString AttrS24
Definition: vabstractpattern.h:378
VAbstractPattern::hasGroupItem
bool hasGroupItem(const QDomElement &domElement, quint32 toolId, quint32 objectId)
Checks if the given group has the item with the given toolId and objectId.
Definition: vabstractpattern.cpp:2587
VAbstractPattern::ToolExists
static void ToolExists(const quint32 &id)
Definition: vabstractpattern.cpp:1669
VAbstractPattern::TagImage
static const QString TagImage
Definition: vabstractpattern.h:279
VAbstractPattern::AttrS42
static const QString AttrS42
Definition: vabstractpattern.h:387
VAbstractPattern::ListPointExpressions
QVector< VFormulaField > ListPointExpressions() const
Definition: vabstractpattern.cpp:1845
VAbstractPattern::AttrDateFormat
static const QString AttrDateFormat
Definition: vabstractpattern.h:325
VAbstractPattern::TagCalculation
static const QString TagCalculation
Definition: vabstractpattern.h:274
VAbstractPattern::ListNodesExpressions
QVector< VFormulaField > ListNodesExpressions(const QDomElement &nodes) const
Definition: vabstractpattern.cpp:1988
VAbstractPattern::getGroupColor
QString getGroupColor(quint32 id)
Definition: vabstractpattern.cpp:2909
VAbstractPattern::AttrH170
static const QString AttrH170
Definition: vabstractpattern.h:370
VAbstractPattern::TagGrainline
static const QString TagGrainline
Definition: vabstractpattern.h:304
VAbstractPattern::setGroupVisibility
void setGroupVisibility(quint32 id, bool visible)
Definition: vabstractpattern.cpp:2836
VAbstractPattern::GetLabelTimeFormat
QString GetLabelTimeFormat() const
Definition: vabstractpattern.cpp:1457
VAbstractPattern::AttrName
static const QString AttrName
Definition: vabstractpattern.h:310
VAbstractPattern::ListPieceExpressions
QVector< VFormulaField > ListPieceExpressions() const
Definition: vabstractpattern.cpp:2049
VAbstractPattern::AttrNodeNotchAngle
static const QString AttrNodeNotchAngle
Definition: vabstractpattern.h:337
VAbstractPattern::AttrNodeIsNotch
static const QString AttrNodeIsNotch
Definition: vabstractpattern.h:330
VAbstractPattern::getDefaultLineWeight
qreal getDefaultLineWeight() const
Definition: vabstractpattern.cpp:632
VAbstractPattern::GetNotes
QString GetNotes() const
Definition: vabstractpattern.cpp:1353
VAbstractPattern::SetLabelTimeFormat
void SetLabelTimeFormat(const QString &format)
Definition: vabstractpattern.cpp:1472
VAbstractPattern::AttrVisible
static const QString AttrVisible
Definition: vabstractpattern.h:311
VAbstractPattern::TagPoint
static const QString TagPoint
Definition: vabstractpattern.h:288
VAbstractPattern::TagGradation
static const QString TagGradation
Definition: vabstractpattern.h:294
VAbstractPattern::modified
bool modified
modified keep state of the document for cases that do not cover QUndoStack
Definition: vabstractpattern.h:493
VAbstractPattern::getDefaultLineColor
QString getDefaultLineColor() const
Definition: vabstractpattern.cpp:626
VAbstractPattern::changeActiveDraftBlock
void changeActiveDraftBlock(const QString &name, const Document &parse=Document::FullParse)
changeActiveDraftBlock set new active draft block name.
Definition: vabstractpattern.cpp:330
VAbstractPattern::AttrS68
static const QString AttrS68
Definition: vabstractpattern.h:400
VAbstractPattern::AttrS72
static const QString AttrS72
Definition: vabstractpattern.h:402
VAbstractPattern::AttrNodeNotchWidth
static const QString AttrNodeNotchWidth
Definition: vabstractpattern.h:336
VAbstractPattern::AttrDefHeight
static const QString AttrDefHeight
Definition: vabstractpattern.h:405
VAbstractPattern::getHistory
QVector< VToolRecord > * getHistory()
getHistory return list with list of history records.
Definition: vabstractpattern.cpp:843
VAbstractPattern::TagNodes
static const QString TagNodes
Definition: vabstractpattern.h:306
VAbstractPattern::AttrNodeShowNotch
static const QString AttrNodeShowNotch
Definition: vabstractpattern.h:333
VAbstractPattern::ListSplineExpressions
QVector< VFormulaField > ListSplineExpressions() const
Definition: vabstractpattern.cpp:1920
VAbstractPattern::patternLabelWasChanged
static bool patternLabelWasChanged
Definition: vabstractpattern.h:499
VAbstractPattern::TagIncrements
static const QString TagIncrements
Definition: vabstractpattern.h:282
VAbstractPattern::getActiveDraftBlockIndex
int getActiveDraftBlockIndex() const
Definition: vabstractpattern.cpp:1781
VAbstractPattern::SetMPath
void SetMPath(const QString &path)
Definition: vabstractpattern.cpp:887
VAbstractPattern::SetDescription
void SetDescription(const QString &text)
Definition: vabstractpattern.cpp:1344
VAbstractPattern::patternHasGroups
void patternHasGroups(bool value)
VAbstractPattern::patternPieces
QStringList patternPieces
patternPieces list of patern pieces names for combobox
Definition: vabstractpattern.h:490
VAbstractPattern::TagSizes
static const QString TagSizes
Definition: vabstractpattern.h:296
VAbstractPattern::ParsePieceInternalPaths
static QVector< quint32 > ParsePieceInternalPaths(const QDomElement &domElement)
Definition: vabstractpattern.cpp:715
VAbstractPattern::ListPathExpressions
QVector< VFormulaField > ListPathExpressions() const
Definition: vabstractpattern.cpp:2011
VContainer::UpdateId
static void UpdateId(quint32 newId)
UpdateId update id. If new id bigger when current save new like current.
Definition: vcontainer.cpp:269
VDataTool
The VDataTool class need for getting access to data container of tool.
Definition: vdatatool.h:71
VDataTool::GroupVisibility
virtual void GroupVisibility(quint32 object, bool visible)=0
VDomDocument
The VDomDocument class represents a Seamly2D document (.val file).
Definition: vdomdocument.h:105
VDomDocument::elementById
QDomElement elementById(quint32 id, const QString &tagName=QString())
Definition: vdomdocument.cpp:222
VDomDocument::GetParametrString
static QString GetParametrString(const QDomElement &domElement, const QString &name, const QString &defValue=QString())
Returns the string value of the given attribute. RENAME: see above.
Definition: vdomdocument.cpp:459
VDomDocument::SetLabelTemplate
void SetLabelTemplate(QDomElement &element, const QVector< VLabelTemplateLine > &lines)
Definition: vdomdocument.cpp:981
VDomDocument::GetParametrUInt
static quint32 GetParametrUInt(const QDomElement &domElement, const QString &name, const QString &defValue)
Returns the long long value of the given attribute. RENAME: GetParameterLongLong?
Definition: vdomdocument.cpp:354
VDomDocument::getParameterBool
static bool getParameterBool(const QDomElement &domElement, const QString &name, const QString &defValue)
Definition: vdomdocument.cpp:383
VDomDocument::setTagText
bool setTagText(const QString &tag, const QString &text)
Definition: vdomdocument.cpp:803
VDomDocument::map
QHash< quint32, QDomElement > map
Map used for finding element by id.
Definition: vdomdocument.h:170
VDomDocument::GetParametrDouble
static qreal GetParametrDouble(const QDomElement &domElement, const QString &name, const QString &defValue)
Returns the double value of the given attribute.
Definition: vdomdocument.cpp:501
VDomDocument::TagVersion
static const QString TagVersion
Definition: vdomdocument.h:115
VDomDocument::TagUnit
static const QString TagUnit
Definition: vdomdocument.h:116
VDomDocument::UniqueTagText
QString UniqueTagText(const QString &tagName, const QString &defVal=QString()) const
Definition: vdomdocument.cpp:572
VDomDocument::SetAttribute
void SetAttribute(QDomElement &domElement, const QString &name, const T &value) const
SetAttribute set attribute in pattern file. Replace "," by ".".
Definition: vdomdocument.h:185
VDomDocument::AttrId
static const QString AttrId
Definition: vdomdocument.h:108
VDomDocument::RemoveAllChildren
static void RemoveAllChildren(QDomElement &domElement)
RemoveAllChildren remove all children from file.
Definition: vdomdocument.cpp:844
VDomDocument::GetLabelTemplate
QVector< VLabelTemplateLine > GetLabelTemplate(const QDomElement &element) const
Definition: vdomdocument.cpp:949
VExceptionBadId
The VExceptionBadId class for exception bad id.
Definition: vexceptionbadid.h:66
VExceptionBadId::ErrorMessage
virtual QString ErrorMessage() const Q_DECL_OVERRIDE
ErrorMessage return main error message.
Definition: vexceptionbadid.cpp:100
VExceptionConversionError
The VExceptionConversionError class for exception of conversion error.
Definition: vexceptionconversionerror.h:65
VExceptionEmptyParameter
The VExceptionEmptyParameter class for exception empty parameter.
Definition: vexceptionemptyparameter.h:68
VExceptionObjectError
The VExceptionObjectError class for exception object error.
Definition: vexceptionobjecterror.h:68
VException
The VException class parent for all exception. Could be use for abstract exception.
Definition: vexception.h:66
VException::AddMoreInformation
void AddMoreInformation(const QString &info)
AddMoreInformation add more information for error.
Definition: vexception.cpp:107
VPatternConverter::PatternMaxVerStr
static const QString PatternMaxVerStr
Definition: vpatternconverter.h:77
VPieceNode::setBeforeSAFormula
void setBeforeSAFormula(const QString &formula)
Definition: vpiecenode.cpp:221
VPieceNode::setShowNotch
void setShowNotch(bool value)
Definition: vpiecenode.cpp:344
VPieceNode::setNotchCount
void setNotchCount(int notchCount)
Definition: vpiecenode.cpp:399
VPieceNode::SetExcluded
void SetExcluded(bool exclude)
Definition: vpiecenode.cpp:417
VPieceNode::setNotch
void setNotch(bool notch)
Definition: vpiecenode.cpp:293
VPieceNode::setNotchType
void setNotchType(NotchType notchType)
Definition: vpiecenode.cpp:320
VPieceNode::setAfterSAFormula
void setAfterSAFormula(const QString &formula)
Definition: vpiecenode.cpp:263
VPieceNode::setNotchLength
void setNotchLength(qreal notchLength)
Definition: vpiecenode.cpp:363
VPieceNode::setNotchWidth
void setNotchWidth(qreal notchWidth)
Definition: vpiecenode.cpp:375
VPieceNode::setShowSeamlineNotch
void setShowSeamlineNotch(bool value)
Definition: vpiecenode.cpp:356
VPieceNode::SetAngleType
void SetAngleType(PieceNodeAngle type)
Definition: vpiecenode.cpp:278
VPieceNode::setNotchAngle
void setNotchAngle(qreal notchAngle)
Definition: vpiecenode.cpp:387
VPieceNode::setNotchSubType
void setNotchSubType(NotchSubType notchSubType)
Definition: vpiecenode.cpp:332
VPiecePath::Append
void Append(const VPieceNode &node)
Definition: vpiecepath.cpp:197
VPiecePath::at
const VPieceNode & at(int indx) const
Definition: vpiecepath.cpp:221
VToolRecord
The VToolRecord class record about tool in history.
Definition: vtoolrecord.h:64
VToolRecord::getTypeTool
Tool getTypeTool() const
getTypeTool return tool type.
Definition: vtoolrecord.h:114
VToolRecord::getId
quint32 getId() const
getId return tool id.
Definition: vtoolrecord.h:94
VToolRecord::getDraftBlockName
QString getDraftBlockName() const
getDraftBlockName return pattern peace name.
Definition: vtoolrecord.h:134
builInFunctions
const QStringList builInFunctions
Definition: def.cpp:120
strStraightforward
const QString strStraightforward
Definition: def.cpp:627
builInPostfixOperators
const QStringList builInPostfixOperators
Definition: def.cpp:133
strSlit
const QString strSlit
Definition: def.cpp:565
trueStr
const QString trueStr
Definition: def.cpp:197
falseStr
const QString falseStr
Definition: def.cpp:198
stringToNotchType
NotchType stringToNotchType(const QString &value)
Definition: def.cpp:600
stringToNotchSubType
NotchSubType stringToNotchSubType(const QString &value)
Definition: def.cpp:650
NotchType
NotchType
Definition: def.h:123
SCASSERT
#define SCASSERT(cond)
Definition: def.h:317
PieceNodeAngle
PieceNodeAngle
Definition: def.h:113
NotchSubType
NotchSubType
Definition: def.h:137
Tool
Tool
Definition: def.h:161
Tool::NodeSplinePath
@ NodeSplinePath
Tool::NodeSpline
@ NodeSpline
Tool::NodeElArc
@ NodeElArc
Tool::NodeArc
@ NodeArc
Tool::NodePoint
@ NodePoint
Tool::LAST_ONE_DO_NOT_USE
@ LAST_ONE_DO_NOT_USE
PiecePathIncludeType
PiecePathIncludeType
Definition: def.h:152
AttrPoint2
const QString AttrPoint2
Definition: ifcdef.cpp:116
AttrC1Radius
const QString AttrC1Radius
Definition: ifcdef.cpp:141
LineTypeByGroup
const QString LineTypeByGroup
Definition: ifcdef.cpp:370
AttrKAsm2
const QString AttrKAsm2
Definition: ifcdef.cpp:120
AttrLength
const QString AttrLength
Definition: ifcdef.cpp:94
AttrLineType
const QString AttrLineType
Definition: ifcdef.cpp:90
AttrC2Radius
const QString AttrC2Radius
Definition: ifcdef.cpp:142
LineTypeSolidLine
const QString LineTypeSolidLine
Definition: ifcdef.cpp:159
AttrLineWeight
const QString AttrLineWeight
Definition: ifcdef.cpp:91
AttrAngle
const QString AttrAngle
Definition: ifcdef.cpp:103
AttrRadius2
const QString AttrRadius2
Definition: ifcdef.cpp:102
AttrPoint1
const QString AttrPoint1
Definition: ifcdef.cpp:115
currentSeamAllowance
const QString currentSeamAllowance
Definition: ifcdef.cpp:442
AttrRotationAngle
const QString AttrRotationAngle
Definition: ifcdef.cpp:151
ColorBlack
const QString ColorBlack
Definition: ifcdef.cpp:373
AttrRadius1
const QString AttrRadius1
Definition: ifcdef.cpp:101
AttrRadius
const QString AttrRadius
Definition: ifcdef.cpp:100
currentLength
const QString currentLength
Definition: ifcdef.cpp:441
builInVariables
const QStringList builInVariables
Definition: ifcdef.cpp:444
AttrCRadius
const QString AttrCRadius
Definition: ifcdef.cpp:145
AttrAngle2
const QString AttrAngle2
Definition: ifcdef.cpp:105
AttrPathPoint
const QString AttrPathPoint
Definition: ifcdef.cpp:123
AttrIdObject
const QString AttrIdObject
Definition: ifcdef.cpp:148
ColorByGroup
const QString ColorByGroup
Definition: ifcdef.cpp:371
AttrAngle1
const QString AttrAngle1
Definition: ifcdef.cpp:104
LineWeightByGroup
const QString LineWeightByGroup
Definition: ifcdef.cpp:369
AttrKAsm1
const QString AttrKAsm1
Definition: ifcdef.cpp:119
NULL_ID
#define NULL_ID
Definition: ifcdef.h:76
NULL_ID_STR
#define NULL_ID_STR
Definition: ifcdef.h:77
anonymous_namespace{vabstractpattern.cpp}::ReadExpressionAttribute
void ReadExpressionAttribute(QVector< VFormulaField > &expressions, const QDomElement &element, const QString &attribute)
Definition: vabstractpattern.cpp:236
CustomSARecord
The CustomSA struct contains record about custom seam allowanse (SA).
Definition: def.h:510
CustomSARecord::endPoint
quint32 endPoint
Definition: def.h:521
CustomSARecord::path
quint32 path
Definition: def.h:520
CustomSARecord::startPoint
quint32 startPoint
Definition: def.h:519
CustomSARecord::reverse
bool reverse
Definition: def.h:522
CustomSARecord::includeType
PiecePathIncludeType includeType
Definition: def.h:523
VFormulaField::element
QDomElement element
Definition: vabstractpattern.h:96
Document
Document
Definition: vabstractpattern.h:78
qApp
#define qApp
Definition: vapplication.h:67