Bug Summary

File:librecad/src/lib/engine/document/dimstyles/lc_dimstyle.cpp
Warning:line 1849, column 5
Undefined or garbage value returned to caller

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name lc_dimstyle.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/home/runner/work/LibreCAD/LibreCAD/librecad/src -fcoverage-compilation-dir=/home/runner/work/LibreCAD/LibreCAD/librecad/src -resource-dir /usr/lib/llvm-18/lib/clang/18 -D _REENTRANT -D DWGSUPPORT -D MUPARSER_STATIC -D QC_APPDIR="librecad" -D LC_VERSION=2.2.2_alpha1-607-g330d41cec -D LC_PRERELEASE=true; -D QT_NO_DEBUG -D QT_SVG_LIB -D QT_PRINTSUPPORT_LIB -D QT_WIDGETS_LIB -D QT_GUI_LIB -D QT_NETWORK_LIB -D QT_CORE_LIB -I . -I /usr/include -I ../../libraries/lciconengine -I ../../libraries/libdxfrw/src -I ../../libraries/jwwlib/src -I ../../libraries/shapelib/src -I cmd -I lib/actions -I lib/actions/visual_snap -I lib/actions/options -I lib/creation -I lib/debug -I lib/engine -I lib/engine/document -I lib/engine/document/blocks -I lib/engine/document/container -I lib/engine/document/dimstyles -I lib/engine/document/entities -I lib/engine/document/entities/support -I lib/engine/document/fonts -I lib/engine/document/io -I lib/engine/document/layers -I lib/engine/document/patterns -I lib/engine/document/selection -I lib/engine/document/textstyles -I lib/engine/document/ucs -I lib/engine/document/variables -I lib/engine/document/views -I lib/engine/clipboard -I lib/engine/overlays -I lib/engine/overlays/angles_base -I lib/engine/overlays/highlight -I lib/engine/overlays/preview -I lib/engine/overlays/references -I lib/engine/overlays/crosshair -I lib/engine/overlays/info_cursor -I lib/engine/overlays/overlay_box -I lib/engine/overlays/ucs_mark -I lib/engine/undo -I lib/engine/utils -I lib/engine/settings -I lib/fileio -I lib/filters -I lib/generators -I lib/generators/makercamsvg -I lib/generators/layers -I lib/generators/image -I lib/gui -I lib/gui/grid -I lib/gui/render -I lib/gui/render/headless -I lib/gui/render/widget -I lib/information -I lib/math -I lib/modification -I lib/selection -I lib/selection/metaentity -I lib/selection/metaentity/entities -I lib/printing -I lib/properties -I actions -I actions/dock_widgets -I actions/dock_widgets/block -I actions/dock_widgets/entity_info -I actions/dock_widgets/layer -I actions/dock_widgets/library -I actions/dock_widgets/ucs_list -I actions/drawing -I actions/drawing/draw -I actions/drawing/draw/arc -I actions/drawing/draw/circle -I actions/drawing/draw/curve -I actions/drawing/draw/spline -I actions/drawing/draw/dimensions -I actions/drawing/draw/ellipse -I actions/drawing/draw/hatch -I actions/drawing/draw/image -I actions/drawing/draw/line -I actions/drawing/draw/point -I actions/drawing/draw/rect -I actions/drawing/draw/polygon -I actions/drawing/draw/misc -I actions/drawing/draw/line/shapes -I actions/drawing/draw/line/misc -I actions/drawing/draw/line/shapes/rect -I actions/drawing/draw/line/shapes/polygon -I actions/drawing/draw/polyline -I actions/drawing/draw/text -I actions/drawing/edit -I actions/drawing/info -I actions/drawing/pick -I actions/drawing/modify -I actions/drawing/pen -I actions/drawing/rel_zero -I actions/drawing/selection -I actions/drawing/snap -I actions/drawing/zoom -I actions/file -I actions/options -I actions/print_preview -I ui -I ui/action_options -I ui/action_options/circle -I ui/action_options/curve -I ui/action_options/spline -I ui/action_options/dimensions -I ui/action_options/edit -I ui/action_options/image -I ui/action_options/info -I ui/action_options/insert -I ui/action_options/line -I ui/action_options/rect -I ui/action_options/polygon -I ui/action_options/misc -I ui/action_options/modify -I ui/action_options/ellipse -I ui/action_options/other -I ui/action_options/polyline -I ui/action_options/point -I ui/action_options/print_preview -I ui/action_options/selection -I ui/action_options/snap -I ui/action_options/text -I ui/actions -I ui/components -I ui/components/relative_position_assistant -I ui/components/comboboxes -I ui/components/containers -I ui/components/creators -I ui/components/layouts -I ui/components/pen -I ui/components/status_bar -I ui/components/toolbars -I ui/components/utils -I ui/dialogs -I ui/dialogs/actions -I ui/dialogs/actions/modify -I ui/dialogs/actions/quick_selection -I ui/dialogs/modify -I ui/dialogs/entity -I ui/dialogs/creators -I ui/dialogs/file -I ui/dialogs/file/export -I ui/dialogs/file/export/layers -I ui/dialogs/file/export/image -I ui/dialogs/file/export/makercam -I ui/dialogs/main -I ui/dialogs/settings -I ui/dialogs/settings/dimstyles -I ui/dialogs/settings/dimstyles/dimstyle_manager -I ui/dialogs/settings/dimstyles/dimstyle_manager/support -I ui/dialogs/settings/options_device -I ui/dialogs/settings/options_drawing -I ui/dialogs/settings/options_general -I ui/dialogs/settings/options_widget -I ui/dialogs/settings/shortcuts -I ui/dock_widgets -I ui/dock_widgets/block_widget -I ui/dock_widgets/command_line -I ui/dock_widgets/entity_info -I ui/dock_widgets/layer_widget -I ui/dock_widgets/layers_tree -I ui/dock_widgets/library_widget -I ui/dock_widgets/pen_palette -I ui/dock_widgets/pen_wizard -I ui/dock_widgets/property_sheet -I ui/dock_widgets/property_sheet/lib -I ui/dock_widgets/property_sheet/lib/properties -I ui/dock_widgets/property_sheet/lib/view -I ui/dock_widgets/property_sheet/lib/view/edit -I ui/dock_widgets/property_sheet/lib/widgets -I ui/dock_widgets/property_sheet/lib/widgets/sheet -I ui/dock_widgets/property_sheet/metaentity -I ui/dock_widgets/property_sheet/metaentity/entities -I ui/dock_widgets/property_sheet/metaentity/entities/document -I ui/dock_widgets/property_sheet/properties -I ui/dock_widgets/property_sheet/properties/action -I ui/dock_widgets/property_sheet/properties/bool -I ui/dock_widgets/property_sheet/properties/color -I ui/dock_widgets/property_sheet/properties/double -I ui/dock_widgets/property_sheet/properties/enum -I ui/dock_widgets/property_sheet/properties/int -I ui/dock_widgets/property_sheet/properties/layer -I ui/dock_widgets/property_sheet/properties/linetype -I ui/dock_widgets/property_sheet/properties/linewidth -I ui/dock_widgets/property_sheet/properties/rect -I ui/dock_widgets/property_sheet/properties/rsvector -I ui/dock_widgets/property_sheet/properties/string -I ui/dock_widgets/views_list -I ui/dock_widgets/ucs_list -I ui/dock_widgets/workspaces -I ui/dock_widgets/cad -I ui/main -I ui/main/init -I ui/main/persistence -I ui/main/release_check -I ui/main/support -I ui/main/fontviewer -I ui/main/workspaces -I ui/view -I main -I main/console_dxf2pdf -I test -I plugins -I ../res -I ../res/arrows -I ../res/controls -I ../res/dxf -I ../res/gdt -I ../res/icons -I ../res/images -I ../../../Qt/6.9.0/gcc_64/include -I ../../../Qt/6.9.0/gcc_64/include/QtSvg -I ../../../Qt/6.9.0/gcc_64/include/QtPrintSupport -I ../../../Qt/6.9.0/gcc_64/include/QtWidgets -I ../../../Qt/6.9.0/gcc_64/include/QtGui -I ../../../Qt/6.9.0/gcc_64/include/QtNetwork -I ../../../Qt/6.9.0/gcc_64/include/QtCore -I ../../generated/librecad/moc -I ../../generated/librecad/ui -I ../../../Qt/6.9.0/gcc_64/mkspecs/linux-g++ -internal-isystem /usr/bin/../lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14 -internal-isystem /usr/bin/../lib/gcc/x86_64-linux-gnu/14/../../../../include/x86_64-linux-gnu/c++/14 -internal-isystem /usr/bin/../lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14/backward -internal-isystem /usr/lib/llvm-18/lib/clang/18/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -std=gnu++1z -fdeprecated-macro -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fcxx-exceptions -fexceptions -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/runner/work/LibreCAD/LibreCAD/out/2026-08-04-154929-5069-1 -x c++ lib/engine/document/dimstyles/lc_dimstyle.cpp
1/*******************************************************************************
2 *
3 This file is part of the LibreCAD project, a 2D CAD program
4
5 Copyright (C) 2025 LibreCAD.org
6 Copyright (C) 2025 sand1024
7
8 This program is free software; you can redistribute it and/or
9 modify it under the terms of the GNU General Public License
10 as published by the Free Software Foundation; either version 2
11 of the License, or (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21 ******************************************************************************/
22
23#include "lc_dimstyle.h"
24
25#include <QRegularExpression>
26
27#include "lc_linemath.h"
28#include "rs_filterdxfrw.h"
29#include "rs_math.h"
30
31
32
33LC_DimStyle::LC_DimStyle(const QString& name): m_name{name} {
34 init();
35}
36
37LC_DimStyle::LC_DimStyle() : m_name{STANDARD_DIM_STYLE} {
38 init();
39}
40
41void LC_DimStyle::init() {
42 m_angularUnitFormattingStyle = std::make_unique<AngularFormat>();
43 m_arrowheadStyle = std::make_unique<Arrowhead>();
44 m_arcStyle = std::make_unique<Arc>();
45 m_dimensionLineStyle = std::make_unique<DimensionLine>();
46 m_extensionLineStyle = std::make_unique<ExtensionLine>();
47 m_leaderStyle = std::make_unique<Leader>();
48 m_latteralToleranceStyle = std::make_unique<LatteralTolerance>();
49 m_mleaderStyle = std::make_unique<MLeader>();
50 m_radialStyle = std::make_unique<Radial>();
51 m_roundOffStyle = std::make_unique<LinearRoundOff>();
52 m_scalingStyle = std::make_unique<Scaling>();
53 m_textStyle = std::make_unique<Text>();
54 m_unitFormattingStyle = std::make_unique<LinearFormat>();
55 m_unitFractionsStyle = std::make_unique<Fractions>();
56 m_unitZeroSuppressionStyle = std::make_unique<ZerosSuppression>();
57 fillByDefaults();
58}
59
60void LC_DimStyle::fillByDefaults() const {
61 m_angularUnitFormattingStyle->fillByDefaults();
62 m_arrowheadStyle->fillByDefaults();
63 m_arcStyle->fillByDefaults();
64 m_dimensionLineStyle->fillByDefaults();
65 m_extensionLineStyle->fillByDefaults();
66 m_leaderStyle->fillByDefaults();
67 m_latteralToleranceStyle->fillByDefaults();
68 m_mleaderStyle->fillByDefaults();
69 m_radialStyle->fillByDefaults();
70 m_roundOffStyle->fillByDefaults();
71 m_scalingStyle->fillByDefaults();
72 m_textStyle->fillByDefaults();
73 m_unitFormattingStyle->fillByDefaults();
74 m_unitFractionsStyle->fillByDefaults();
75 m_unitZeroSuppressionStyle->fillByDefaults();
76}
77
78void LC_DimStyle::merge(const LC_DimStyle* src) const {
79 if (src == nullptr) {
80 return;
81 }
82 m_angularUnitFormattingStyle->merge(src->angularFormat());
83 m_arrowheadStyle->merge(src->arrowhead());
84 m_arcStyle->merge(src->arc());
85 m_dimensionLineStyle->merge(src->dimensionLine());
86 m_extensionLineStyle->merge(src->extensionLine());
87 m_leaderStyle->merge(src->leader());
88 m_latteralToleranceStyle->merge(src->latteralTolerance());
89 m_mleaderStyle->merge(src->mleader());
90 m_radialStyle->merge(src->radial());
91 m_roundOffStyle->merge(src->roundOff());
92 m_scalingStyle->merge(src->scaling());
93 m_textStyle->merge(src->text());
94 m_unitFormattingStyle->merge(src->linearFormat());
95 m_unitFractionsStyle->merge(src->fractions());
96 m_unitZeroSuppressionStyle->merge(src->zerosSuppression());
97}
98
99void LC_DimStyle::mergeWith(const LC_DimStyle* src, const ModificationAware::CheckFlagMode mergeMode, const ModificationAware::CheckFlagMode nextMode) const {
100 if (src == nullptr) {
101 return;
102 }
103 setModifyCheckMode(mergeMode);
104 merge(src);
105 setModifyCheckMode(nextMode);
106}
107
108LC_DimStyle::ModificationAware::CheckFlagMode LC_DimStyle::getModifyCheckMode() const {
109 return m_angularUnitFormattingStyle->getModifyCheckMode();
110}
111
112void LC_DimStyle::setModifyCheckMode(const ModificationAware::CheckFlagMode mode) const {
113 m_angularUnitFormattingStyle->setModifyCheckMode(mode);
114 m_arrowheadStyle->setModifyCheckMode(mode);
115 m_arcStyle->setModifyCheckMode(mode);
116 m_dimensionLineStyle->setModifyCheckMode(mode);
117 m_extensionLineStyle->setModifyCheckMode(mode);
118 m_leaderStyle->setModifyCheckMode(mode);
119 m_latteralToleranceStyle->setModifyCheckMode(mode);
120 m_mleaderStyle->setModifyCheckMode(mode);
121 m_radialStyle->setModifyCheckMode(mode);
122 m_roundOffStyle->setModifyCheckMode(mode);
123 m_scalingStyle->setModifyCheckMode(mode);
124 m_textStyle->setModifyCheckMode(mode);
125 m_unitFormattingStyle->setModifyCheckMode(mode);
126 m_unitFractionsStyle->setModifyCheckMode(mode);
127 m_unitZeroSuppressionStyle->setModifyCheckMode(mode);
128}
129
130void LC_DimStyle::ZerosSuppression::setLinearFlag(const LinearSuppressionPolicy dimzin, const bool set) {
131 const int newValue = set ? DIMZIN | dimzin : DIMZIN & ~dimzin;
132 setLinearRaw(newValue);
133}
134
135void LC_DimStyle::ZerosSuppression::setAngularFlag(const AngularSuppressionPolicy dimazin, const bool set) {
136 const int newValue = set ? DIMAZIN | dimazin : DIMAZIN & ~dimazin;
137 setAngularRaw(newValue);
138}
139
140void LC_DimStyle::ZerosSuppression::setToleranceFlag(const ToleranceSuppressionPolicy dimtzin, const bool set) {
141 const int newValue = set ? DIMTZIN | dimtzin : DIMTZIN & ~dimtzin;
142 setToleranceRaw(newValue);
143}
144
145void LC_DimStyle::ZerosSuppression::setAltLinearFlag(const LinearSuppressionPolicy dimaltz, const bool set) {
146 const int newValue = set ? DIMALTZ | dimaltz : DIMALTZ & ~dimaltz;
147 setAltLinearRaw(newValue);
148}
149
150void LC_DimStyle::ZerosSuppression::setAltToleranceFlag(const ToleranceSuppressionPolicy dimalttz, const bool set) {
151 const int newValue = set ? DIMALTTZ | dimalttz : DIMALTTZ & ~dimalttz;
152 setAltToleranceRaw(newValue);
153}
154
155void LC_DimStyle::copyTo(LC_DimStyle* copy) const {
156 copy->m_name = m_name;
157 m_angularUnitFormattingStyle->copyTo(copy->angularFormat());
158 m_arrowheadStyle->copyTo(copy->arrowhead());
159 m_arcStyle->copyTo(copy->arc());
160 m_dimensionLineStyle->copyTo(copy->dimensionLine());
161 m_extensionLineStyle->copyTo(copy->extensionLine());
162 m_leaderStyle->copyTo(copy->leader());
163 m_latteralToleranceStyle->copyTo(copy->latteralTolerance());
164 m_mleaderStyle->copyTo(copy->mleader());
165 m_radialStyle->copyTo(copy->radial());
166 m_roundOffStyle->copyTo(copy->roundOff());
167 m_scalingStyle->copyTo(copy->scaling());
168 m_textStyle->copyTo(copy->text());
169 m_unitFormattingStyle->copyTo(copy->linearFormat());
170 m_unitFractionsStyle->copyTo(copy->fractions());
171 m_unitZeroSuppressionStyle->copyTo(copy->zerosSuppression());
172}
173
174void LC_DimStyle::resetFlags(const bool toUnset) const {
175 const int value = toUnset ? 0 : UINT_MAX(2147483647 *2U +1U);
176 m_angularUnitFormattingStyle->setFlags(value);
177 m_arrowheadStyle->setFlags(value);
178 m_arcStyle->setFlags(value);
179 m_dimensionLineStyle->setFlags(value);
180 m_extensionLineStyle->setFlags(value);
181 m_leaderStyle->setFlags(value);
182 m_latteralToleranceStyle->setFlags(value);
183 m_mleaderStyle->setFlags(value);
184 m_radialStyle->setFlags(value);
185 m_roundOffStyle->setFlags(value);
186 m_scalingStyle->resetFlags();
187 m_textStyle->setFlags(value);
188 m_unitFormattingStyle->setFlags(value);
189 m_unitFractionsStyle->setFlags(value);
190 m_unitZeroSuppressionStyle->setFlags(value);
191}
192
193LC_DimStyle* LC_DimStyle::getCopy() const {
194 const auto copy = new LC_DimStyle();
195 copyTo(copy);
196 copy->m_name = m_name;
197 copy->m_fromVars = m_fromVars;
198 return copy;
199}
200
201const QString& LC_DimStyle::getName() const {
202 return m_name;
203}
204
205void LC_DimStyle::Text::fillByDefaults() {
206 DIMATFIT = EITHER_TEXT_OR_ARROW;
207 DIMTFILL = NONE;
208 DIMTFILLCLR = RS2::FlagByBlock;
209 DIMTAD = ABOVE_DIM_LINE_EXCEPT_NOT_HORIZONTAL;
210 DIMJUST = ABOVE_AND_CENTERED;
211 DIMCLRT = RS2::FlagByBlock;
212 DIMTIX = PLACE_BETWEEN_IF_SUFFICIENT_ROOM;
213 DIMTIH = DRAW_HORIZONTALLY;
214 DIMTOH = DRAW_HORIZONTALLY;
215 DIMTVP = 0.0000;
216 DIMTXSTY = "Standard";
217 DIMTXT = 2.5000;
218 DIMTXTDIRECTION = LEFT_TO_RIGHT;
219 DIMUPT = DIM_LINE_LOCATION_ONLY;
220 DIMTMOVE = DIM_LINE_WITH_TEXT;
221}
222
223void LC_DimStyle::Text::copyTo(Text* c) const {
224 copyFlags(c);
225 c->DIMATFIT = DIMATFIT;
226 c->DIMTFILL = DIMTFILL;
227 c->DIMTFILLCLR = DIMTFILLCLR;
228 c->DIMTAD = DIMTAD;
229 c->DIMJUST = DIMJUST;
230 c->DIMCLRT = DIMCLRT;
231 c->DIMTIX = DIMTIX;
232 c->DIMTIH = DIMTIH;
233 c->DIMTOH = DIMTOH;
234 c->DIMTVP = DIMTVP;
235 c->DIMTXSTY = DIMTXSTY;
236 c->DIMTXT = DIMTXT;
237 c->DIMTXTDIRECTION = DIMTXTDIRECTION;
238 c->DIMUPT = DIMUPT;
239 c->DIMTMOVE = DIMTMOVE;
240}
241
242void LC_DimStyle::Text::merge(const Text* parent) {
243 if (checkModifyState($DIMATFIT)) {
244 DIMATFIT = parent->DIMATFIT;
245 }
246 if (checkModifyState($DIMTFILL)) {
247 DIMTFILL = parent->DIMTFILL;
248 }
249 if (checkModifyState($DIMTFILLCLR)) {
250 DIMTFILLCLR = parent->DIMTFILLCLR;
251 }
252 if (checkModifyState($DIMTAD)) {
253 DIMTAD = parent->DIMTAD;
254 }
255 if (checkModifyState($DIMJUST)) {
256 DIMJUST = parent->DIMJUST;
257 }
258 if (checkModifyState($DIMCLRT)) {
259 DIMCLRT = parent->DIMCLRT;
260 }
261 if (checkModifyState($DIMTIX)) {
262 DIMTIX = parent->DIMTIX;
263 }
264 if (checkModifyState($DIMTIH)) {
265 DIMTIH = parent->DIMTIH;
266 }
267 if (checkModifyState($DIMTOH)) {
268 DIMTOH = parent->DIMTOH;
269 }
270 if (checkModifyState($DIMTVP)) {
271 DIMTVP = parent->DIMTVP;
272 }
273 if (checkModifyState($DIMTXSTY)) {
274 DIMTXSTY = parent->DIMTXSTY;
275 }
276 if (checkModifyState($DIMTXT)) {
277 DIMTXT = parent->DIMTXT;
278 }
279 if (checkModifyState($DIMTXTDIRECTION)) {
280 DIMTXTDIRECTION = parent->DIMTXTDIRECTION;
281 }
282 if (checkModifyState($DIMUPT)) {
283 DIMUPT = parent->DIMUPT;
284 }
285 if (checkModifyState($DIMTMOVE)) {
286 DIMTMOVE = parent->DIMTMOVE;
287 }
288}
289
290void LC_DimStyle::DimensionLine::fillByDefaults() {
291 DIMCLRD = RS2::FlagByBlock;
292 DIMDLE = 0.0;
293 DIMDLI = 3.7500;
294 DIMGAP = 0.6250;
295 DIMLTYPE = "ByBlock";
296 DIMLTYPE_LineType = RS2::LineByBlock;
297 DIMLWD = RS2::WidthByBlock;
298 DIMSD1 = DONT_SUPPRESS;
299 DIMSD2 = DONT_SUPPRESS;
300 DIMTOFL = DRAW_EVEN_IF_ARROWHEADS_ARE_OUTSIDE;
301}
302
303void LC_DimStyle::DimensionLine::copyTo(DimensionLine* c) const {
304 copyFlags(c);
305 c->DIMCLRD = DIMCLRD;
306 c->DIMDLE = DIMDLE;
307 c->DIMDLI = DIMDLI;
308 c->DIMGAP = DIMGAP;
309 c->DIMLTYPE = DIMLTYPE;
310 c->DIMLTYPE_LineType = DIMLTYPE_LineType;
311 c->DIMLWD = DIMLWD;
312 c->DIMSD1 = DIMSD1;
313 c->DIMSD2 = DIMSD2;
314 c->DIMTOFL = DIMTOFL;
315}
316
317void LC_DimStyle::DimensionLine::merge(const DimensionLine* parent) {
318 if (checkModifyState($DIMCLRD)) {
319 DIMCLRD = parent->DIMCLRD;
320 }
321 if (checkModifyState($DIMDLE)) {
322 DIMDLE = parent->DIMDLE;
323 }
324 if (checkModifyState($DIMDLI)) {
325 DIMDLI = parent->DIMDLI;
326 }
327 if (checkModifyState($DIMGAP)) {
328 DIMGAP = parent->DIMGAP;
329 }
330 if (checkModifyState($DIMLTYPE)) {
331 DIMLTYPE = parent->DIMLTYPE;
332 DIMLTYPE_LineType = parent->DIMLTYPE_LineType;
333 }
334 if (checkModifyState($DIMLWD)) {
335 DIMLWD = parent->DIMLWD;
336 }
337 if (checkModifyState($DIMSD1)) {
338 DIMSD1 = parent->DIMSD1;
339 }
340 if (checkModifyState($DIMSD2)) {
341 DIMSD2 = parent->DIMSD2;
342 }
343 if (checkModifyState($DIMTOFL)) {
344 DIMTOFL = parent->DIMTOFL;
345 }
346}
347
348
349void LC_DimStyle::DimensionLine::setLineGap(const double dimgap) {
350 checkModified(dimgap, DIMGAP, $DIMGAP);
351 DIMGAP = dimgap;
352}
353
354void LC_DimStyle::DimensionLine::setColor(const RS_Color& dimclrd) {
355 checkModified(dimclrd, DIMCLRD, $DIMCLRD);
356 DIMCLRD = dimclrd;
357}
358
359void LC_DimStyle::DimensionLine::setLineWidth(const RS2::LineWidth dimlwd) {
360 checkModified(dimlwd, DIMLWD, $DIMLWD);
361 DIMLWD = dimlwd;
362}
363
364void LC_DimStyle::DimensionLine::setDistanceBeyondExtLinesForObliqueStroke(const double dimdle) {
365 checkModified(dimdle, DIMDLE, $DIMDLE);
366 DIMDLE = dimdle;
367}
368
369void LC_DimStyle::DimensionLine::setBaselineDimLinesSpacing(const double dimdli) {
370 checkModified(dimdli, DIMDLI, $DIMDLI);
371 DIMDLI = dimdli;
372}
373
374void LC_DimStyle::DimensionLine::setSuppressFirst(const bool v) {
375 setSuppressFirstLine( v ? SUPPRESS : DONT_SUPPRESS);
376}
377
378void LC_DimStyle::DimensionLine::setSuppressFirstLine(const DimLineAndArrowSuppressionPolicy dimsd1) {
379 checkModified(dimsd1, DIMSD1, $DIMSD1);
380 DIMSD1 = dimsd1;
381}
382
383void LC_DimStyle::DimensionLine::setSuppressSecondLine(const DimLineAndArrowSuppressionPolicy dimsd2) {
384 checkModified(dimsd2, DIMSD2, $DIMSD2);
385 DIMSD2 = dimsd2;
386}
387
388void LC_DimStyle::DimensionLine::setSuppressSecond(const bool v) {
389 setSuppressSecondLine( v ? SUPPRESS : DONT_SUPPRESS);
390}
391
392void LC_DimStyle::DimensionLine::setDrawPolicyForOutsideText(const DrawPolicyForOutsideText dimtofl) {
393 checkModified(dimtofl, DIMTOFL, $DIMTOFL);
394 DIMTOFL = dimtofl;
395}
396
397void LC_DimStyle::DimensionLine::setLineType(const QString& dimltype) {
398 checkModified(dimltype, DIMLTYPE, $DIMLTYPE);
399 DIMLTYPE = dimltype;
400 DIMLTYPE_LineType = RS_FilterDXFRW::nameToLineType(dimltype);
401}
402
403void LC_DimStyle::DimensionLine::setLineType(const RS2::LineType lineType) {
404 checkModified(lineType, DIMLTYPE_LineType, $DIMLTYPE);
405 DIMLTYPE_LineType = lineType;
406 DIMLTYPE = RS_FilterDXFRW::lineTypeToName(lineType);
407}
408
409void LC_DimStyle::ExtensionLine::fillByDefaults() {
410 DIMCLRE = RS2::FlagByBlock;
411 DIMEXE = 1.2500;
412 DIMEXO = 0.625;
413 DIMFXL = 1.0;
414 DIMFXLON = false;
415 DIMLTEX1 = "ByBlock";
416 DIMLTEX2 = "ByBlock";
417 DIMLTEX1_linetype = RS2::LineByBlock;
418 DIMLTEX2_linetype = RS2::LineByBlock;
419 DIMLWE = RS2::WidthByBlock;
420 DIMSE1 = DONT_SUPPRESS;
421 DIMSE2 = DONT_SUPPRESS;
422}
423
424void LC_DimStyle::ExtensionLine::copyTo(ExtensionLine* c) const {
425 copyFlags(c);
426 c->DIMCLRE = DIMCLRE;
427 c->DIMEXE = DIMEXE;
428 c->DIMEXO = DIMEXO;
429 c->DIMFXL = DIMFXL;
430 c->DIMFXLON = DIMFXLON;
431 c->DIMLTEX1 = DIMLTEX1;
432 c->DIMLTEX2 = DIMLTEX2;
433 c->DIMLTEX1_linetype = DIMLTEX1_linetype;
434 c->DIMLTEX2_linetype = DIMLTEX2_linetype;
435 c->DIMLWE = DIMLWE;
436 c->DIMSE1 = DIMSE1;
437 c->DIMSE2 = DIMSE2;
438}
439
440void LC_DimStyle::ExtensionLine::merge(const ExtensionLine* parent) {
441 if (checkModifyState($DIMCLRE)) {
442 DIMCLRE = parent->DIMCLRE;
443 }
444 if (checkModifyState($DIMEXE)) {
445 DIMEXE = parent->DIMEXE;
446 }
447 if (checkModifyState($DIMEXO)) {
448 DIMEXO = parent->DIMEXO;
449 }
450 if (checkModifyState($DIMFXL)) {
451 DIMFXL = parent->DIMFXL;
452 }
453 if (checkModifyState($DIMFXLON)) {
454 DIMFXLON = parent->DIMFXLON;
455 }
456 if (checkModifyState($DIMLTEX1)) {
457 DIMLTEX1 = parent->DIMLTEX1;
458 DIMLTEX1_linetype = parent->DIMLTEX1_linetype;
459 }
460 if (checkModifyState($DIMLTEX2)) {
461 DIMLTEX2 = parent->DIMLTEX2;
462 DIMLTEX2_linetype = parent->DIMLTEX2_linetype;
463 }
464 if (checkModifyState($DIMLWE)) {
465 DIMLWE = parent->DIMLWE;
466 }
467 if (checkModifyState($DIMSE1)) {
468 DIMSE1 = parent->DIMSE1;
469 }
470 if (checkModifyState($DIMSE2)) {
471 DIMSE2 = parent->DIMSE2;
472 }
473}
474
475void LC_DimStyle::ExtensionLine::setColor(const RS_Color &dimclre) {
476 checkModified(dimclre, DIMCLRE, $DIMCLRE);
477 DIMCLRE = dimclre;
478}
479
480void LC_DimStyle::ExtensionLine::setDistanceBeyondDimLine(const double dimexe) {
481 checkModified(dimexe, DIMEXE, $DIMEXE);
482 DIMEXE = dimexe;
483}
484
485void LC_DimStyle::ExtensionLine::setDistanceFromOriginPoint(const double dimexo) {
486 checkModified(dimexo, DIMEXO, $DIMEXO);
487 DIMEXO = dimexo;
488}
489
490void LC_DimStyle::ExtensionLine::setFixedLength(const double dimfxl) {
491 checkModified(dimfxl, DIMFXL, $DIMFXL);
492 DIMFXL = dimfxl;
493}
494
495void LC_DimStyle::ExtensionLine::setHasFixedLength(const bool dimfxlon) {
496 checkModified(dimfxlon, DIMFXLON, $DIMFXLON);
497 DIMFXLON = dimfxlon;
498}
499
500void LC_DimStyle::ExtensionLine::setLineWidth(const RS2::LineWidth dimlwe) {
501 checkModified(dimlwe, DIMLWE, $DIMLWE);
502 DIMLWE = dimlwe;
503}
504
505void LC_DimStyle::ExtensionLine::setLineTypeFirst(const QString& dimltex1) {
506 checkModified(dimltex1, DIMLTEX1, $DIMLTEX1);
507 DIMLTEX1_linetype = RS_FilterDXFRW::nameToLineType(dimltex1);
508 DIMLTEX1 = dimltex1;
509}
510
511void LC_DimStyle::ExtensionLine::setLineTypeSecond(const QString& dimltex2) {
512 checkModified(dimltex2, DIMLTEX2, $DIMLTEX2);
513 DIMLTEX2_linetype = RS_FilterDXFRW::nameToLineType(dimltex2);
514 DIMLTEX2 = dimltex2;
515}
516
517void LC_DimStyle::ExtensionLine::setLineTypeFirst(const RS2::LineType lineType) {
518 checkModified(lineType, DIMLTEX1_linetype, $DIMLTEX1);
519 DIMLTEX1_linetype = lineType;
520 DIMLTEX1 = RS_FilterDXFRW::lineTypeToName(lineType);
521}
522
523void LC_DimStyle::ExtensionLine::setLineTypeSecond(const RS2::LineType lineType) {
524 checkModified(lineType, DIMLTEX2_linetype, $DIMLTEX2);
525 // if (DIMLTEX2_linetype != lineType) {
526 // setFlag($DIMLTEX2);
527 // }
528 DIMLTEX2_linetype = lineType;
529 DIMLTEX2 = RS_FilterDXFRW::lineTypeToName(lineType);
530}
531
532void LC_DimStyle::ExtensionLine::setSuppressFirstLine(const ExtensionLineAndArrowSuppressionPolicy dimse1) {
533 checkModified(dimse1, DIMSE1, $DIMSE1);
534 DIMSE1 = dimse1;
535}
536
537void LC_DimStyle::ExtensionLine::setSuppressFirst(const bool v) {
538 setSuppressFirstLine(v ? SUPPRESS : DONT_SUPPRESS);
539}
540
541void LC_DimStyle::ExtensionLine::setSuppressSecondLine(const ExtensionLineAndArrowSuppressionPolicy dimse2) {
542 checkModified(dimse2, DIMSE2, $DIMSE2);
543 DIMSE2 = dimse2;
544}
545
546void LC_DimStyle::ExtensionLine::setSuppressSecond(const bool v) {
547 setSuppressSecondLine(v ? SUPPRESS : DONT_SUPPRESS);
548}
549
550void LC_DimStyle::Arrowhead::fillByDefaults() {
551 DIMASZ = 2.5;
552 DIMBLK = "";
553 DIMBLK1 = "";
554 DIMBLK2 = "";
555 DIMSAH = false;
556 DIMSOXD = DONT_SUPPRESS;
557 DIMTSZ = 0;
558}
559
560void LC_DimStyle::Arrowhead::copyTo(Arrowhead* c) const {
561 copyFlags(c);
562 c->DIMASZ = DIMASZ;
563 c->DIMBLK = DIMBLK;
564 c->DIMBLK1 = DIMBLK1;
565 c->DIMBLK2 = DIMBLK2;
566 c->DIMSAH = DIMSAH;
567 c->DIMSOXD = DIMSOXD;
568 c->DIMTSZ = DIMTSZ;
569}
570
571void LC_DimStyle::Arrowhead::merge(const Arrowhead* parent) {
572 if (checkModifyState($DIMASZ)) {
573 DIMASZ = parent->DIMASZ;
574 }
575 if (checkModifyState($DIMBLK)) {
576 DIMBLK = parent->DIMBLK;
577 }
578 if (checkModifyState($DIMBLK1)) {
579 DIMBLK1 =parent-> DIMBLK1;
580 }
581 if (checkModifyState($DIMBLK2)) {
582 DIMBLK2 = parent->DIMBLK2;
583 }
584 if (checkModifyState($DIMSAH)) {
585 DIMSAH = parent->DIMSAH;
586 }
587 if (checkModifyState($DIMSOXD)) {
588 DIMSOXD = parent->DIMSOXD;
589 }
590 if (checkModifyState($DIMTSZ)) {
591 DIMTSZ = parent->DIMTSZ;
592 }
593}
594
595QString LC_DimStyle::Arrowhead::obtainFirstArrowName() const {
596 auto result = arrowHeadBlockNameFirst();
597 if (result.isEmpty()) {
598 result = sameBlockName();
599 }
600 return result;
601}
602
603QString LC_DimStyle::Arrowhead::obtainSecondArrowName() const {
604 if (isUseSeparateArrowHeads()) {
605 return arrowHeadBlockNameSecond();
606 }
607 return obtainFirstArrowName();
608}
609
610void LC_DimStyle::Arrowhead::setSuppressions(const ArrowHeadSuppressionPolicy dimsoxd) {
611 checkModified(dimsoxd, DIMSOXD, $DIMSOXD);
612 DIMSOXD = dimsoxd;
613}
614
615void LC_DimStyle::Arrowhead::setSize(const double dimasz) {
616 checkModified(dimasz, DIMASZ, $DIMASZ);
617 DIMASZ = dimasz;
618}
619
620void LC_DimStyle::Arrowhead::setSameBlockName(const QString& dimblk) {
621 checkModified(dimblk, DIMBLK, $DIMBLK);
622 DIMBLK = dimblk;
623}
624
625void LC_DimStyle::Arrowhead::setArrowHeadBlockNameFirst(const QString& dimblk1) {
626 checkModified(dimblk1, DIMBLK1, $DIMBLK1);
627 DIMBLK1 = dimblk1;
628}
629
630void LC_DimStyle::Arrowhead::setArrowHeadBlockNameSecond(const QString& dimblk2) {
631 checkModified(dimblk2, DIMBLK2, $DIMBLK2);
632 DIMBLK2 = dimblk2;
633}
634
635void LC_DimStyle::Arrowhead::setUseSeparateArrowHeads(const bool dimsah) {
636 checkModified(dimsah, DIMSAH, $DIMSAH);
637 DIMSAH = dimsah;
638}
639
640void LC_DimStyle::Arrowhead::setTickSize(const double dimtsz) {
641 DIMTSZ = dimtsz;
642}
643
644void LC_DimStyle::ZerosSuppression::fillByDefaults() {
645 DIMZIN = TRAILING_IN_DECIMAL;
646 DIMAZIN = DONT_SUPPRESS;
647 DIMALTTZ = TOL_SUPPRESS_ZERO_FEET_AND_ZERO_INCHES;
648 DIMALTZ = SUPPRESS_ZERO_FEET_AND_ZERO_INCHES;
649 DIMTZIN = TRAILING_IN_DECIMAL;
650}
651
652void LC_DimStyle::ZerosSuppression::copyTo(ZerosSuppression* c) const {
653 copyFlags(c);
654 c->DIMZIN = DIMZIN;
655 c->DIMAZIN = DIMAZIN;
656 c->DIMALTTZ = DIMALTTZ;
657 c->DIMALTZ = DIMALTZ;
658 c->DIMTZIN = DIMTZIN;
659}
660
661void LC_DimStyle::ZerosSuppression::merge(const ZerosSuppression* parent) {
662 if (checkModifyState($DIMZIN)) {
663 DIMZIN = parent->DIMZIN;
664 }
665 if (checkModifyState($DIMAZIN)) {
666 DIMAZIN = parent->DIMAZIN;
667 }
668 if (checkModifyState($DIMALTZ)) {
669 DIMALTZ = parent->DIMALTZ;
670 }
671 if (checkModifyState($DIMALTTZ)) {
672 DIMALTTZ = parent->DIMALTTZ;
673 }
674 if (checkModifyState($DIMTZIN)) {
675 DIMTZIN = parent->DIMTZIN;
676 }
677}
678
679void LC_DimStyle::ZerosSuppression::setToleranceRaw(const int dimtzin) {
680 checkModified(dimtzin, DIMTZIN, $DIMTZIN);
681 DIMTZIN = dimtzin;
682}
683
684void LC_DimStyle::ZerosSuppression::setLinearRaw(const int dimzin) {
685 checkModified(dimzin, DIMZIN, $DIMZIN);
686 DIMZIN = dimzin;
687}
688
689void LC_DimStyle::ZerosSuppression::setAngularRaw(const int dimazin) {
690 checkModified(dimazin, DIMAZIN, $DIMAZIN);
691 DIMAZIN = dimazin;
692}
693
694void LC_DimStyle::ZerosSuppression::setAltLinearRaw(const int dimaltz) {
695 checkModified(dimaltz, DIMALTZ, $DIMALTZ);
696 DIMALTZ = dimaltz;
697}
698
699void LC_DimStyle::ZerosSuppression::setAltToleranceRaw(const int dimalttz) {
700 checkModified(dimalttz, DIMALTTZ, $DIMALTTZ);
701 DIMALTTZ = dimalttz;
702}
703
704void LC_DimStyle::LinearRoundOff::fillByDefaults() {
705 DIMALTRND = 0;
706 DIMRND = 0;
707}
708
709void LC_DimStyle::LinearRoundOff::copyTo(LinearRoundOff* c) const {
710 copyFlags(c);
711 c->DIMALTRND = DIMALTRND;
712 c->DIMRND = DIMRND;
713}
714
715void LC_DimStyle::LinearRoundOff::merge(const LinearRoundOff* parent) {
716 if (checkModifyState($DIMALTRND)) {
717 DIMALTRND = parent->DIMALTRND;
718 }
719 if (checkModifyState($DIMRND)) {
720 DIMRND = parent->DIMRND;
721 }
722}
723
724void LC_DimStyle::LinearRoundOff::setRoundToValue(const double dimrnd) {
725 checkModified(dimrnd, DIMRND, $DIMRND);
726 DIMRND = dimrnd;
727}
728
729void LC_DimStyle::LinearRoundOff::setAltRoundToValue(const double dimaltrnd) {
730 checkModified(dimaltrnd, DIMALTRND, $DIMALTRND);
731 DIMALTRND = dimaltrnd;
732}
733
734void LC_DimStyle::Scaling::fillByDefaults() {
735 DIMLFAC = 1.0;
736 DIMSCALE = 1.0;
737}
738
739void LC_DimStyle::Scaling::copyTo(Scaling* c) const {
740 copyFlags(c);
741 c->DIMLFAC = DIMLFAC;
742 c->DIMSCALE = DIMSCALE;
743}
744
745void LC_DimStyle::Scaling::merge(const Scaling* parent) {
746 if (checkModifyState($DIMLFAC)) {
747 DIMLFAC = parent->DIMLFAC;
748 }
749 if (checkModifyState($DIMSCALE)) {
750 DIMSCALE = parent->DIMSCALE;
751 }
752}
753
754void LC_DimStyle::Scaling::setLinearFactor(const double dimlfac) {
755 checkModified(dimlfac, DIMLFAC, $DIMLFAC);
756 DIMLFAC = dimlfac;
757}
758
759void LC_DimStyle::Scaling::setScale(const double dimscale) {
760 checkModified(dimscale, DIMSCALE, $DIMSCALE);
761 DIMSCALE = dimscale;
762}
763
764void LC_DimStyle::Fractions::fillByDefaults() {
765 DIMFRAC = HORIZONTAL;
766}
767
768void LC_DimStyle::Fractions::copyTo(Fractions* c) const {
769 copyFlags(c);
770 c->DIMFRAC = DIMFRAC;
771}
772
773void LC_DimStyle::Fractions::merge(const Fractions* parent) {
774 if (checkModifyState($DIMFRAC)) {
775 DIMFRAC = parent->DIMFRAC;
776 }
777}
778
779void LC_DimStyle::Fractions::setStyle(const FractionStylePolicy dimfrac) {
780 checkModified(dimfrac, DIMFRAC, $DIMFRAC);
781 DIMFRAC = dimfrac;
782}
783
784LC_DimStyle::LinearFormat::~LinearFormat() {
785 delete m_primaryPrefixSuffix;
786 delete m_alternativePrefixSuffix;
787}
788
789void LC_DimStyle::LinearFormat::fillByDefaults() {
790 DIMALT = DISABLE;
791 DIMALTD = 3;
792 DIMALTF = 0.03937;
793 DIMALTU = RS2::Decimal;
794 DIMAPOST = "";
795 DIMDEC = 2;
796 DIMDSEP = ',';
797 DIMLUNIT = RS2::Decimal;
798 DIMPOST = "";
799}
800
801void LC_DimStyle::LinearFormat::copyTo(LinearFormat* c) const {
802 copyFlags(c);
803 c->DIMALT = DIMALT;
804 c->DIMALTD = DIMALTD;
805 c->DIMALTF = DIMALTF;
806 c->DIMALTU = DIMALTU;
807 c->DIMAPOST = DIMAPOST;
808 c->DIMDEC = DIMDEC;
809 c->DIMDSEP = DIMDSEP;
810 c->DIMLUNIT = DIMLUNIT;
811 c->DIMPOST = DIMPOST;
812}
813
814void LC_DimStyle::LinearFormat::merge(const LinearFormat* parent) {
815 if (checkModifyState($DIMALT)) {
816 DIMALT = parent->DIMALT;
817 }
818 if (checkModifyState($DIMALTD)) {
819 DIMALTD = parent->DIMALTD;
820 }
821 if (checkModifyState($DIMALTF)) {
822 DIMALTF = parent->DIMALTF;
823 }
824 if (checkModifyState($DIMALTU)) {
825 DIMALTU = parent->DIMALTU;
826 }
827 if (checkModifyState($DIMAPOST)) {
828 DIMAPOST = parent->DIMAPOST;
829 }
830 if (checkModifyState($DIMDEC)) {
831 DIMDEC = parent->DIMDEC;
832 }
833 if (checkModifyState($DIMSEP)) {
834 DIMDSEP = parent->DIMDSEP;
835 }
836 if (checkModifyState($DIMLUNIT)) {
837 DIMLUNIT = parent->DIMLUNIT;
838 }
839 if (checkModifyState($DIMPOST)) {
840 DIMPOST = parent->DIMPOST;
841 }
842}
843
844void LC_DimStyle::LinearFormat::setAltUnitsMultiplier(const double dimaltf) {
845 checkModified(dimaltf, DIMALTF, $DIMALTF);
846 DIMALTF = dimaltf;
847}
848
849void LC_DimStyle::LinearFormat::setAlternateUnits(const AlternateUnitsPolicy dimalt) {
850 checkModified(dimalt, DIMALT, $DIMALT);
851 DIMALT = dimalt;
852}
853
854void LC_DimStyle::LinearFormat::setAltPrefixOrSuffix(const QString& dimapost) {
855 checkModified(dimapost, DIMAPOST, $DIMAPOST);
856 DIMAPOST = dimapost;
857}
858
859void LC_DimStyle::LinearFormat::setAltFormat(const RS2::LinearFormat dimaltu) {
860 checkModified(dimaltu, DIMALTU, $DIMALTU);
861 DIMALTU = dimaltu;
862}
863
864void LC_DimStyle::LinearFormat::setDecimalPlaces(const int dimdec) {
865 checkModified(dimdec, DIMDEC, $DIMDEC);
866 DIMDEC = dimdec;
867}
868
869void LC_DimStyle::LinearFormat::setAltDecimalPlaces(const int dimaltd) {
870 checkModified(dimaltd, DIMALTD, $DIMALTD);
871 DIMALTD = dimaltd;
872}
873
874void LC_DimStyle::LinearFormat::setDecimalFormatSeparatorChar(const int dimsep) {
875 checkModified(dimsep, DIMDSEP, $DIMSEP);
876 DIMDSEP = dimsep;
877}
878
879void LC_DimStyle::LinearFormat::setPrefixOrSuffix(const QString& dimpost) {
880 checkModified(dimpost, DIMPOST, $DIMPOST);
881 DIMPOST = dimpost;
882}
883
884void LC_DimStyle::LinearFormat::setFormat(const RS2::LinearFormat dimlunit) {
885 checkModified(dimlunit, DIMLUNIT, $DIMLUNIT);
886 DIMLUNIT = dimlunit;
887}
888
889LC_DimStyle::LinearFormat::TextPattern::TextPattern(const bool primary, const QString& text, LinearFormat* linearFormat) :
890 m_separator{primary ? "<>" : "[]"},
891 m_format{linearFormat},
892 m_forAltUnit{!primary} {
893 parse(text);
894}
895
896QString LC_DimStyle::LinearFormat::TextPattern::update() {
897 m_completeString = QString().append(m_prefix).append(m_separator).append(m_suffix).append(
898 m_suffixEndsWithLineFeed ? "\\X" : "");
899 if (m_forAltUnit) {
900 m_format->setAltPrefixOrSuffix(m_completeString);
901 }
902 else {
903 m_format->setPrefixOrSuffix(m_completeString);
904 }
905 return m_completeString;
906}
907
908void LC_DimStyle::LinearFormat::TextPattern::parse(const QString& val) {
909 m_prefix.clear();
910 m_suffix.clear();
911 m_completeString = val;
912 m_suffixEndsWithLineFeed = false;
913 if (!val.isEmpty()) {
914 const int pos = val.indexOf(m_separator);
915 if (pos > 0) {
916 m_prefix = val.left(pos);
917 m_suffix = val.mid(pos + 2);
918 if (m_suffix.endsWith("\\X")) {
919 m_suffix = m_suffix.left(m_suffix.length() - 1);
920 m_suffixEndsWithLineFeed = true;
921 }
922 }
923 }
924}
925
926QString LC_DimStyle::LinearFormat::TextPattern::getPrefix() {
927 return m_prefix;
928}
929
930QString LC_DimStyle::LinearFormat::TextPattern::getSuffix() {
931 return m_suffix;
932}
933
934bool LC_DimStyle::LinearFormat::TextPattern::isSuffixEndsWithLineFeed() const {
935 return m_suffixEndsWithLineFeed;
936}
937
938void LC_DimStyle::LinearFormat::TextPattern::setPrefix(const QString& p) {
939 m_prefix = p;
940 update();
941}
942
943void LC_DimStyle::LinearFormat::TextPattern::setSuffix(const QString& s) {
944 m_suffix = s;
945 update();
946}
947
948void LC_DimStyle::LinearFormat::TextPattern::setSuffixEndsWithNewLineFeed(const bool set) {
949 m_suffixEndsWithLineFeed = set;
950 update();
951}
952
953LC_DimStyle::LinearFormat::TextPattern* LC_DimStyle::LinearFormat::getPrimaryPrefixOrSuffix() {
954 if (m_primaryPrefixSuffix == nullptr) {
955 m_primaryPrefixSuffix = new TextPattern(true, DIMPOST, this);
956 }
957 return m_primaryPrefixSuffix;
958}
959
960LC_DimStyle::LinearFormat::TextPattern* LC_DimStyle::LinearFormat::getAlternativePrefixOrSuffix() {
961 if (m_alternativePrefixSuffix == nullptr) {
962 m_alternativePrefixSuffix = new TextPattern(false, DIMAPOST, this);
963 }
964 return m_alternativePrefixSuffix;
965}
966
967void LC_DimStyle::AngularFormat::fillByDefaults() {
968 DIMADEC = 0;
969 DIMAUNIT = RS2::DegreesDecimal;
970}
971
972void LC_DimStyle::AngularFormat::copyTo(AngularFormat* c) const {
973 copyFlags(c);
974 c->DIMADEC = DIMADEC;
975 c->DIMAUNIT = DIMAUNIT;
976}
977
978void LC_DimStyle::AngularFormat::merge(const AngularFormat* parent) {
979 if (checkModifyState($DIMADEC)) {
980 DIMADEC = parent->DIMADEC;
981 }
982 if (checkModifyState($DIMAUNIT)) {
983 DIMAUNIT = parent->DIMAUNIT;
984 }
985}
986
987void LC_DimStyle::AngularFormat::setDecimalPlaces(const int dimadec) {
988 checkModified(dimadec, DIMADEC, $DIMADEC);
989 DIMADEC = dimadec;
990}
991
992void LC_DimStyle::AngularFormat::setFormat(const RS2::AngleFormat dimaunit) {
993 checkModified(dimaunit, DIMAUNIT, $DIMAUNIT);
994 DIMAUNIT = dimaunit;
995}
996
997void LC_DimStyle::LatteralTolerance::fillByDefaults() {
998 DIMALTTD = 3;
999 DIMLIM = false;
1000 DIMTDEC = 2;
1001 DIMTFAC = 1.0;
1002 DIMTM = 0.0;
1003 DIMTOL = false;
1004 DIMTOLJ = BOTTOM;
1005 DIMTP = 0.0;
1006 DIMTALN = ALIGN_DECIMAL_SEPARATORS;
1007}
1008
1009void LC_DimStyle::LatteralTolerance::copyTo(LatteralTolerance* c) const {
1010 copyFlags(c);
1011 c->DIMALTTD = DIMALTTD;
1012 c->DIMLIM = DIMLIM;
1013 c->DIMTDEC = DIMTDEC;
1014 c->DIMTFAC = DIMTFAC;
1015 c->DIMTM = DIMTM;
1016 c->DIMTOL = DIMTOL;
1017 c->DIMTOLJ = DIMTOLJ;
1018 c->DIMTP = DIMTP;
1019 c->DIMTALN = DIMTALN;
1020}
1021
1022void LC_DimStyle::LatteralTolerance::merge(const LatteralTolerance* parent) {
1023 if (checkModifyState($DIMALTTD)) {
1024 DIMALTTD = parent->DIMALTTD;
1025 }
1026 if (checkModifyState($DIMLIM)) {
1027 DIMLIM = parent->DIMLIM;
1028 }
1029 if (checkModifyState($DIMTDEC)) {
1030 DIMTDEC = parent->DIMTDEC;
1031 }
1032 if (checkModifyState($DIMTFAC)) {
1033 DIMTFAC = parent->DIMTFAC;
1034 }
1035 if (checkModifyState($DIMTM)) {
1036 DIMTM = parent->DIMTM;
1037 }
1038 if (checkModifyState($DIMTOL)) {
1039 DIMTOL = parent->DIMTOL;
1040 }
1041 if (checkModifyState($DIMTOLJ)) {
1042 DIMTOLJ = parent->DIMTOLJ;
1043 }
1044 if (checkModifyState($DIMTP)) {
1045 DIMTP = parent->DIMTP;
1046 }
1047 if (checkModifyState($DIMTALN)) {
1048 DIMTALN = parent->DIMTALN;
1049 }
1050}
1051
1052void LC_DimStyle::LatteralTolerance::setAdjustment(const AdjustmentMode dimtaln) {
1053 checkModified(dimtaln, DIMTALN, $DIMTALN);
1054 DIMTALN = dimtaln;
1055}
1056
1057void LC_DimStyle::LatteralTolerance::setAdjustmentRaw(const int dimtaln) {
1058 AdjustmentMode align;
1059 switch (dimtaln) {
1060 case 0:
1061 align = ALIGN_DECIMAL_SEPARATORS;
1062 break;
1063 case 1:
1064 align = ALIGN_OPERATIONAL_SYMBOLS;
1065 break;
1066 default:
1067 align = ALIGN_DECIMAL_SEPARATORS;
1068 break;
1069 }
1070 setAdjustment(align);
1071}
1072
1073void LC_DimStyle::LatteralTolerance::setDecimalPlacesAltDim(const int dimalttd) {
1074 checkModified(dimalttd, DIMALTTD, $DIMALTTD);
1075 DIMALTTD = dimalttd;
1076}
1077
1078void LC_DimStyle::LatteralTolerance::setLimitsAreGeneratedAsDefaultText(const bool dimlim) {
1079 checkModified(dimlim, DIMLIM, $DIMLIM);
1080 DIMLIM = dimlim;
1081}
1082
1083void LC_DimStyle::LatteralTolerance::setDecimalPlaces(const int dimtdec) {
1084 checkModified(dimtdec, DIMTDEC, $DIMTDEC);
1085 DIMTDEC = dimtdec;
1086}
1087
1088void LC_DimStyle::LatteralTolerance::setHeightScaleFactorToDimText(const double dimtfac) {
1089 checkModified(dimtfac, DIMTFAC, $DIMTFAC);
1090 DIMTFAC = dimtfac;
1091}
1092
1093void LC_DimStyle::LatteralTolerance::setLowerToleranceLimit(const double dimtm) {
1094 checkModified(dimtm, DIMTM, $DIMTM);
1095 DIMTM = dimtm;
1096}
1097
1098void LC_DimStyle::LatteralTolerance::setAppendTolerancesToDimText(const bool dimtol) {
1099 checkModified(dimtol, DIMTOL, $DIMTOL);
1100 DIMTOL = dimtol;
1101}
1102
1103void LC_DimStyle::LatteralTolerance::setUpperToleranceLimit(const double dimtp) {
1104 checkModified(dimtp, DIMTP, $DIMTP);
1105 DIMTP = dimtp;
1106}
1107
1108void LC_DimStyle::LatteralTolerance::setVerticalJustification(const VerticalJustificationToDimText dimtolj) {
1109 checkModified(dimtolj, DIMTOLJ, $DIMTOLJ);
1110 DIMTOLJ = dimtolj;
1111}
1112
1113void LC_DimStyle::Leader::fillByDefaults() {
1114 DIMLDRBLK = "";
1115}
1116
1117void LC_DimStyle::Leader::copyTo(Leader* c) const {
1118 copyFlags(c);
1119 c->DIMLDRBLK = DIMLDRBLK;
1120}
1121
1122void LC_DimStyle::Leader::merge(const Leader* parent) {
1123 if (checkModifyState($DIMLDRBLK)) {
1124 DIMLDRBLK = parent->DIMLDRBLK;
1125 }
1126}
1127
1128void LC_DimStyle::Leader::setArrowBlockName(const QString& dimldrblk) {
1129 checkModified(dimldrblk, DIMLDRBLK, $DIMLDRBLK);
1130 DIMLDRBLK = dimldrblk;
1131}
1132
1133void LC_DimStyle::MLeader::fillByDefaults() {
1134 MLEADERSCALE = 1.0;
1135}
1136
1137void LC_DimStyle::MLeader::copyTo(MLeader* c) const {
1138 copyFlags(c);
1139 c->MLEADERSCALE = MLEADERSCALE;
1140}
1141
1142// fixme - remove to MLEADERStyle
1143void LC_DimStyle::MLeader::merge(const MLeader* parent) {
1144 if (checkModifyState($MLEADERSCALE)) {
1145 MLEADERSCALE = parent->MLEADERSCALE;
1146 }
1147}
1148
1149void LC_DimStyle::MLeader::setScale(const double mleaderscale) {
1150 checkModified(mleaderscale, MLEADERSCALE, $MLEADERSCALE);
1151 MLEADERSCALE = mleaderscale;
1152}
1153
1154void LC_DimStyle::Radial::fillByDefaults() {
1155 DIMCEN = 2.5;
1156 DIMJOGANG = 45;
1157}
1158
1159void LC_DimStyle::Radial::copyTo(Radial* c) const {
1160 copyFlags(c);
1161 c->DIMCEN = DIMCEN;
1162 c->DIMJOGANG = DIMJOGANG;
1163}
1164
1165void LC_DimStyle::Radial::merge(const Radial* parent) {
1166 if (checkModifyState($DIMCEN)) {
1167 DIMCEN = parent->DIMCEN;
1168 }
1169 if (checkModifyState($DIMJOGANG)) {
1170 DIMJOGANG = parent->DIMJOGANG;
1171 }
1172}
1173
1174void LC_DimStyle::Radial::setCenterMarkOrLineSize(const double dimcen) {
1175 checkModified(dimcen, DIMCEN, $DIMCEN);
1176 DIMCEN = dimcen;
1177}
1178
1179void LC_DimStyle::Arc::fillByDefaults() {
1180 DIMARCSYM = BEFORE;
1181}
1182
1183void LC_DimStyle::Arc::copyTo(Arc* c) const {
1184 copyFlags(c);
1185 c->DIMARCSYM = DIMARCSYM;
1186}
1187
1188void LC_DimStyle::Arc::merge(const Arc* parent) {
1189 if (checkModifyState($DIMARCSYM)) {
1190 DIMARCSYM = parent->DIMARCSYM;
1191 }
1192}
1193
1194void LC_DimStyle::Arc::setArcSymbolPosition(const DimArcSymbolPositionPolicy dimarcsym) {
1195 checkModified(dimarcsym, DIMARCSYM, $DIMARCSYM);
1196 DIMARCSYM = dimarcsym;
1197}
1198
1199void LC_DimStyle::Arc::setArcSymbolPositionRaw(const int dimarcsym) {
1200 DimArcSymbolPositionPolicy mode;
1201 switch (dimarcsym) {
1202 case 0: {
1203 mode = BEFORE;
1204 break;
1205 }
1206 case 1: {
1207 mode = ABOVE;
1208 break;
1209 }
1210 case 2: {
1211 mode = NONE;
1212 break;
1213 }
1214 default:
1215 mode = BEFORE;
1216 break;
1217 }
1218 setArcSymbolPosition(mode);
1219}
1220
1221void LC_DimStyle::DimensionLine::setLineWidthRaw(const int dimlwd) {
1222 const auto lineWidth = RS2::dxfInt2lineWidth(dimlwd);
1223 setLineWidth(lineWidth);
1224}
1225
1226void LC_DimStyle::ExtensionLine::setLineWidthRaw(const int dimlwe) {
1227 const RS2::LineWidth _dimlwe = RS2::dxfInt2lineWidth(dimlwe);
1228 setLineWidth(_dimlwe);
1229}
1230
1231void LC_DimStyle::ExtensionLine::setSuppressFirstRaw(const int dimse1) {
1232 const auto policy = int2SuppressionPolicy(dimse1);
1233 setSuppressFirstLine(policy);
1234}
1235
1236void LC_DimStyle::ExtensionLine::setSuppressSecondRaw(const int dimse2) {
1237 const auto policy = int2SuppressionPolicy(dimse2);
1238 setSuppressSecondLine(policy);
1239}
1240
1241LC_DimStyle::ExtensionLine::ExtensionLineAndArrowSuppressionPolicy
1242 LC_DimStyle::ExtensionLine::int2SuppressionPolicy(const int dimsoxd) {
1243 switch (dimsoxd) {
1244 case 0: {
1245 return DONT_SUPPRESS;
1246 }
1247 case 1: {
1248 return SUPPRESS;
1249 }
1250 default: {
1251 return DONT_SUPPRESS;
1252 }
1253 }
1254}
1255
1256void LC_DimStyle::Arrowhead::setSuppressionsRaw(const int dimsoxd) {
1257 ArrowHeadSuppressionPolicy policy;
1258 switch (dimsoxd) {
1259 case 0: {
1260 policy = DONT_SUPPRESS;
1261 break;
1262 }
1263 case 1: {
1264 policy = SUPPRESS;
1265 break;
1266 }
1267 default: {
1268 policy = DONT_SUPPRESS;
1269 break;
1270 }
1271 }
1272 setSuppressions(policy);
1273}
1274
1275void LC_DimStyle::Radial::setTransverseSegmentAngleInJoggedRadius(const double dimjogang) {
1276 checkModified(dimjogang, DIMJOGANG, $DIMJOGANG);
1277 DIMJOGANG = dimjogang;
1278}
1279
1280LC_DimStyle::Radial::CenterMarkDrawingMode LC_DimStyle::Radial::drawingMode() const {
1281 // For DIMDIAMETER and DIMRADIUS, the center mark is drawn only if you place the dimension line outside the circle or arc.
1282 // 0 No center marks or lines are drawn
1283 // <0 Centerlines are drawn
1284 // >0 Center marks are drawn
1285
1286 if (LC_LineMath::isNotMeaningful(DIMCEN)) {
1287 return DRAW_NOTHING;
1288 }
1289 return std::signbit(DIMCEN) ? DRAW_CENTERLINES : DRAW_CENTERMARKS;
1290}
1291
1292void LC_DimStyle::setName(const QString& name) {
1293 m_name = name;
1294}
1295
1296void LC_DimStyle::Text::setUnsufficientSpacePolicyRaw(const int dimatfit) {
1297 TextAndArrowUnsufficientSpaceArrangementPolicy _dimatfit;
1298 switch (dimatfit) {
1299 case 0: {
1300 _dimatfit = OUTSIDE_EXT_LINES;
1301 break;
1302 }
1303 case 1: {
1304 _dimatfit = ARROW_FIRST_THEN_TEXT;
1305 break;
1306 }
1307 case 2: {
1308 _dimatfit = TEXT_FIRST_THEN_ARROW;
1309 break;
1310 }
1311 case 3: {
1312 _dimatfit = EITHER_TEXT_OR_ARROW;
1313 break;
1314 }
1315 default:
1316 _dimatfit = EITHER_TEXT_OR_ARROW;
1317 break;
1318 }
1319 setUnsufficientSpacePolicy(_dimatfit);
1320}
1321
1322void LC_DimStyle::Text::setPositionMovementPolicyRaw(const int dimtmove) {
1323 TextMovementPolicy _dimtmove;
1324 switch (dimtmove) {
1325 case 0: {
1326 _dimtmove = DIM_LINE_WITH_TEXT;
1327 break;
1328 }
1329 case 1: {
1330 _dimtmove = ADDS_LEADER;
1331 break;
1332 }
1333 case 2: {
1334 _dimtmove = ALLOW_FREE_POSITIONING;
1335 break;
1336 }
1337 default:
1338 _dimtmove = DIM_LINE_WITH_TEXT;
1339 break;
1340 }
1341 setPositionMovementPolicy(_dimtmove);
1342}
1343
1344void LC_DimStyle::Text::setCursorControlPolicyRaw(const int dimupt) {
1345 CursorControlPolicy _dimupt;
1346 switch (dimupt) {
1347 case 0: {
1348 _dimupt = DIM_LINE_LOCATION_ONLY;
1349 break;
1350 }
1351 case 1: {
1352 _dimupt = TEXT_AND_DIM_LINE_LOCATION;
1353 break;
1354 }
1355 default:
1356 _dimupt = DIM_LINE_LOCATION_ONLY;
1357 break;
1358 }
1359 setCursorControlPolicy(_dimupt);
1360}
1361
1362void LC_DimStyle::Text::setBackgroundFillModeRaw(const int dimtfill) {
1363 BackgroundColorPolicy _dimtfill;
1364 switch (dimtfill) {
1365 case 0: {
1366 _dimtfill = NONE;
1367 break;
1368 }
1369 case 1: {
1370 _dimtfill = DRAWING;
1371 break;
1372 }
1373 case 2: {
1374 _dimtfill = EXPLICIT;
1375 break;
1376 }
1377 default:
1378 _dimtfill = NONE;
1379 break;
1380 }
1381
1382 setBackgroundFillMode(_dimtfill);
1383}
1384
1385void LC_DimStyle::Text::setExtLinesRelativePlacementRaw(const int dimtix) {
1386 PlacementRelatedToExtLinesPolicy _dimtix;
1387 switch (dimtix) {
1388 case 0: {
1389 _dimtix = PLACE_BETWEEN_IF_SUFFICIENT_ROOM;
1390 break;
1391 }
1392 case 1: {
1393 _dimtix = PLACE_ALWAYS_INSIDE;
1394 break;
1395 }
1396 default:
1397 _dimtix = PLACE_BETWEEN_IF_SUFFICIENT_ROOM;
1398 break;
1399 }
1400 setExtLinesRelativePlacement(_dimtix);
1401}
1402
1403void LC_DimStyle::Text::setVerticalPositioningRaw(const int dimtad) {
1404 VerticalPositionPolicy _dimtad;
1405 switch (dimtad) {
1406 case 0: {
1407 _dimtad = CENTER_BETWEEN_EXT_LINES;
1408 break;
1409 }
1410 case 1: {
1411 _dimtad = ABOVE_DIM_LINE_EXCEPT_NOT_HORIZONTAL;
1412 break;
1413 }
1414 case 2: {
1415 _dimtad = FAREST_SIDE_FROM_DEF_POINTS;
1416 break;
1417 }
1418 case 3: {
1419 _dimtad = JIS_POSTION;
1420 break;
1421 }
1422 case 4: {
1423 _dimtad = BELOW_DIMENSION_LINE;
1424 break;
1425 }
1426 default:
1427 _dimtad = ABOVE_DIM_LINE_EXCEPT_NOT_HORIZONTAL;
1428 break;
1429 }
1430 setVerticalPositioning(_dimtad);
1431}
1432
1433void LC_DimStyle::Text::setHorizontalPositioningRaw(const int dimjust) {
1434 HorizontalPositionPolicy _dimjust;
1435 switch (dimjust) {
1436 case 0: {
1437 _dimjust = ABOVE_AND_CENTERED;
1438 break;
1439 }
1440 case 1: {
1441 _dimjust = NEXT_TO_EXT_ONE;
1442 break;
1443 }
1444 case 2: {
1445 _dimjust = NEXT_TO_EXT_TWO;
1446 break;
1447 }
1448 case 3: {
1449 _dimjust = ABOVE_ALIGN_EXT_ONE;
1450 break;
1451 }
1452 case 4: {
1453 _dimjust = ABOVE_ALIGN_EXT_TWO;
1454 break;
1455 }
1456 default:
1457 _dimjust = ABOVE_AND_CENTERED;
1458 break;
1459 }
1460 setHorizontalPositioning(_dimjust);
1461}
1462
1463void LC_DimStyle::Text::setOrientationInsideRaw(const int dimtih) {
1464 TextOrientationPolicy _dimtih;
1465 switch (dimtih) {
1466 case 0: {
1467 _dimtih = ALIGN_WITH_DIM_LINE;
1468 break;
1469 }
1470 case 1: {
1471 _dimtih = DRAW_HORIZONTALLY;
1472 break;
1473 }
1474 default:
1475 _dimtih = DRAW_HORIZONTALLY;
1476 break;
1477 }
1478 setOrientationInside(_dimtih);
1479}
1480
1481void LC_DimStyle::Text::setOrientationOutsideRaw(const int dimtoh) {
1482 TextOrientationPolicy _dimtoh;
1483 switch (dimtoh) {
1484 case 0: {
1485 _dimtoh = ALIGN_WITH_DIM_LINE;
1486 break;
1487 }
1488 case 1: {
1489 _dimtoh = DRAW_HORIZONTALLY;
1490 break;
1491 }
1492 default:
1493 _dimtoh = DRAW_HORIZONTALLY;
1494 break;
1495 }
1496 setOrientationOutside(_dimtoh);
1497}
1498
1499void LC_DimStyle::DimensionLine::setDrawPolicyForOutsideTextRaw(const int dimtofl) {
1500 DrawPolicyForOutsideText _dimtofl;
1501 switch (dimtofl) {
1502 case 0: {
1503 _dimtofl = DONT_DRAW_IF_ARROWHEADS_ARE_OUTSIDE;
1504 break;
1505 }
1506 case 1: {
1507 _dimtofl = DRAW_EVEN_IF_ARROWHEADS_ARE_OUTSIDE;
1508 break;
1509 }
1510 default:
1511 _dimtofl = DRAW_EVEN_IF_ARROWHEADS_ARE_OUTSIDE;
1512 break;
1513 }
1514 setDrawPolicyForOutsideText(_dimtofl);
1515}
1516
1517void LC_DimStyle::DimensionLine::setSuppressSecondLineRaw(const int dimsd2) {
1518 DimLineAndArrowSuppressionPolicy _dimsd2;
1519 switch (dimsd2) {
1520 case 0: {
1521 _dimsd2 = DONT_SUPPRESS;
1522 break;
1523 }
1524 case 1: {
1525 _dimsd2 = SUPPRESS;
1526 break;
1527 }
1528 default:
1529 _dimsd2 = DONT_SUPPRESS;
1530 break;
1531 }
1532 setSuppressSecondLine(_dimsd2);
1533}
1534
1535void LC_DimStyle::DimensionLine::setSuppressFirstLineRaw(const int dimsd1) {
1536 DimLineAndArrowSuppressionPolicy _dimsd1;
1537 switch (dimsd1) {
1538 case 0: {
1539 _dimsd1 = DONT_SUPPRESS;
1540 break;
1541 }
1542 case 1: {
1543 _dimsd1 = SUPPRESS;
1544 break;
1545 }
1546 default:
1547 _dimsd1 = DONT_SUPPRESS;
1548 break;
1549 }
1550 setSuppressFirstLine(_dimsd1);
1551}
1552
1553void LC_DimStyle::Fractions::setStyleRaw(const int dimfrac) {
1554 FractionStylePolicy _dimfrac;
1555 switch (dimfrac) {
1556 case 0: {
1557 _dimfrac = HORIZONTAL;
1558 break;
1559 }
1560 case 1: {
1561 _dimfrac = DIAGONAL_STACKING;
1562 break;
1563 }
1564 case 2: {
1565 _dimfrac = NOT_STACKED;
1566 break;
1567 }
1568 default:
1569 _dimfrac = HORIZONTAL;
1570 break;
1571 }
1572 setStyle(_dimfrac);
1573}
1574
1575void LC_DimStyle::LinearFormat::setAltFormatRaw(const int dimaltu) {
1576 const RS2::LinearFormat _dimaltu = dxfInt2LinearFormat(dimaltu);
1577 setAltFormat(_dimaltu);
1578}
1579
1580RS2::LinearFormat LC_DimStyle::LinearFormat::dxfInt2LinearFormat(const int f) {
1581 switch (f) {
1582 case 1:
1583 return RS2::Scientific;
1584 case 2:
1585 return RS2::Decimal;
1586 case 3:
1587 return RS2::Engineering;
1588 case 4:
1589 return RS2::Architectural;
1590 case 5:
1591 return RS2::Fractional;
1592 case 6:
1593 return RS2::ArchitecturalMetric;
1594 default:
1595 return RS2::Decimal;
1596 }
1597}
1598
1599int LC_DimStyle::LinearFormat::linearFormat2dxf(const RS2::LinearFormat f) {
1600 switch (f) {
1601 case RS2::Scientific:
1602 return 1;
1603 case RS2::Decimal:
1604 return 2;
1605 case RS2::Engineering:
1606 return 3;
1607 case RS2::Architectural:
1608 return 4;
1609 case RS2::Fractional:
1610 return 5;
1611 case RS2::ArchitecturalMetric:
1612 return 6;
1613 default:
1614 return 2;
1615 }
1616}
1617
1618void LC_DimStyle::LinearFormat::setAlternateUnitsRaw(const int dimalt) {
1619 AlternateUnitsPolicy _dimalt;
1620 switch (dimalt) {
1621 case 0: {
1622 _dimalt = DISABLE;
1623 break;
1624 }
1625 case 1: {
1626 _dimalt = ENABLE;
1627 break;
1628 }
1629 default:
1630 _dimalt = DISABLE;
1631 break;
1632 }
1633 setAlternateUnits(_dimalt);
1634}
1635
1636void LC_DimStyle::LinearFormat::setFormatRaw(const int dimlunit) {
1637 const RS2::LinearFormat _dimlunit = dxfInt2LinearFormat(dimlunit);
1638 setFormat(_dimlunit);
1639}
1640
1641int LC_DimStyle::LinearFormat::formatRaw() const {
1642 return linearFormat2dxf(DIMLUNIT);
1643}
1644
1645int LC_DimStyle::LinearFormat::altFormatRaw() const {
1646 return linearFormat2dxf(DIMALTU);
1647}
1648
1649void LC_DimStyle::AngularFormat::setFormatRaw(const int dimaunit) {
1650 RS2::AngleFormat _dimaunit;
1651 switch (dimaunit) {
1652 case 0:
1653 _dimaunit = RS2::DegreesDecimal;
1654 break;
1655 case 1:
1656 _dimaunit = RS2::DegreesMinutesSeconds;
1657 break;
1658 case 2:
1659 _dimaunit = RS2::Gradians;
1660 break;
1661 case 3:
1662 _dimaunit = RS2::Radians;
1663 break;
1664 case 4:
1665 _dimaunit = RS2::Surveyors;
1666 break;
1667 default:
1668 _dimaunit = RS2::DegreesDecimal;
1669 break;
1670 }
1671 setFormat(_dimaunit);
1672}
1673
1674void LC_DimStyle::LatteralTolerance::setVerticalJustificationRaw(const int dimtolj) {
1675 VerticalJustificationToDimText _dimtolj{BOTTOM};
1676 switch (dimtolj) {
1677 case 0:
1678 _dimtolj = BOTTOM;
1679 break;
1680 case 1:
1681 _dimtolj = MIDDLE;
1682 break;
1683 case 2:
1684 _dimtolj = TOP;
1685 break;
1686 default:
1687 _dimtolj = BOTTOM;
1688 break;
1689 }
1690 setVerticalJustification(_dimtolj);
1691}
1692
1693void LC_DimStyle::Text::setReadingDirectionRaw(const int dimtxtdirection) {
1694 TextDirection _dimtxtdirection{LEFT_TO_RIGHT};
1695 switch (dimtxtdirection) {
1696 case 0: {
1697 _dimtxtdirection = LEFT_TO_RIGHT;
1698 break;
1699 }
1700 case 1: {
1701 _dimtxtdirection = RIGHT_TO_LEFT;
1702 break;
1703 }
1704 default: {
1705 _dimtxtdirection = LEFT_TO_RIGHT;
1706 break;
1707 }
1708 }
1709 setReadingDirection(_dimtxtdirection);
1710}
1711
1712void LC_DimStyle::Text::setExplicitBackgroundFillColor(const RS_Color& dimtfillclr) {
1713 checkModified(dimtfillclr, DIMTFILLCLR, $DIMTFILLCLR);
1714 DIMTFILLCLR = dimtfillclr;
1715}
1716
1717void LC_DimStyle::Text::setUnsufficientSpacePolicy(const TextAndArrowUnsufficientSpaceArrangementPolicy dimatfit) {
1718 checkModified(dimatfit, DIMATFIT, $DIMATFIT);
1719 DIMATFIT = dimatfit;
1720}
1721
1722void LC_DimStyle::Text::setExtLinesRelativePlacement(const PlacementRelatedToExtLinesPolicy dimtix) {
1723 checkModified(dimtix, DIMTIX, $DIMTIX);
1724 DIMTIX = dimtix;
1725}
1726
1727void LC_DimStyle::Text::setBackgroundFillMode(const BackgroundColorPolicy dimtfill) {
1728 checkModified(dimtfill, DIMTFILL, $DIMTFILL);
1729 DIMTFILL = dimtfill;
1730}
1731
1732void LC_DimStyle::Text::setHorizontalPositioning(const HorizontalPositionPolicy dimjust) {
1733 checkModified(dimjust, DIMJUST, $DIMJUST);
1734 DIMJUST = dimjust;
1735}
1736
1737void LC_DimStyle::Text::setVerticalPositioning(const VerticalPositionPolicy dimtad) {
1738 checkModified(dimtad, DIMTAD, $DIMTAD);
1739 DIMTAD = dimtad;
1740}
1741
1742void LC_DimStyle::Text::setVerticalDistanceToDimLine(const double dimtvp) {
1743 checkModified(dimtvp, DIMTVP, $DIMTVP);
1744 DIMTVP = dimtvp;
1745}
1746
1747void LC_DimStyle::Text::setOrientationInside(const TextOrientationPolicy dimtih) {
1748 checkModified(dimtih, DIMTIH, $DIMTIH);
1749 DIMTIH = dimtih;
1750}
1751
1752void LC_DimStyle::Text::setOrientationOutside(const TextOrientationPolicy dimtoh) {
1753 checkModified(dimtoh, DIMTOH, $DIMTOH);
1754 DIMTOH = dimtoh;
1755}
1756
1757void LC_DimStyle::Text::setStyle(const QString& dimtxsty) {
1758 checkModified(dimtxsty, DIMTXSTY, $DIMTXSTY);
1759 DIMTXSTY = dimtxsty;
1760}
1761
1762void LC_DimStyle::Text::setColor(const RS_Color& dimclrt) {
1763 checkModified(dimclrt, DIMCLRT, $DIMCLRT);
1764 DIMCLRT = dimclrt;
1765}
1766
1767void LC_DimStyle::Text::setHeight(const double dimtxt) {
1768 checkModified(dimtxt, DIMTXT, $DIMTXT);
1769 DIMTXT = dimtxt;
1770}
1771
1772void LC_DimStyle::Text::setReadingDirection(const TextDirection dimtxtdirection) {
1773 checkModified(dimtxtdirection, DIMTXTDIRECTION, $DIMTXTDIRECTION);
1774 DIMTXTDIRECTION = dimtxtdirection;
1775}
1776
1777void LC_DimStyle::Text::setPositionMovementPolicy(const TextMovementPolicy dimtmove) {
1778 checkModified(dimtmove, DIMTMOVE, $DIMTMOVE);
1779 DIMTMOVE = dimtmove;
1780}
1781
1782void LC_DimStyle::Text::setCursorControlPolicy(const CursorControlPolicy dimupt) {
1783 checkModified(dimupt, DIMUPT, $DIMUPT);
1784 DIMUPT = dimupt;
1785}
1786
1787QString LC_DimStyle::getStyleNameForBaseAndType(const QString& baseName, const RS2::EntityType dimType) {
1788 return baseName + getDimStyleNameSuffixForType(dimType);
1789}
1790
1791QString LC_DimStyle::getDimStyleNameSuffixForType(const RS2::EntityType dimType) {
1792 switch (dimType) {
1793 case RS2::EntityDimLinear:
1794 // fixme - sand - is there difference between 0 and 1? ACAD uses only 1 but supports both
1795 return "$0";
1796 case RS2::EntityDimAligned:
1797 return "$1";
1798 case RS2::EntityDimAngular:
1799 return "$2";
1800 case RS2::EntityDimDiametric:
1801 return "$3";
1802 case RS2::EntityDimRadial:
1803 return "$4";
1804 case RS2::EntityDimOrdinate:
1805 return "$5";
1806 case RS2::EntityTolerance: // fixme - sand - are 6 and 7 the same? Acad uses only 7
1807 return "$6";
1808 case RS2::EntityDimLeader:
1809 return "$7";
1810 default:
1811 return "";
1812 }
1813}
1814
1815void LC_DimStyle::parseStyleName(const QString& fullName, QString& baseName, RS2::EntityType& dimensionType) {
1816 const qsizetype pos = fullName.indexOf(NAME_SEPARATOR);
1817 if (pos > 0) {
4
←
Assuming 'pos' is > 0
→
5
←
Taking true branch
→
1818 baseName = fullName.left(pos);
1819 const QString suffix = fullName.mid(pos + 1);
1820 if (suffix == "0" || suffix == "1") {
6
←
Taking false branch
→
1821 dimensionType = RS2::EntityDimLinear;
1822 }
1823 else if (suffix == "2") {
7
←
Taking false branch
→
1824 dimensionType = RS2::EntityDimAngular;
1825 }
1826 else if (suffix == "3") {
8
←
Taking false branch
→
1827 dimensionType = RS2::EntityDimDiametric;
1828 }
1829 else if (suffix == "4") {
9
←
Taking false branch
→
1830 dimensionType = RS2::EntityDimRadial;
1831 }
1832 else if (suffix == "5") {
1833 dimensionType = RS2::EntityDimOrdinate;
1834 }
1835 else if (suffix == "6" || suffix == "7") {
10
←
Taking false branch
→
1836 dimensionType = RS2::EntityDimLeader;
1837 }
1838 }
1839 else {
1840 baseName = fullName;
1841 dimensionType = RS2::EntityUnknown;
1842 }
1843}
11
←
Returning without writing to 'dimensionType'
→
1844
1845RS2::EntityType LC_DimStyle::getDimensionType() const {
1846 RS2::EntityType type;
2
←
'type' declared without an initial value
→
1847 QString baseName;
1848 parseStyleName(m_name, baseName, type);
3
←
Calling 'LC_DimStyle::parseStyleName'
→
12
←
Returning from 'LC_DimStyle::parseStyleName'
→
1849 return type;
13
←
Undefined or garbage value returned to caller
1850}
1851
1852QString LC_DimStyle::getBaseName() const {
1853 RS2::EntityType type;
1854 QString baseName;
1855 parseStyleName(m_name, baseName, type);
1856 return baseName;
1857}
1858
1859bool LC_DimStyle::isBaseStyle() const {
1860 const int dimensionType = getDimensionType();
1
Calling 'LC_DimStyle::getDimensionType'
→
1861 return dimensionType == RS2::EntityUnknown;
1862}
1863
1864bool LC_DimStyle::ModificationAware::checkModifyState(const unsigned f) const {
1865 switch (m_checkModificationMode) {
1866 case ALL:
1867 return true;
1868 case SET:
1869 return isSet(f);
1870 case UNSET:
1871 return isNotSet(f);
1872 default:
1873 return true;
1874 }
1875}
1876
1877void LC_DimStyle::ModificationAware::checkModified(const RS_Color &newValue, const RS_Color &currentValue, const unsigned flag) {
1878 if (!newValue.isEqualIgnoringFlags(currentValue) || m_checkModificationMode == ALL) {
1879 setFlag(flag);
1880 }
1881}
1882
1883void LC_DimStyle::ModificationAware::checkModified(const double newValue, const double currentValue, const unsigned flag) {
1884 if (RS_Math::notEqual(newValue, currentValue, RS_TOLERANCE1.0e-10) || m_checkModificationMode == ALL) {
1885 setFlag(flag);
1886 }
1887}
1888
1889void LC_DimStyle::ModificationAware::checkModified(const int newValue, const int currentValue, const unsigned flag) {
1890 if (newValue != currentValue || m_checkModificationMode == ALL) {
1891 setFlag(flag);
1892 }
1893}
1894
1895void LC_DimStyle::ModificationAware::checkModified(const short newValue, const short currentValue, const unsigned flag) {
1896 if (newValue != currentValue || m_checkModificationMode == ALL) {
1897 setFlag(flag);
1898 }
1899}
1900
1901void LC_DimStyle::ModificationAware::checkModified(const bool newValue, const bool currentValue, const unsigned flag) {
1902 if (newValue != currentValue || m_checkModificationMode == ALL) {
1903 setFlag(flag);
1904 }
1905}
1906
1907void LC_DimStyle::ModificationAware::checkModified(const QString& newValue, const QString& currentValue, const unsigned flag) {
1908 if (newValue != currentValue || m_checkModificationMode == ALL) {
1909 setFlag(flag);
1910 }
1911}
1912
1913void LC_DimStyle::ModificationAware::copyFlags(ModificationAware* c) const {
1914 c->setFlags(getFlags());
1915}