1 /*
2 Copyright (C) 2019-2021, Dirk Krause
3 SPDX-License-Identifier: BSD-3-Clause
4 */
5
6 /*
7 WARNING: This file was generated by the dkct program (see
8 http://dktools.sourceforge.net/ for details).
9 Changes you make here will be lost if dkct is run again!
10 You should modify the original source and run dkct on it.
11 Original source: WxdkdrawMouse.cpt
12 */
13
14 /** @file WxdkdrawMouse.cpp The WxdkdrawMouse module.
15 */
16
17
18 #include <wxdkdraw/wxdkdraw.h>
19
20 #ifndef WXDKDRAWAPPH_INCLUDED
21 #include <wxdkdraw/WxdkdrawApp.h>
22 #endif
23 #ifndef WXDKDRAWFRAME_H_INCLUDED
24 #include <wxdkdraw/WxdkdrawFrame.h>
25 #endif
26 #ifndef WXDKDRAWDLGTEXTINPUT_H_INCLUDED
27 #include <wxdkdraw/WxdkdrawDlgTextInput.h>
28 #endif
29 #ifndef WXDKDRAWDLGSPLINEVALUE_H_INCLUDED
30 #include <wxdkdraw/WxdkdrawDlgSplineValue.h>
31 #endif
32 #ifndef WXDKDRAWDLGIMAGEOPTIONS_H_INCLUDED
33 #include <wxdkdraw/WxdkdrawDlgImageOptions.h>
34 #endif
35 #ifndef WXDKDRAWDLGDOTFILLED_H_INCLUDED
36 #include <wxdkdraw/WxdkdrawDlgDotFilled.h>
37 #endif
38 #ifndef WXDKDRAWDLGBOXRADIUS_H_INCLUDED
39 #include <wxdkdraw/WxdkdrawDlgBoxRadius.h>
40 #endif
41 #ifndef DK4MAAU32_H_INCLUDED
42 #include <libdk4ma/dk4maau32.h>
43 #endif
44 #ifndef DK4MAAI32_H_INCLUDED
45 #include <libdk4ma/dk4maai32.h>
46 #endif
47 #ifndef DK4MAAU16_H_INCLUDED
48 #include <libdk4ma/dk4maau16.h>
49 #endif
50
51 #if DK4_HAVE_MATH_H
52 #ifndef MATH_H_INCLUDED
53 #include <math.h>
54 #define MATH_H_INCLUDED 1
55 #endif
56 #endif
57
58
59
60
61
62
63 /** Image file types we can handle.
64 */
65 static wxChar const image_files_to_open[] = {
66 #if DK4_HAVE_PNG_H
67 wxT("PNG files (*.png)|*.png")
68 #if DK4_HAVE_JPEGLIB_H
69 wxT("|JPEG files (*.jpeg)|*.jpeg")
70 wxT("|JPEG files (*.jpg)|*.jpg")
71 #endif
72 /* if DK4_HAVE_JPEGLIB_H */
73 #if DK4_HAVE_TIFF_H
74 wxT("|TIFF files (*.tiff)|*.tiff")
75 wxT("|TIFF files (*.tif)|*.tif")
76 #endif
77 /* if DK4_HAVE_TIFF_H */
78 wxT("|NetPBM files (*.pam)|*.pam")
79 #else
80 /* if DK4_HAVE_PNG_H */
81 #if DK4_HAVE_JPEGLIB_H
82 wxT("JPEG files (*.jpeg)|*.jpeg")
83 wxT("|JPEG files (*.jpg)|*.jpg")
84 #if DK4_HAVE_TIFF_H
85 wxT("|TIFF files (*.tiff)|*.tiff")
86 wxT("|TIFF files (*.tif)|*.tif")
87 #endif
88 /* if DK4_HAVE_TIFF_H */
89 wxT("|NetPBM files (*.pam)|*.pam")
90 #else
91 /* if DK4_HAVE_JPEGLIB_H */
92 #if DK4_HAVE_TIFF_H
93 wxT("TIFF files (*.tiff)|*.tiff")
94 wxT("|TIFF files (*.tif)|*.tif")
95 wxT("|NetPBM files (*.pam)|*.pam")
96 #else
97 /* if DK4_HAVE_TIFF_H */
98 wxT("NetPBM files (*.pam)|*.pam")
99 #endif
100 /* if DK4_HAVE_TIFF_H */
101 #endif
102 /* if DK4_HAVE_JPEGLIB_H */
103 #endif
104 /* DK4_HAVE_PNG_H */
105 wxT("|NetPBM files (*.pnm)|*.pnm")
106 wxT("|NetPBM files (*.ppm)|*.ppm")
107 wxT("|NetPBM files (*.pgm)|*.pgm")
108 wxT("|NetPBM files (*.pbm)|*.pbm")
109 };
110
111
112
113 bool
IsAcceptablePoint(void)114 WxdkdrawFrame::IsAcceptablePoint(void)
115 {
116 bool back = true;
117
118 switch (m_iState) {
119 case S_POLY_FURTHER :
120 case S_SPLINE_FURTHER :
121 case S_CIRCLE_RADIUS :
122 case S_IMG_2 :
123 {
124 if (
125 (m_ptMousePosGrid.x == m_ptMouseMoveStart.x)
126 && (m_ptMousePosGrid.y == m_ptMouseMoveStart.y)
127 ) {
128 back = false;
129 }
130 } break;
131 case S_ELLIPSE_CORNER :
132 case S_BOX_OPPOSITE :
133 {
134 back = false;
135 /*
136 For a box we accept neither equal x nor equal y coordinates
137 */
138 if (
139 (m_ptMousePosGrid.x != m_ptMouseMoveStart.x)
140 && (m_ptMousePosGrid.y != m_ptMouseMoveStart.y)
141 ) {
142 back = true;
143 }
144 } break;
145 case S_ARC_2 : {
146 if (
147 ((m_pCurrent->det).a.x1 == (m_pCurrent->det).a.x2)
148 && ((m_pCurrent->det).a.y1 == (m_pCurrent->det).a.y2)
149 ) {
150 back = false;
151 }
152 } break;
153 case S_ARC_3 : {
154 if (
155 (
156 ((m_pCurrent->det).a.x1 == (m_pCurrent->det).a.x3)
157 && ((m_pCurrent->det).a.y1 == (m_pCurrent->det).a.y3)
158 ) || (
159 ((m_pCurrent->det).a.x2 == (m_pCurrent->det).a.x3)
160 && ((m_pCurrent->det).a.y2 == (m_pCurrent->det).a.y3)
161 )
162 ) {
163 back = false;
164 }
165 } break;
166 }
167 return back;
168 }
169
170
171 void
MouseMoveNoop(void)172 WxdkdrawFrame::MouseMoveNoop(void)
173 {
174 Wxd_object_t *pobj;
175 size_t si;
176 int oldtype = WXD_OT_GROUP_END;
177
178 if (m_bMousePos) {
179 if (NULL != m_pCurrent) {
180 oldtype = (int)(m_pCurrent->ot);
181 }
182 #if 0
183 if (NULL == m_pStyle) {
184 #endif
185 pobj = FindNearestObject();
186 if (m_pCurrent != pobj) {
187 if ((NULL != pobj) && (NULL == m_pCurrent)) {
188 msgMouseL->SetLabel(sTexts[201]);
189 msgMouseL->Refresh();
190 m_bUpdate = true;
191 }
192 else {
193 if ((NULL == pobj) && (NULL != m_pCurrent)) {
194 msgMouseL->SetLabel(sNlWx[7]);
195 msgMouseL->Refresh();
196 m_bUpdate = true;
197 }
198 }
199 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
200 m_pCurrent = pobj;
201 if (NULL != m_pCurrent) {
202 pobj->mark |= OBJ_MARKER_1;
203 if (oldtype != (int)(m_pCurrent->ot)) {
204 if (
205 (WXD_OT_TEXT <= m_pCurrent->ot)
206 && (WXD_OT_DOT_WHITE >= m_pCurrent->ot)
207 ) {
208 si = (size_t)172U + (size_t)(m_pCurrent->ot);
209 SetStatusText(sTexts[si]);
210 m_bUpdate = true;
211 }
212 }
213 }
214 else {
215 SetStatusText(sNlWx[19]);
216 }
217 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
218 }
219 #if 0
220 }
221 #endif
222 }
223 else {
224 if (NULL != m_pCurrent) {
225 m_pCurrent = NULL;
226 msgMouseL->SetLabel(sNlWx[7]);
227 msgMouseL->Refresh();
228 SetStatusText(sNlWx[19]);
229 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
230 }
231 }
232
233 }
234
235
236
237 void
MouseMoveDelete(void)238 WxdkdrawFrame::MouseMoveDelete(void)
239 {
240 Wxd_object_t *pOldCurrent;
241
242 if (m_bMousePos) {
243 pOldCurrent = m_pCurrent;
244 m_pCurrent = FindNearestObject(true);
245 if (m_pCurrent != pOldCurrent) {
246 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
247 if (NULL != m_pCurrent) {
248 wxdobj_mark_recursively(m_pCurrent, OBJ_MARKER_1);
249 if (
250 (WXD_OT_GROUP_BEGIN <= m_pCurrent->ot)
251 && (WXD_OT_DOT_WHITE >= m_pCurrent->ot)
252 ) {
253 SetStatusText(
254 sTexts[(size_t)172U + (size_t)(m_pCurrent->ot)]
255 );
256 }
257 else {
258 SetStatusText(sNlWx[7]);
259 }
260 msgMouseL->SetLabel(sTexts[340]);
261 }
262 else {
263 SetStatusText(sNlWx[7]);
264 msgMouseL->SetLabel(sNlWx[7]);
265 }
266 msgMouseL->Refresh();
267 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
268 }
269 }
270 else {
271 SetStatusText(sNlWx[7]);
272 msgMouseL->SetLabel(sNlWx[7]);
273 msgMouseL->Refresh();
274 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
275 }
276
277 }
278
279
280
281 void
MouseMoveMoveSelect(void)282 WxdkdrawFrame::MouseMoveMoveSelect(void)
283 {
284 Wxd_object_t *pOldCurrent;
285
286 if (m_bMousePos) {
287 pOldCurrent = m_pCurrent;
288 m_pCurrent = FindNearestObject(true);
289 if (m_pCurrent != pOldCurrent) {
290 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
291 if (NULL != m_pCurrent) {
292 wxdobj_mark_recursively(m_pCurrent, OBJ_MARKER_1);
293 if (
294 (WXD_OT_GROUP_BEGIN <= m_pCurrent->ot)
295 && (WXD_OT_DOT_WHITE >= m_pCurrent->ot)
296 ) {
297 SetStatusText(
298 sTexts[(size_t)172U + (size_t)(m_pCurrent->ot)]
299 );
300 }
301 else {
302 SetStatusText(sNlWx[7]);
303 }
304 msgMouseL->SetLabel(sTexts[342]);
305 }
306 else {
307 SetStatusText(sNlWx[7]);
308 msgMouseL->SetLabel(sNlWx[7]);
309 }
310 msgMouseL->Refresh();
311 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
312 }
313 #if TRACE_DEBUG
314 else {
315 }
316 #endif
317 }
318 else {
319 SetStatusText(sNlWx[7]);
320 msgMouseL->SetLabel(sNlWx[7]);
321 msgMouseL->Refresh();
322 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
323 }
324
325 }
326
327
328
329 void
MouseMoveMovePlace(void)330 WxdkdrawFrame::MouseMoveMovePlace(void)
331 {
332
333
334
335 if ((m_bMousePos) && (m_bMouseDiff)) {
336 if (0 != wxdobj_shift_marked(m_pDrw, &m_ptMouseMoveDiff, 0)) {
337
338 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
339 }
340 #if TRACE_DEBUG
341 else {
342 }
343 #endif
344 }
345 #if TRACE_DEBUG
346 else {
347 }
348 #endif
349
350 }
351
352
353
354 void
MouseMoveCopySelect(void)355 WxdkdrawFrame::MouseMoveCopySelect(void)
356 {
357 Wxd_object_t *pOldCurrent;
358
359 if (m_bMousePos) {
360 pOldCurrent = m_pCurrent;
361 m_pCurrent = FindNearestObject(true);
362 if (m_pCurrent != pOldCurrent) {
363 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
364 if (NULL != m_pCurrent) {
365 wxdobj_mark_recursively(m_pCurrent, OBJ_MARKER_1);
366 if (
367 (WXD_OT_GROUP_BEGIN <= m_pCurrent->ot)
368 && (WXD_OT_DOT_WHITE >= m_pCurrent->ot)
369 ) {
370 SetStatusText(
371 sTexts[(size_t)172U + (size_t)(m_pCurrent->ot)]
372 );
373 }
374 else {
375 SetStatusText(sNlWx[7]);
376 }
377 msgMouseL->SetLabel(sTexts[370]);
378 }
379 else {
380 SetStatusText(sNlWx[7]);
381 msgMouseL->SetLabel(sNlWx[7]);
382 }
383 msgMouseL->Refresh();
384 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
385 }
386 }
387 else {
388 SetStatusText(sNlWx[7]);
389 msgMouseL->SetLabel(sNlWx[7]);
390 msgMouseL->Refresh();
391 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
392 }
393
394 }
395
396
397
398 void
MouseMoveCopyPlace(void)399 WxdkdrawFrame::MouseMoveCopyPlace(void)
400 {
401
402 if ((m_bMousePos) && (m_bMouseDiff)) {
403 if (0 != wxdobj_shift_marked(m_pDrw, &m_ptMouseMoveDiff, 0)) {
404 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
405 }
406 else {
407 }
408 }
409 else {
410 }
411
412 }
413
414
415
416 void
MouseLeftNoop(void)417 WxdkdrawFrame::MouseLeftNoop(void)
418 {
419 Wxd_object_t *pobj;
420 size_t si;
421
422 if (m_bMousePos) {
423 #if 0
424 if (NULL == m_pStyle) {
425 #endif
426 pobj = FindNearestObject();
427 if (NULL != pobj) {
428 m_pStyle = pobj;
429 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
430
431 if (
432 (WXD_OT_TEXT <= m_pStyle->ot)
433 && (WXD_OT_DOT_WHITE >= m_pStyle->ot)
434 ) {
435 msgMouseR->SetLabel(sTexts[200]);
436
437 msgMouseL->SetLabel(sNlWx[7]);
438
439 si = (size_t)185U + (size_t)(m_pStyle->ot);
440
441 SetStatusText(sTexts[si]);
442
443 msgMouseR->Refresh();
444
445 msgMouseL->Refresh();
446
447 m_bUpdate = true;
448
449 StyleToGUI();
450 }
451 else {
452 SetStatusText(sNlWx[19]);
453 }
454 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
455 }
456 #if 0
457 }
458 else {
459 }
460 #endif
461 }
462 else {
463 }
464
465 }
466
467
468
469 void
MouseLeftDelete(void)470 WxdkdrawFrame::MouseLeftDelete(void)
471 {
472 Wxd_object_t *pobj;
473
474 if (m_bMousePos) {
475 pobj = FindNearestObject(true);
476 if (NULL != pobj) {
477 wxdobj_obj_delete_from_drawing(m_pDrw, pobj);
478 msgMouseL->SetLabel(sNlWx[7]);
479 msgMouseL->Refresh();
480 SetStatusText(sNlWx[7]);
481 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
482 SetModified();
483 }
484 }
485 else {
486 }
487
488 }
489
490
491
492 void
MouseLeftMoveSelect(void)493 WxdkdrawFrame::MouseLeftMoveSelect(void)
494 {
495
496 if (m_bMousePos) {
497 m_pCurrent = FindNearestObject(true);
498 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
499 if (NULL != m_pCurrent) {
500 wxdobj_mark_recursively(m_pCurrent, OBJ_MARKER_1);
501 m_iState = S_MOVE_PLACE;
502 DK4_MEMCPY(\
503 &m_ptMouseMoveStart,\
504 &m_ptMousePosGrid,\
505 sizeof(Wxd_point_t)\
506 );
507 m_ptMouseMoveDiff.x = (int32_t)0L;
508 m_ptMouseMoveDiff.y = (int32_t)0L;
509 m_bMouseDiff = true;
510 if (
511 (WXD_OT_GROUP_BEGIN <= m_pCurrent->ot)
512 && (WXD_OT_DOT_WHITE >= m_pCurrent->ot)
513 ) {
514 SetStatusText(sTexts[(size_t)172U + (size_t)(m_pCurrent->ot)]);
515 }
516 else {
517 SetStatusText(sNlWx[7]);
518 }
519 msgMouseL->SetLabel(sTexts[343]);
520 }
521 else {
522 SetStatusText(sNlWx[7]);
523 msgMouseL->SetLabel(sNlWx[7]);
524 }
525 msgMouseL->Refresh();
526 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
527 }
528 else {
529 }
530
531 }
532
533
534
535 void
MouseLeftMovePlace(void)536 WxdkdrawFrame::MouseLeftMovePlace(void)
537 {
538
539 if ((m_bMousePos) && (m_bMouseDiff)) {
540 if (0 != wxdobj_shift_marked(m_pDrw, &m_ptMouseMoveDiff, 0)) {
541 wxdobj_shift_marked(m_pDrw, &m_ptMouseMoveDiff, 1);
542 if (NULL != m_pCurrent) {
543 wxdobj_bb_modified_object(m_pDrw, m_pCurrent);
544 }
545 else {
546 wxdobj_bb_for_drawing(m_pDrw);
547 }
548 m_iState = S_MOVE_SELECT;
549 SetModified();
550 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
551 }
552 }
553
554 }
555
556
557
558 void
MouseLeftCopySelect(void)559 WxdkdrawFrame::MouseLeftCopySelect(void)
560 {
561
562 if (m_bMousePos) {
563 m_pCurrent = FindNearestObject(true);
564 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
565 if (NULL != m_pCurrent) {
566 wxdobj_mark_recursively(m_pCurrent, OBJ_MARKER_1);
567 m_iState = S_COPY_PLACE;
568 DK4_MEMCPY(\
569 &m_ptMouseMoveStart,\
570 &m_ptMousePosGrid,\
571 sizeof(Wxd_point_t)\
572 );
573 m_ptMouseMoveDiff.x = (int32_t)0L;
574 m_ptMouseMoveDiff.y = (int32_t)0L;
575 m_bMouseDiff = true;
576 if (
577 (WXD_OT_GROUP_BEGIN <= m_pCurrent->ot)
578 && (WXD_OT_DOT_WHITE >= m_pCurrent->ot)
579 ) {
580 SetStatusText(sTexts[(size_t)172U + (size_t)(m_pCurrent->ot)]);
581 }
582 else {
583 SetStatusText(sNlWx[7]);
584 }
585 msgMouseL->SetLabel(sTexts[371]);
586 }
587 else {
588 SetStatusText(sNlWx[7]);
589 msgMouseL->SetLabel(sNlWx[7]);
590 }
591 msgMouseL->Refresh();
592 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
593 }
594
595 }
596
597
598
599 void
MouseLeftCopyPlace(void)600 WxdkdrawFrame::MouseLeftCopyPlace(void)
601 {
602
603 if ((m_bMousePos) && (m_bMouseDiff)) {
604 if (0 != wxdobj_shift_marked(m_pDrw, &m_ptMouseMoveDiff, 0)) {
605 /* Create copy and shift objects in copy */
606 if (NULL != m_pCurrent) {
607 wxdobj_copy_recursive(m_pDrw, m_pCurrent, &m_ptMouseMoveDiff);
608 SetModified();
609 }
610 m_iState = S_COPY_SELECT;
611 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
612 }
613 }
614
615 }
616
617
618
619 void
EndOperationPolyFirst(void)620 WxdkdrawFrame::EndOperationPolyFirst(void)
621 {
622
623 if (NULL != m_pCurrent) {
624 m_pCurrent->mark = (uint8_t)(
625 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
626 );
627 }
628 m_pCurrent = NULL;
629 m_iState = S_NOOP;
630 SetMouseAndStatusTexts(S_NOOP);
631
632 }
633
634
635
636 void
EndOperationPolyFurther(bool bComplete,bool bSkip)637 WxdkdrawFrame::EndOperationPolyFurther(bool bComplete, bool bSkip)
638 {
639 dk4_er_t er;
640 uint16_t itd;
641
642 if (bSkip) {
643
644 if (NULL != m_pCurrent) {
645 wxdobj_obj_delete_from_drawing(m_pDrw, m_pCurrent);
646 m_iState = S_POLY_FIRST;
647 }
648 else {
649 m_iState = S_NOOP;
650 }
651 }
652 else {
653 if (NULL != m_pCurrent) {
654 m_pCurrent->mark = (uint8_t)(
655 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
656 );
657 if (
658 (WXD_OT_POLYLINE == m_pCurrent->ot)
659 || (WXD_OT_POLYGON == m_pCurrent->ot)
660 ) {
661 if (2U < (m_pCurrent->det).p.n) {
662 dk4error_init(&er);
663 itd = (uint16_t)((m_pCurrent->det).p.n - 1U);
664 if ( wxdobj_del_polypoint(m_pCurrent, itd, &er) ) {
665 m_iState = S_POLY_FIRST;
666 }
667 else {
668 m_iState = S_NOOP;
669 dk4error_copy(&m_oErrorReport, &er);
670 }
671 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
672 SetModified();
673 }
674 else {
675 wxdobj_obj_delete_from_drawing(m_pDrw, m_pCurrent);
676 }
677 m_iState = S_POLY_FIRST;
678 }
679 else {
680 m_iState = S_NOOP;
681 }
682 }
683 else {
684 m_iState = S_NOOP;
685 }
686 }
687 m_pCurrent = NULL;
688 if (bComplete) {
689 m_iState = S_NOOP;
690 }
691 SetMouseAndStatusTexts(m_iState);
692 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
693
694 }
695
696
697
698 void
EndOperationSplineFirst(void)699 WxdkdrawFrame::EndOperationSplineFirst(void)
700 {
701
702 #if 0
703 if (NULL != m_pCurrent) {
704 m_pCurrent->mark &= (~(OBJ_MARKER_1));
705 }
706 m_pCurrent = NULL;
707 m_iState = S_NOOP;
708 SetMouseAndStatusTexts(S_NOOP);
709 #else
710 EndOperationPolyFirst();
711 #endif
712
713 }
714
715
716
717 void
EndOperationSplineFurther(bool bComplete,bool bSkip)718 WxdkdrawFrame::EndOperationSplineFurther(bool bComplete, bool bSkip)
719 {
720 dk4_er_t er;
721 uint16_t itd;
722
723 if (bSkip) {
724
725 if (NULL != m_pCurrent) {
726 wxdobj_obj_delete_from_drawing(m_pDrw, m_pCurrent);
727 m_iState = S_SPLINE_FIRST;
728 }
729 else {
730 m_iState = S_NOOP;
731 }
732 }
733 else {
734 if (NULL != m_pCurrent) {
735 m_pCurrent->mark = (uint8_t)(
736 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
737 );
738 if (
739 (WXD_OT_O_SPLINE == m_pCurrent->ot)
740 || (WXD_OT_C_SPLINE == m_pCurrent->ot)
741 ) {
742 if (2U < (m_pCurrent->det).s.n) {
743 dk4error_init(&er);
744 itd = (uint16_t)((m_pCurrent->det).s.n - 1U);
745 if ( wxdobj_del_splinepoint(m_pCurrent, itd, &er) ) {
746 ((m_pCurrent->det).s.p)[(m_pCurrent->det).s.n - 1U].s =
747 SValueAtEnd();
748 m_iState = S_SPLINE_FIRST;
749 }
750 else {
751 m_iState = S_NOOP;
752 dk4error_copy(&m_oErrorReport, &er);
753 }
754 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
755 SetModified();
756 }
757 else {
758 wxdobj_obj_delete_from_drawing(m_pDrw, m_pCurrent);
759 }
760 m_iState = S_SPLINE_FIRST;
761 }
762 else {
763 m_iState = S_NOOP;
764 }
765 }
766 else {
767 m_iState = S_NOOP;
768 }
769 }
770 m_pCurrent = NULL;
771 if (bComplete) {
772 m_iState = S_NOOP;
773 }
774 SetMouseAndStatusTexts(m_iState);
775 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
776
777 }
778
779
780
781 void
EndOperationBoxFirst(void)782 WxdkdrawFrame::EndOperationBoxFirst(void)
783 {
784 #if 0
785 if (NULL != m_pCurrent) {
786 m_pCurrent->mark &= (~(OBJ_MARKER_1));
787 }
788 m_pCurrent = NULL;
789 m_iState = S_NOOP;
790 SetMouseAndStatusTexts(S_NOOP);
791 #else
792 EndOperationPolyFirst();
793 #endif
794 }
795
796
797
798 void
EndOperationTwoPointsSecond(int ns,bool bComplete)799 WxdkdrawFrame::EndOperationTwoPointsSecond(int ns, bool bComplete)
800 {
801 if (NULL != m_pCurrent) {
802 m_pCurrent->mark = (uint8_t)(
803 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
804 );
805 wxdobj_obj_delete_from_drawing(m_pDrw, m_pCurrent);
806 m_pCurrent = NULL;
807 }
808 m_iState = ns;
809 if (bComplete) {
810 m_iState = S_NOOP;
811 }
812 SetMouseAndStatusTexts(m_iState);
813 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
814 }
815
816
817
818 void
EndOperationBoxOpposite(bool bComplete)819 WxdkdrawFrame::EndOperationBoxOpposite(bool bComplete)
820 {
821 EndOperationTwoPointsSecond(S_BOX_FIRST, bComplete);
822 }
823
824
825
826 void
EndOperationCircleCenter(void)827 WxdkdrawFrame::EndOperationCircleCenter(void)
828 {
829
830 #if 0
831 if (NULL != m_pCurrent) {
832 m_pCurrent->mark &= (~(OBJ_MARKER_1));
833 }
834 m_pCurrent = NULL;
835 m_iState = S_NOOP;
836 SetMouseAndStatusTexts(S_NOOP);
837 #else
838 EndOperationPolyFirst();
839 #endif
840
841 }
842
843
844
845 void
EndOperationCircleRadius(bool bComplete)846 WxdkdrawFrame::EndOperationCircleRadius(bool bComplete)
847 {
848
849 EndOperationTwoPointsSecond(S_CIRCLE_CENTER, bComplete);
850
851 }
852
853
854
855 void
EndOperationEllipseCenter(void)856 WxdkdrawFrame::EndOperationEllipseCenter(void)
857 {
858
859 #if 0
860 if (NULL != m_pCurrent) {
861 m_pCurrent->mark &= (~(OBJ_MARKER_1));
862 }
863 m_pCurrent = NULL;
864 m_iState = S_NOOP;
865 SetMouseAndStatusTexts(S_NOOP);
866 #else
867 EndOperationPolyFirst();
868 #endif
869
870 }
871
872
873
874 void
EndOperationEllipseCorner(bool bComplete)875 WxdkdrawFrame::EndOperationEllipseCorner(bool bComplete)
876 {
877
878 EndOperationTwoPointsSecond(S_ELLIPSE_CENTER, bComplete);
879
880 }
881
882
883
884 void
EndOperationArc1(void)885 WxdkdrawFrame::EndOperationArc1(void)
886 {
887 #if 0
888 if (NULL != m_pCurrent) {
889 m_pCurrent->mark &= (~(OBJ_MARKER_1));
890 }
891 m_pCurrent = NULL;
892 m_iState = S_NOOP;
893 SetMouseAndStatusTexts(S_NOOP);
894 #else
895 EndOperationPolyFirst();
896 #endif
897 }
898
899
900
901 void
EndOperationArc2(bool bComplete)902 WxdkdrawFrame::EndOperationArc2(bool bComplete)
903 {
904 if (NULL != m_pCurrent) {
905 m_pCurrent->mark = (uint8_t)(
906 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
907 );
908 wxdobj_obj_delete_from_drawing(m_pDrw, m_pCurrent);
909 m_pCurrent = NULL;
910 }
911 m_iState = S_ARC_1;
912 if (bComplete) {
913 m_iState = S_NOOP;
914 }
915 SetMouseAndStatusTexts(m_iState);
916 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
917 }
918
919
920
921 void
EndOperationArc3(bool bComplete)922 WxdkdrawFrame::EndOperationArc3(bool bComplete)
923 {
924 EndOperationArc2(bComplete);
925 }
926
927
928
929 void
EndOperationDot(void)930 WxdkdrawFrame::EndOperationDot(void)
931 {
932 m_pCurrent = NULL;
933 m_iState = S_NOOP;
934 SetMouseAndStatusTexts(m_iState);
935 }
936
937
938
939 void
EndOperationLibelemPlace(void)940 WxdkdrawFrame::EndOperationLibelemPlace(void)
941 {
942 /*
943 Remove library element group object from drawing
944 */
945 if (NULL != m_pCurrent) {
946 wxdobj_obj_delete_from_drawing(m_pDrw, m_pCurrent);
947 }
948 m_pCurrent = NULL;
949 m_iState = S_NOOP;
950 SetMouseAndStatusTexts(m_iState);
951 }
952
953
954
955 void
EndOperationPointMovePlace(void)956 WxdkdrawFrame::EndOperationPointMovePlace(void)
957 {
958 if (NULL != m_pCurrent) {
959 switch ( (int)(m_pCurrent->ot) ) {
960 case WXD_OT_ELLIPSE : case WXD_OT_CIRCLE : {
961 DK4_MEMCPY(\
962 &((m_pCurrent->det).e),\
963 &m_ellPointMoveOri,\
964 sizeof(Wxd_det_ellipse_t)\
965 );
966 } break;
967 }
968 if (
969 wxdobj_set_control_point(m_pCurrent, &m_ptPointMoveOri, m_uCurrent)
970 ) {
971 switch ( (int)(m_pCurrent->ot) ) {
972 case WXD_OT_BOX : {
973 wxdobj_bb_correct(&((m_pCurrent->det).b.b), &m_uCurrent);
974 } break;
975 case WXD_OT_IMAGE : {
976 wxdobj_bb_correct(&((m_pCurrent->det).i.br), &m_uCurrent);
977 } break;
978 }
979 }
980 m_pCurrent->mark = (uint8_t)(
981 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
982 );
983 wxdobj_bb_modified_object(m_pDrw, m_pCurrent);
984 m_pCurrent = NULL;
985 }
986 m_uCurrent = (uint16_t)0U;
987 #if 0
988 m_iState = S_NOOP;
989 #endif
990 /* 2020-03-21 Bugfix
991 When aborting placement we probably want to select
992 another point to move.
993 */
994 m_iState = S_MOVEPT_SELECT;
995 SetMouseAndStatusTexts(m_iState);
996 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
997 }
998
999
1000
1001 void
EndOperationPointAddPlace(bool bComplete)1002 WxdkdrawFrame::EndOperationPointAddPlace(bool bComplete)
1003 {
1004
1005 if (NULL != m_pCurrent) {
1006 m_pCurrent->mark = (uint8_t)(
1007 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
1008 );
1009 wxdobj_delete_control_point(m_pCurrent, m_uCurrent);
1010 m_pCurrent = NULL;
1011 m_uCurrent = (uint16_t)0U;
1012 wxdobj_bb_modified_object(m_pDrw, m_pCurrent);
1013 }
1014 m_iState = ((bComplete) ? (S_NOOP) : (S_ADDPT_SELECT));
1015 SetMouseAndStatusTexts(m_iState);
1016 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
1017
1018 }
1019
1020
1021
1022 void
EndOperationDrawingSizePlace(bool bComplete)1023 WxdkdrawFrame::EndOperationDrawingSizePlace(bool bComplete)
1024 {
1025
1026 m_iState = ((bComplete) ? (S_NOOP) : (S_DRWSZ_SELECT));
1027 SetMouseAndStatusTexts(m_iState);
1028 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
1029 DK4_MEMCPY(&(m_pDrw->bb),&m_oOldSize,sizeof(Wxd_bb_t));
1030 DK4_MEMCPY(&(m_oBorder.det.b.b),&m_oOldSize,sizeof(Wxd_bb_t));
1031 SetMouseAndStatusTexts(m_iState);
1032 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_GRID);
1033
1034 }
1035
1036
1037
1038 void
EndOperation(bool bComplete,bool bSkip)1039 WxdkdrawFrame::EndOperation(bool bComplete, bool bSkip)
1040 {
1041 int rdl = WXD_REFRESH_MARKUP;
1042
1043 /*
1044 _STATE_ End current operation.
1045 */
1046 switch (m_iState) {
1047 /*
1048 When ending operations in states having objects under
1049 modification which are drawn in the markup pass,
1050 we must refresh the drawing.
1051 */
1052 case S_MOVE_PLACE :
1053 case S_COPY_PLACE :
1054 case S_MOVEPT_SELECT :
1055 case S_MOVEPT_PLACE :
1056 case S_ADDPT_PLACE :
1057 {
1058 rdl = WXD_REFRESH_DRAWING;
1059 } break;
1060 }
1061 /*
1062 _STATE_ End current operation.
1063 */
1064 switch (m_iState) {
1065 case S_NOOP : {
1066 if (NULL != m_pStyle) {
1067 m_pStyle = NULL;
1068 StyleToGUI();
1069 wxdobj_drw_require_redraw(m_pDrw, rdl);
1070 msgMouseR->SetLabel(sNlWx[7]);
1071 msgMouseL->SetLabel(sNlWx[7]);
1072 SetStatusText(sNlWx[19]);
1073 msgMouseR->Refresh();
1074 msgMouseL->Refresh();
1075 m_bUpdate = true;
1076 }
1077 m_pCurrent = NULL;
1078 } break;
1079 case S_POLY_FIRST : {
1080 EndOperationPolyFirst();
1081 } break;
1082 case S_POLY_FURTHER : {
1083 EndOperationPolyFurther(bComplete, bSkip);
1084 } break;
1085 case S_SPLINE_FIRST : {
1086 EndOperationSplineFirst();
1087 } break;
1088 case S_SPLINE_FURTHER : {
1089 EndOperationSplineFurther(bComplete, bSkip);
1090 } break;
1091 case S_BOX_FIRST : {
1092 EndOperationBoxFirst();
1093 } break;
1094 case S_BOX_OPPOSITE : {
1095 EndOperationBoxOpposite(bComplete);
1096 } break;
1097 case S_CIRCLE_CENTER : {
1098 EndOperationCircleCenter();
1099 } break;
1100 case S_CIRCLE_RADIUS : {
1101 EndOperationCircleRadius(bComplete);
1102 } break;
1103 case S_ELLIPSE_CENTER : {
1104 EndOperationEllipseCenter();
1105 } break;
1106 case S_ELLIPSE_CORNER : {
1107 EndOperationEllipseCorner(bComplete);
1108 } break;
1109 case S_ARC_1 : {
1110 EndOperationArc1();
1111 } break;
1112 case S_ARC_2 : {
1113 EndOperationArc2(bComplete);
1114 } break;
1115 case S_ARC_3 : {
1116 EndOperationArc3(bComplete);
1117 } break;
1118 case S_DOT : {
1119 EndOperationDot();
1120 } break;
1121 case S_LIBELEM_PLACE : {
1122 EndOperationLibelemPlace();
1123 } break;
1124 case S_MOVEPT_PLACE : {
1125 EndOperationPointMovePlace();
1126 } break;
1127 case S_ADDPT_PLACE : {
1128 EndOperationPointAddPlace(bComplete);
1129 } break;
1130 case S_DRWSZ_PLACE : {
1131 EndOperationDrawingSizePlace(bComplete);
1132 } break;
1133 case S_GROUP_ONE : {
1134 if ((2 > wxdobj_num_marked_2(m_pDrw)) || (bComplete)) {
1135 m_pStyle = NULL;
1136 m_pCurrent = NULL;
1137 m_iState = S_NOOP;
1138 }
1139 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
1140 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_2);
1141 SetMouseAndStatusTexts(m_iState);
1142 wxdobj_drw_require_redraw(m_pDrw, rdl);
1143 } break;
1144 case S_GROUP_RECT_2 : {
1145 m_iState = ((bComplete) ? (S_NOOP) : (S_GROUP_RECT_1));
1146 m_pStyle = NULL;
1147 m_pCurrent = NULL;
1148 SetMouseAndStatusTexts(m_iState);
1149 wxdobj_drw_require_redraw(m_pDrw, rdl);
1150 } break;
1151 case S_REGION_DELETE : {
1152 m_iState = ((bComplete) ? (S_NOOP) : (S_DELETE));
1153 m_pStyle = NULL;
1154 m_pCurrent = NULL;
1155 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
1156 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_2);
1157 SetMouseAndStatusTexts(m_iState);
1158 wxdobj_drw_require_redraw(m_pDrw, rdl);
1159 } break;
1160 default : {
1161 m_pStyle = NULL;
1162 m_pCurrent = NULL;
1163 m_iState = S_NOOP;
1164 SetMouseAndStatusTexts(m_iState);
1165 wxdobj_drw_require_redraw(m_pDrw, rdl);
1166 } break;
1167 }
1168
1169 }
1170
1171
1172
1173 void
MouseMovePolyFirst(void)1174 WxdkdrawFrame::MouseMovePolyFirst(void)
1175 {
1176
1177
1178 }
1179
1180
1181
1182 void
MouseLeftPolyFirst(void)1183 WxdkdrawFrame::MouseLeftPolyFirst(void)
1184 {
1185
1186 if (m_bMousePos) {
1187 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
1188 m_pCurrent = wxdobj_add_polyline(
1189 m_pDrw, NULL, 2U,
1190 ((WXD_OT_POLYGON == m_iObjToCreate) ? 1 : 0), &m_oStyle
1191 );
1192 if (
1193 (NULL != m_pCurrent)
1194 && (NULL != (m_pCurrent->det).p.p)
1195 ) {
1196 m_iState = S_POLY_FURTHER;
1197 m_pCurrent->mark |= OBJ_MARKER_1;
1198 ((m_pCurrent->det).p.p)[0].x = ((m_pCurrent->det).p.p)[1].x =
1199 m_ptMousePosGrid.x;
1200 ((m_pCurrent->det).p.p)[0].y = ((m_pCurrent->det).p.p)[1].y =
1201 m_ptMousePosGrid.y;
1202 if (WXD_OT_POLYGON == m_iObjToCreate) {
1203 if (WXD_FS_PURE < m_pCurrent->fs) {
1204 UpdateStipples();
1205 }
1206 }
1207 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
1208 m_bAcceptablePoint = false;
1209 DK4_MEMCPY(\
1210 &m_ptMouseMoveStart,\
1211 &m_ptMousePosGrid,\
1212 sizeof(Wxd_point_t)\
1213 );
1214 SetMouseAndStatusTexts(m_iState);
1215 }
1216 else {
1217 /* ERROR: Memory */
1218 dk4error_set_simple_error_code(
1219 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
1220 );
1221 }
1222 }
1223
1224 }
1225
1226
1227
1228 void
MouseMovePolyFurther(void)1229 WxdkdrawFrame::MouseMovePolyFurther(void)
1230 {
1231 bool bOldAcceptable;
1232
1233 if (m_bMousePos) {
1234 if (
1235 (NULL != m_pCurrent)
1236 && (NULL != (m_pCurrent->det).p.p)
1237 ) {
1238 ((m_pCurrent->det).p.p)[(m_pCurrent->det).p.n - 1U].x =
1239 m_ptMousePosGrid.x;
1240 ((m_pCurrent->det).p.p)[(m_pCurrent->det).p.n - 1U].y =
1241 m_ptMousePosGrid.y;
1242 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
1243 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
1244 bOldAcceptable = m_bAcceptablePoint;
1245 m_bAcceptablePoint = IsAcceptablePoint();
1246 if (bOldAcceptable != m_bAcceptablePoint) {
1247 SetMouseAndStatusTexts(m_iState);
1248 }
1249 }
1250 else {
1251 /* ERROR: Memory (already reported) */
1252 }
1253 }
1254 else {
1255 /* ERROR: No mouse position available */
1256 dk4error_set_simple_error_code(
1257 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
1258 );
1259 }
1260
1261 }
1262
1263
1264
1265 void
MouseLeftPolyFurther(void)1266 WxdkdrawFrame::MouseLeftPolyFurther(void)
1267 {
1268 dk4_er_t er;
1269
1270 if (m_bMousePos) {
1271 if (IsAcceptablePoint()) {
1272 if (
1273 (NULL != m_pCurrent)
1274 && (NULL != (m_pCurrent->det).p.p)
1275 ) {
1276 /* Fix current segment end point
1277 */
1278 ((m_pCurrent->det).p.p)[(m_pCurrent->det).p.n - 1U].x =
1279 m_ptMousePosGrid.x;
1280 ((m_pCurrent->det).p.p)[(m_pCurrent->det).p.n - 1U].y =
1281 m_ptMousePosGrid.y;
1282 dk4error_init(&er);
1283 if (
1284 wxdobj_add_polypoint(m_pCurrent, (m_pCurrent->det).p.n, &er)
1285 ) {
1286 /*
1287 Initial end point value for new segment
1288 */
1289 ((m_pCurrent->det).p.p)[(m_pCurrent->det).p.n - 1U].x =
1290 m_ptMousePosGrid.x;
1291 ((m_pCurrent->det).p.p)[(m_pCurrent->det).p.n - 1U].y =
1292 m_ptMousePosGrid.y;
1293 SetModified();
1294 m_bAcceptablePoint = false;
1295 DK4_MEMCPY(\
1296 &m_ptMouseMoveStart,\
1297 &m_ptMousePosGrid,\
1298 sizeof(Wxd_point_t)\
1299 );
1300 }
1301 else {
1302 dk4error_copy(&m_oErrorReport, &er);
1303 }
1304 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
1305 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
1306 }
1307 else {
1308 /* ERROR: Memory (already reported) */
1309 }
1310 }
1311 }
1312 else {
1313 /* ERROR: Mouse position unknown */
1314 dk4error_set_simple_error_code(
1315 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
1316 );
1317 }
1318
1319 }
1320
1321
1322
1323 void
MouseMoveSplineFirst(void)1324 WxdkdrawFrame::MouseMoveSplineFirst(void)
1325 {
1326
1327
1328 }
1329
1330
1331
1332 void
MouseLeftSplineFirst(void)1333 WxdkdrawFrame::MouseLeftSplineFirst(void)
1334 {
1335
1336 if (m_bMousePos) {
1337 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
1338 m_pCurrent = wxdobj_add_spline(
1339 m_pDrw, NULL, 2U,
1340 ((WXD_OT_C_SPLINE == m_iObjToCreate) ? 1 : 0), &m_oStyle
1341 );
1342 if (
1343 (NULL != m_pCurrent)
1344 && (NULL != (m_pCurrent->det).s.p)
1345 ) {
1346 m_iState = S_SPLINE_FURTHER;
1347 m_pCurrent->mark |= OBJ_MARKER_1;
1348 ((m_pCurrent->det).s.p)[0].x = ((m_pCurrent->det).s.p)[1].x =
1349 m_ptMousePosGrid.x;
1350 ((m_pCurrent->det).s.p)[0].y = ((m_pCurrent->det).s.p)[1].y =
1351 m_ptMousePosGrid.y;
1352 ((m_pCurrent->det).s.p)[0].s = ((m_pCurrent->det).s.p)[1].s =
1353 SValueAtEnd();
1354 if (WXD_OT_C_SPLINE == m_iObjToCreate) {
1355 if (WXD_FS_PURE < m_pCurrent->fs) {
1356 UpdateStipples();
1357 }
1358 }
1359 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
1360 m_bAcceptablePoint = false;
1361 DK4_MEMCPY(\
1362 &m_ptMouseMoveStart,\
1363 &m_ptMousePosGrid,\
1364 sizeof(Wxd_point_t)\
1365 );
1366 SetMouseAndStatusTexts(m_iState);
1367 }
1368 else {
1369 /* ERROR: Memory */
1370 dk4error_set_simple_error_code(
1371 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
1372 );
1373 }
1374 }
1375
1376 }
1377
1378
1379
1380 void
MouseMoveSplineFurther(void)1381 WxdkdrawFrame::MouseMoveSplineFurther(void)
1382 {
1383 bool bOldAcceptable;
1384
1385 if (m_bMousePos) {
1386 if (
1387 (NULL != m_pCurrent)
1388 && (NULL != (m_pCurrent->det).s.p)
1389 ) {
1390 ((m_pCurrent->det).s.p)[(m_pCurrent->det).s.n - 1U].x =
1391 m_ptMousePosGrid.x;
1392 ((m_pCurrent->det).s.p)[(m_pCurrent->det).s.n - 1U].y =
1393 m_ptMousePosGrid.y;
1394 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
1395 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
1396 bOldAcceptable = m_bAcceptablePoint;
1397 m_bAcceptablePoint = IsAcceptablePoint();
1398 if (bOldAcceptable != m_bAcceptablePoint) {
1399 SetMouseAndStatusTexts(m_iState);
1400 }
1401 }
1402 else {
1403 /* ERROR: Memory (already reported) */
1404 }
1405 }
1406 else {
1407 /* ERROR: No mouse position available */
1408 dk4error_set_simple_error_code(
1409 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
1410 );
1411 }
1412
1413 }
1414
1415
1416
1417 double
SValueAtEnd(void)1418 WxdkdrawFrame::SValueAtEnd(void)
1419 {
1420 double back = 0.0;
1421 if (NULL != m_pCurrent) {
1422 if (WXD_OT_C_SPLINE == m_pCurrent->ot) {
1423 back = ((m_bSplineInterpolated) ? (-1.0) : (1.0));
1424 }
1425 }
1426 return back;
1427 }
1428
1429
1430
1431 void
MouseLeftSplineFurther(void)1432 WxdkdrawFrame::MouseLeftSplineFurther(void)
1433 {
1434 dk4_er_t er;
1435
1436 if (m_bMousePos) {
1437 if (IsAcceptablePoint()) {
1438 if (
1439 (NULL != m_pCurrent)
1440 && (NULL != (m_pCurrent->det).s.p)
1441 ) {
1442 /* Fix current segment end point
1443 */
1444 ((m_pCurrent->det).s.p)[(m_pCurrent->det).s.n - 1U].x =
1445 m_ptMousePosGrid.x;
1446 ((m_pCurrent->det).s.p)[(m_pCurrent->det).s.n - 1U].y =
1447 m_ptMousePosGrid.y;
1448 ((m_pCurrent->det).s.p)[(m_pCurrent->det).s.n - 1U].s =
1449 (m_bSplineInterpolated ? (-1.0) : (1.0));
1450 dk4error_init(&er);
1451 if (
1452 wxdobj_add_splinepoint(m_pCurrent,(m_pCurrent->det).s.n,&er)
1453 ) {
1454
1455 /*
1456 Initial end point value for new segment
1457 */
1458 ((m_pCurrent->det).s.p)[(m_pCurrent->det).s.n - 1U].x =
1459 m_ptMousePosGrid.x;
1460 ((m_pCurrent->det).s.p)[(m_pCurrent->det).s.n - 1U].y =
1461 m_ptMousePosGrid.y;
1462 ((m_pCurrent->det).s.p)[(m_pCurrent->det).s.n - 1U].s =
1463 SValueAtEnd();
1464 SetModified();
1465 m_bAcceptablePoint = false;
1466 DK4_MEMCPY(\
1467 &m_ptMouseMoveStart,\
1468 &m_ptMousePosGrid,\
1469 sizeof(Wxd_point_t)\
1470 );
1471 }
1472 else {
1473 dk4error_copy(&m_oErrorReport, &er);
1474 }
1475 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
1476 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
1477 }
1478 else {
1479 /* ERROR: Memory (already reported) */
1480 }
1481 }
1482 }
1483 else {
1484 /* ERROR: Mouse position unknown */
1485 dk4error_set_simple_error_code(
1486 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
1487 );
1488 }
1489
1490 }
1491
1492
1493
1494 void
SetBoxDetails(bool bUpdateRadius)1495 WxdkdrawFrame::SetBoxDetails(bool bUpdateRadius)
1496 {
1497 int32_t h;
1498 int32_t w;
1499 int32_t m;
1500 if (NULL != m_pCurrent) {
1501 if (m_ptMousePosGrid.x >= m_ptMouseMoveStart.x) {
1502 (m_pCurrent->det).b.b.xl = m_ptMouseMoveStart.x;
1503 (m_pCurrent->det).b.b.xr = m_ptMousePosGrid.x;
1504 }
1505 else {
1506 (m_pCurrent->det).b.b.xl = m_ptMousePosGrid.x;
1507 (m_pCurrent->det).b.b.xr = m_ptMouseMoveStart.x;
1508 }
1509 if (m_ptMousePosGrid.y >= m_ptMouseMoveStart.y) {
1510 (m_pCurrent->det).b.b.yb = m_ptMouseMoveStart.y;
1511 (m_pCurrent->det).b.b.yt = m_ptMousePosGrid.y;
1512 }
1513 else {
1514 (m_pCurrent->det).b.b.yb = m_ptMousePosGrid.y;
1515 (m_pCurrent->det).b.b.yt = m_ptMouseMoveStart.y;
1516 }
1517 if (bUpdateRadius && m_bSplineInterpolated) {
1518 w = (m_pCurrent->det).b.b.xr - (m_pCurrent->det).b.b.xl;
1519 h = (m_pCurrent->det).b.b.yt - (m_pCurrent->det).b.b.yb;
1520 m = ((w < h) ? (w) : (h));
1521 (m_pCurrent->det).b.r = (uint32_t)(m / (int32_t)4UL);
1522 }
1523 }
1524 }
1525
1526
1527
1528 void
MouseMoveBoxFirst(void)1529 WxdkdrawFrame::MouseMoveBoxFirst(void)
1530 {
1531
1532
1533 }
1534
1535
1536
1537 void
MouseLeftBoxFirst(void)1538 WxdkdrawFrame::MouseLeftBoxFirst(void)
1539 {
1540
1541 if (m_bMousePos) {
1542 m_bAcceptablePoint = false;
1543 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
1544 m_pCurrent = wxdobj_add_box(m_pDrw, NULL, &m_oStyle);
1545 if (NULL != m_pCurrent) {
1546 m_pCurrent->mark |= OBJ_MARKER_1;
1547 m_iState = S_BOX_OPPOSITE;
1548 (m_pCurrent->det).b.r = (uint32_t)0UL;
1549 (m_pCurrent->det).b.b.xl = m_ptMousePosGrid.x;
1550 (m_pCurrent->det).b.b.xr = m_ptMousePosGrid.x;
1551 (m_pCurrent->det).b.b.yb = m_ptMousePosGrid.y;
1552 (m_pCurrent->det).b.b.yt = m_ptMousePosGrid.y;
1553 m_bAcceptablePoint = false;
1554 DK4_MEMCPY(\
1555 &m_ptMouseMoveStart,\
1556 &m_ptMousePosGrid,\
1557 sizeof(Wxd_point_t)\
1558 );
1559 SetMouseAndStatusTexts(m_iState);
1560 if (WXD_FS_PURE < m_pCurrent->fs) {
1561 UpdateStipples();
1562 }
1563 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
1564 }
1565 else {
1566 /* ERROR: Memory */
1567 dk4error_set_simple_error_code(
1568 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
1569 );
1570 }
1571 }
1572 else {
1573 }
1574
1575 }
1576
1577
1578
1579 void
MouseMoveBoxOpposite(void)1580 WxdkdrawFrame::MouseMoveBoxOpposite(void)
1581 {
1582 bool bOldAcceptablePoint;
1583
1584 if (m_bMousePos) {
1585 if (NULL != m_pCurrent) {
1586 SetBoxDetails(true);
1587 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
1588 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
1589 bOldAcceptablePoint = m_bAcceptablePoint;
1590 m_bAcceptablePoint = IsAcceptablePoint();
1591 if (bOldAcceptablePoint != m_bAcceptablePoint) {
1592 SetMouseAndStatusTexts(m_iState);
1593 }
1594 }
1595 else {
1596 /* ERROR: Memory (already reported) */
1597 }
1598 }
1599 else {
1600 /* ERROR: No mouse position available */
1601 dk4error_set_simple_error_code(
1602 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
1603 );
1604 }
1605
1606 }
1607
1608
1609
1610 void
MouseLeftBoxOpposite(void)1611 WxdkdrawFrame::MouseLeftBoxOpposite(void)
1612 {
1613
1614 if (m_bMousePos) {
1615 if (NULL != m_pCurrent) {
1616 if (IsAcceptablePoint()) {
1617 m_iState = S_BOX_FIRST;
1618 SetBoxDetails(true);
1619 m_pCurrent->mark = (uint8_t)(
1620 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
1621 );
1622 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
1623 m_pCurrent = NULL;
1624 SetModified();
1625 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
1626 SetMouseAndStatusTexts(m_iState);
1627 }
1628 }
1629 else {
1630 /* ERROR: Memory (already reported) */
1631 }
1632 }
1633 else {
1634 /* ERROR: Mouse position unknown */
1635 dk4error_set_simple_error_code(
1636 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
1637 );
1638 }
1639
1640 }
1641
1642
1643
1644 void
MouseMoveCircleCenter(void)1645 WxdkdrawFrame::MouseMoveCircleCenter(void)
1646 {
1647
1648
1649 }
1650
1651
1652
1653 void
CalculateCircleRadius(uint32_t & rx,dk4_er_t * erp)1654 WxdkdrawFrame::CalculateCircleRadius(uint32_t & rx, dk4_er_t *erp)
1655 {
1656 dk4_er_t er;
1657 double dx;
1658 double dy;
1659 int32_t xdiff = (int32_t)0L;
1660 int32_t ydiff = (int32_t)0L;
1661
1662 dk4error_init(&er);
1663 xdiff = dk4ma_int32_t_abs(
1664 dk4ma_int32_t_sub(
1665 m_ptMousePosGrid.x, m_ptMouseMoveStart.x, &er
1666 ), &er
1667 );
1668 ydiff = dk4ma_int32_t_abs(
1669 dk4ma_int32_t_sub(
1670 m_ptMousePosGrid.y, m_ptMouseMoveStart.y, &er
1671 ), &er
1672 );
1673 if ((int32_t)0L == xdiff) {
1674 rx = (uint32_t)ydiff;
1675 }
1676 else {
1677 if ((int32_t)0L == ydiff) {
1678 rx = (uint32_t)xdiff;
1679 }
1680 else {
1681 dx = (double)xdiff;
1682 dy = (double)ydiff;
1683 dx = dk4ma_rint(sqrt(dx * dx + dy * dy));
1684 rx = dk4ma_uint32_from_double(dx, &er);
1685 }
1686 }
1687 if (DK4_E_NONE != er.ec) {
1688 rx = (uint32_t)0UL;
1689 dk4error_copy(erp, &er);
1690 }
1691 }
1692
1693
1694
1695 void
MouseLeftCircleCenter(void)1696 WxdkdrawFrame::MouseLeftCircleCenter(void)
1697 {
1698
1699 if (m_bMousePos) {
1700 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
1701 m_pCurrent = wxdobj_add_circle(m_pDrw, NULL, &m_oStyle);
1702 if (NULL != m_pCurrent) {
1703 m_pCurrent->mark |= OBJ_MARKER_1;
1704 m_iState = S_CIRCLE_RADIUS;
1705 m_bAcceptablePoint = false;
1706 DK4_MEMCPY(\
1707 &m_ptMouseMoveStart,\
1708 &m_ptMousePosGrid,\
1709 sizeof(Wxd_point_t)\
1710 );
1711 SetMouseAndStatusTexts(m_iState);
1712 (m_pCurrent->det).e.x = m_ptMousePosGrid.x;
1713 (m_pCurrent->det).e.y = m_ptMousePosGrid.y;
1714 (m_pCurrent->det).e.rx = 0UL;
1715 (m_pCurrent->det).e.ry = 0UL;
1716 (m_pCurrent->det).e.a = 0;
1717 if (WXD_FS_PURE < m_pCurrent->fs) {
1718 UpdateStipples();
1719 }
1720 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
1721 }
1722 else {
1723 /* ERROR: Memory */
1724 dk4error_set_simple_error_code(
1725 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
1726 );
1727 }
1728 }
1729 else {
1730 }
1731
1732 }
1733
1734
1735
1736 void
MouseMoveCircleRadius(void)1737 WxdkdrawFrame::MouseMoveCircleRadius(void)
1738 {
1739 dk4_er_t er;
1740 uint32_t rx = 0UL;
1741 bool bOldAcceptable;
1742
1743 if (m_bMousePos) {
1744 if (NULL != m_pCurrent) {
1745 dk4error_init(&er);
1746 CalculateCircleRadius(rx, &er);
1747 if (DK4_E_NONE == er.ec) {
1748 (m_pCurrent->det).e.rx = rx;
1749 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
1750 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
1751 bOldAcceptable = m_bAcceptablePoint;
1752 m_bAcceptablePoint = IsAcceptablePoint();
1753 if (bOldAcceptable != m_bAcceptablePoint) {
1754 SetMouseAndStatusTexts(m_iState);
1755 }
1756 }
1757 else {
1758 dk4error_copy(&m_oErrorReport, &er);
1759 }
1760 }
1761 else {
1762 /* ERROR: Memory (already reported) */
1763 }
1764 }
1765 else {
1766 /* ERROR: No mouse position available */
1767 dk4error_set_simple_error_code(
1768 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
1769 );
1770 }
1771
1772 }
1773
1774
1775
1776 void
MouseLeftCircleRadius(void)1777 WxdkdrawFrame::MouseLeftCircleRadius(void)
1778 {
1779 dk4_er_t er;
1780 uint32_t rx = 0UL;
1781
1782 if (m_bMousePos) {
1783 if (IsAcceptablePoint()) {
1784 if (NULL != m_pCurrent) {
1785 dk4error_init(&er);
1786 CalculateCircleRadius(rx, &er);
1787 if (DK4_E_NONE == er.ec) {
1788 (m_pCurrent->det).e.rx = rx;
1789 m_pCurrent->mark = (uint8_t)(
1790 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
1791 );
1792 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
1793 m_pCurrent = NULL;
1794 SetModified();
1795 m_iState = S_CIRCLE_CENTER;
1796 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
1797 SetMouseAndStatusTexts(m_iState);
1798 }
1799 else {
1800 dk4error_copy(&m_oErrorReport, &er);
1801 }
1802 }
1803 else {
1804 /* ERROR: Memory (already reported) */
1805 }
1806 }
1807 }
1808 else {
1809 /* ERROR: No mouse position available */
1810 dk4error_set_simple_error_code(
1811 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
1812 );
1813 }
1814
1815 }
1816
1817
1818
1819 void
CalculateEllipseRadii(uint32_t & rx,uint32_t & ry,dk4_er_t * erp)1820 WxdkdrawFrame::CalculateEllipseRadii(uint32_t & rx,uint32_t & ry,dk4_er_t *erp)
1821 {
1822 dk4_er_t er;
1823
1824 dk4error_init(&er);
1825 rx = (uint32_t)dk4ma_int32_t_abs(
1826 dk4ma_int32_t_sub(
1827 m_ptMousePosGrid.x, m_ptMouseMoveStart.x, &er
1828 ), &er
1829 );
1830 ry = (uint32_t)dk4ma_int32_t_abs(
1831 dk4ma_int32_t_sub(
1832 m_ptMousePosGrid.y, m_ptMouseMoveStart.y, &er
1833 ), &er
1834 );
1835 if (DK4_E_NONE != er.ec) {
1836 rx = ry = (uint32_t)0UL;
1837 dk4error_copy(erp, &er);
1838 }
1839 }
1840
1841
1842
1843 void
MouseMoveEllipseCenter(void)1844 WxdkdrawFrame::MouseMoveEllipseCenter(void)
1845 {
1846
1847
1848 }
1849
1850
1851
1852 void
MouseLeftEllipseCenter(void)1853 WxdkdrawFrame::MouseLeftEllipseCenter(void)
1854 {
1855
1856 if (m_bMousePos) {
1857 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
1858 m_pCurrent = wxdobj_add_ellipse(m_pDrw, NULL, &m_oStyle);
1859 if (NULL != m_pCurrent) {
1860 m_pCurrent->mark |= OBJ_MARKER_1;
1861 m_iState = S_ELLIPSE_CORNER;
1862 m_bAcceptablePoint = false;
1863 DK4_MEMCPY(\
1864 &m_ptMouseMoveStart,\
1865 &m_ptMousePosGrid,\
1866 sizeof(Wxd_point_t)\
1867 );
1868 SetMouseAndStatusTexts(m_iState);
1869 (m_pCurrent->det).e.x = m_ptMousePosGrid.x;
1870 (m_pCurrent->det).e.y = m_ptMousePosGrid.y;
1871 (m_pCurrent->det).e.rx = 0UL;
1872 (m_pCurrent->det).e.ry = 0UL;
1873 (m_pCurrent->det).e.a = 0;
1874 if (WXD_FS_PURE < m_pCurrent->fs) {
1875 UpdateStipples();
1876 }
1877 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
1878 }
1879 else {
1880 /* ERROR: Memory */
1881 dk4error_set_simple_error_code(
1882 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
1883 );
1884 }
1885 }
1886 else {
1887 /* ERROR: Mouse position not known */
1888 dk4error_set_simple_error_code(
1889 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
1890 );
1891 }
1892
1893 }
1894
1895
1896
1897 void
MouseMoveEllipseCorner(void)1898 WxdkdrawFrame::MouseMoveEllipseCorner(void)
1899 {
1900 dk4_er_t er;
1901 uint32_t rx = 0UL;
1902 uint32_t ry = 0UL;
1903 bool bOldAcceptable;
1904
1905 if (m_bMousePos) {
1906 if (NULL != m_pCurrent) {
1907 dk4error_init(&er);
1908 CalculateEllipseRadii(rx, ry, &er);
1909 if (DK4_E_NONE == er.ec) {
1910 (m_pCurrent->det).e.rx = rx;
1911 (m_pCurrent->det).e.ry = ry;
1912 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
1913 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
1914 bOldAcceptable = m_bAcceptablePoint;
1915 m_bAcceptablePoint = IsAcceptablePoint();
1916 if (bOldAcceptable != m_bAcceptablePoint) {
1917 SetMouseAndStatusTexts(m_iState);
1918 }
1919 }
1920 else {
1921 dk4error_copy(&m_oErrorReport, &er);
1922 }
1923 }
1924 else {
1925 /* ERROR: Memory (already reported) */
1926 }
1927 }
1928 else {
1929 /* ERROR: No mouse position */
1930 dk4error_set_simple_error_code(
1931 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
1932 );
1933 }
1934
1935 }
1936
1937
1938
1939 void
MouseLeftEllipseCorner(void)1940 WxdkdrawFrame::MouseLeftEllipseCorner(void)
1941 {
1942 dk4_er_t er;
1943 uint32_t rx = 0UL;
1944 uint32_t ry = 0UL;
1945
1946 if (m_bMousePos) {
1947 if (IsAcceptablePoint()) {
1948 if (NULL != m_pCurrent) {
1949 dk4error_init(&er);
1950 CalculateEllipseRadii(rx, ry, &er);
1951 if (DK4_E_NONE == er.ec) {
1952 (m_pCurrent->det).e.rx = rx;
1953 (m_pCurrent->det).e.ry = ry;
1954 m_pCurrent->mark = (uint8_t)(
1955 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
1956 );
1957 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
1958 m_pCurrent = NULL;
1959 SetModified();
1960 m_iState = S_ELLIPSE_CENTER;
1961 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
1962 SetMouseAndStatusTexts(m_iState);
1963 }
1964 else {
1965 dk4error_copy(&m_oErrorReport, &er);
1966 }
1967 }
1968 else {
1969 /* ERROR: Memory (already reported). */
1970 }
1971 }
1972 }
1973 else {
1974 /* ERROR: Mouse position unknown */
1975 dk4error_set_simple_error_code(
1976 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
1977 );
1978 }
1979
1980 }
1981
1982
1983
1984 void
MouseMoveArc1(void)1985 WxdkdrawFrame::MouseMoveArc1(void)
1986 {
1987
1988
1989 }
1990
1991
1992
1993 void
MouseLeftArc1(void)1994 WxdkdrawFrame::MouseLeftArc1(void)
1995 {
1996
1997 if (m_bMousePos) {
1998 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
1999 m_pCurrent = wxdobj_add_arc(
2000 m_pDrw, NULL, ((WXD_OT_C_ARC == m_iObjToCreate) ? 1 : 0), &m_oStyle
2001 );
2002 if (NULL != m_pCurrent) {
2003 m_pCurrent->mark |= OBJ_MARKER_1;
2004 m_iState = S_ARC_2;
2005 m_bAcceptablePoint = false;
2006 (m_pCurrent->det).a.x1 =
2007 (m_pCurrent->det).a.x2 =
2008 (m_pCurrent->det).a.x3 = m_ptMousePosGrid.x;
2009 (m_pCurrent->det).a.y1 =
2010 (m_pCurrent->det).a.y2 =
2011 (m_pCurrent->det).a.y3 = m_ptMousePosGrid.y;
2012 (m_pCurrent->det).a.x = (double)(m_ptMousePosGrid.x);
2013 (m_pCurrent->det).a.y = (double)(m_ptMousePosGrid.y);
2014 (m_pCurrent->det).a.r = 0.0;
2015 (m_pCurrent->det).a.a = 0.0;
2016 (m_pCurrent->det).a.b = 2.0 * M_PI;
2017 (m_pCurrent->det).a.d = (int8_t)0;
2018 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
2019 SetMouseAndStatusTexts(m_iState);
2020 if (WXD_OT_C_ARC == m_iObjToCreate) {
2021 if (WXD_FS_PURE < m_pCurrent->fs) {
2022 UpdateStipples();
2023 }
2024 }
2025 }
2026 else {
2027 /* ERROR: Memory */
2028 dk4error_set_simple_error_code(
2029 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
2030 );
2031 }
2032 }
2033 else {
2034 /* ERROR: Unknown mouse position */
2035 dk4error_set_simple_error_code(
2036 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
2037 );
2038 }
2039
2040 }
2041
2042
2043
2044 void
MouseMoveArc2(void)2045 WxdkdrawFrame::MouseMoveArc2(void)
2046 {
2047 bool bOldAcceptable;
2048
2049 if (m_bMousePos) {
2050 if (NULL != m_pCurrent) {
2051 (m_pCurrent->det).a.x2 =
2052 (m_pCurrent->det).a.x3 = m_ptMousePosGrid.x;
2053 (m_pCurrent->det).a.y2 =
2054 (m_pCurrent->det).a.y3 = m_ptMousePosGrid.y;
2055 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
2056 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
2057 bOldAcceptable = m_bAcceptablePoint;
2058 m_bAcceptablePoint = IsAcceptablePoint();
2059 if (bOldAcceptable != m_bAcceptablePoint) {
2060 SetMouseAndStatusTexts(m_iState);
2061 }
2062 }
2063 else {
2064 /* ERROR: Memory (already reported) */
2065 }
2066 }
2067 else {
2068 /* ERROR: Unknown mouse position */
2069 dk4error_set_simple_error_code(
2070 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
2071 );
2072 }
2073
2074 }
2075
2076
2077
2078 void
MouseLeftArc2(void)2079 WxdkdrawFrame::MouseLeftArc2(void)
2080 {
2081
2082 if (m_bMousePos) {
2083 if (IsAcceptablePoint()) {
2084 if (NULL != m_pCurrent) {
2085 (m_pCurrent->det).a.x2 =
2086 (m_pCurrent->det).a.x3 = m_ptMousePosGrid.x;
2087 (m_pCurrent->det).a.y2 =
2088 (m_pCurrent->det).a.y3 = m_ptMousePosGrid.y;
2089 m_iState = S_ARC_3;
2090 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
2091 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
2092 SetMouseAndStatusTexts(m_iState);
2093 }
2094 else {
2095 /* ERROR: Memory (already reported) */
2096 }
2097 }
2098 }
2099 else {
2100 /* RROR: Mouse position unknown */
2101 dk4error_set_simple_error_code(
2102 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
2103 );
2104 }
2105
2106 }
2107
2108
2109
2110 void
MouseMoveArc3(void)2111 WxdkdrawFrame::MouseMoveArc3(void)
2112 {
2113 bool bOldAcceptable;
2114
2115 if (m_bMousePos) {
2116 if (NULL != m_pCurrent) {
2117 (m_pCurrent->det).a.x3 = m_ptMousePosGrid.x;
2118 (m_pCurrent->det).a.y3 = m_ptMousePosGrid.y;
2119 wxdarc_calculation(
2120 &((m_pCurrent->det).a.x),
2121 &((m_pCurrent->det).a.y),
2122 &((m_pCurrent->det).a.r),
2123 &((m_pCurrent->det).a.a),
2124 &((m_pCurrent->det).a.b),
2125 &((m_pCurrent->det).a.d),
2126 (m_pCurrent->det).a.x1,
2127 (m_pCurrent->det).a.y1,
2128 (m_pCurrent->det).a.x2,
2129 (m_pCurrent->det).a.y2,
2130 (m_pCurrent->det).a.x3,
2131 (m_pCurrent->det).a.y3
2132 );
2133 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
2134 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
2135 bOldAcceptable = m_bAcceptablePoint;
2136 m_bAcceptablePoint = IsAcceptablePoint();
2137 if (bOldAcceptable != m_bAcceptablePoint) {
2138 SetMouseAndStatusTexts(m_iState);
2139 }
2140 }
2141 else {
2142 /* ERROR: Memory (already reported) */
2143 }
2144 }
2145 else {
2146 /* ERROR: Unknown mouse position */
2147 dk4error_set_simple_error_code(
2148 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
2149 );
2150 }
2151
2152 }
2153
2154
2155
2156 void
MouseLeftArc3(void)2157 WxdkdrawFrame::MouseLeftArc3(void)
2158 {
2159
2160 if (m_bMousePos) {
2161 if (IsAcceptablePoint()) {
2162 if (NULL != m_pCurrent) {
2163 (m_pCurrent->det).a.x3 = m_ptMousePosGrid.x;
2164 (m_pCurrent->det).a.y3 = m_ptMousePosGrid.y;
2165 wxdarc_calculation(
2166 &((m_pCurrent->det).a.x),
2167 &((m_pCurrent->det).a.y),
2168 &((m_pCurrent->det).a.r),
2169 &((m_pCurrent->det).a.a),
2170 &((m_pCurrent->det).a.b),
2171 &((m_pCurrent->det).a.d),
2172 (m_pCurrent->det).a.x1,
2173 (m_pCurrent->det).a.y1,
2174 (m_pCurrent->det).a.x2,
2175 (m_pCurrent->det).a.y2,
2176 (m_pCurrent->det).a.x3,
2177 (m_pCurrent->det).a.y3
2178 );
2179 m_pCurrent->mark = (uint8_t)(
2180 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
2181 );
2182 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
2183 m_pCurrent = NULL;
2184 m_iState = S_ARC_1;
2185 SetModified();
2186 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
2187 SetMouseAndStatusTexts(m_iState);
2188 }
2189 else {
2190 /* ERROR: Memory (already reported). */
2191 }
2192 }
2193 }
2194 else {
2195 /* ERROR: Mouse position unknown */
2196 dk4error_set_simple_error_code(
2197 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
2198 );
2199 }
2200
2201 }
2202
2203
2204
2205 void
MouseMoveDot(void)2206 WxdkdrawFrame::MouseMoveDot(void)
2207 {
2208
2209
2210 }
2211
2212
2213
2214 void
MouseLeftDot(void)2215 WxdkdrawFrame::MouseLeftDot(void)
2216 {
2217
2218 if (m_bMousePos) {
2219 m_pCurrent = wxdobj_add_dot(
2220 m_pDrw, NULL,
2221 ((WXD_OT_DOT_WHITE == m_iObjToCreate) ? (1) : (0)),
2222 &m_oStyle
2223 );
2224 if (NULL != m_pCurrent) {
2225
2226
2227
2228
2229
2230
2231 (m_pCurrent->det).d.x = m_ptMousePosGrid.x;
2232 (m_pCurrent->det).d.y = m_ptMousePosGrid.y;
2233 (m_pCurrent->det).d.d = (uint16_t)(
2234 (WXD_OT_DOT_WHITE == m_iObjToCreate)
2235 ? (m_iv[IVI_DOT_DIAMETER_WHITE])
2236 : (m_iv[IVI_DOT_DIAMETER_FILLED])
2237 );
2238 m_pCurrent->mark = (uint8_t)(
2239 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
2240 );
2241 #if 0
2242 /* Bugfix 2021-06-13:
2243 Increasing the layer number must happen before registering
2244 the dot object for layers and stipples.
2245 So this functionality was moved into the WxdkdrawObj modules
2246 wxdobj_obj_new_dot() function which is called by
2247 the wxdobj_add_dot() before registering the object happens.
2248 */
2249 if (DK4_I16_MAX > m_pCurrent->lay) {
2250 m_pCurrent->lay += (int16_t)1;
2251 }
2252 #endif
2253 wxdobj_bb_simple_object(m_pDrw, m_pCurrent);
2254 m_pCurrent = NULL;
2255 SetModified();
2256 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
2257 }
2258 else {
2259 /* ERROR: Memory */
2260 dk4error_set_simple_error_code(
2261 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
2262 );
2263 }
2264 }
2265 else {
2266 /* ERROR: Mouse position unknown */
2267 dk4error_set_simple_error_code(
2268 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
2269 );
2270 }
2271
2272 }
2273
2274
2275
2276 void
MouseMoveText(void)2277 WxdkdrawFrame::MouseMoveText(void)
2278 {
2279
2280
2281 }
2282
2283
2284
2285 void
MouseLeftText(void)2286 WxdkdrawFrame::MouseLeftText(void)
2287 {
2288 Wxd_object_t *pObject = NULL;
2289 #if 0
2290 wxChar const *ptrExportText = NULL;
2291 wxChar const *ptrScreenText = NULL;
2292 #endif
2293 wxChar *ptrExportText = NULL;
2294 wxChar *ptrScreenText = NULL;
2295 int32_t x;
2296 int32_t y;
2297 bool bLaTeX;
2298
2299 x = m_ptMousePosGrid.x;
2300 y = m_ptMousePosGrid.y;
2301 bLaTeX = cbStyleTextLaTeX->GetValue();
2302 m_pCurrent = NULL;
2303 if (m_bMousePos) {
2304 WxdkdrawDlgTextInput tid(
2305 this, sTexts, sNlWx, &ptrExportText, &ptrScreenText, bLaTeX,
2306 &m_oErrorReport
2307 );
2308 Dk4WxApplicationHelper::ChooseChildPosition(*drawco, tid);
2309 if (wxID_OK == tid.ShowModal()) {
2310 if (NULL != ptrExportText) {
2311 pObject = wxdobj_add_textlabel(
2312 m_pDrw, NULL, ptrExportText, &m_oStyle
2313 );
2314 if (NULL != pObject) {
2315 (pObject->det).t.a = 0;
2316 (pObject->det).t.x = x;
2317 (pObject->det).t.y = y;
2318 (pObject->det).t.tsc = ptrScreenText;
2319 UpdateFonts();
2320 SetModified();
2321 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
2322 wxdobj_bb_simple_object(m_pDrw, pObject);
2323 }
2324 else {
2325 /* ERROR: Memory */
2326 dk4error_set_simple_error_code(
2327 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
2328 );
2329 }
2330 }
2331 }
2332 #if 0
2333 WxdkdrawDlgTextInput tid(this, sTexts, sNlWx, bLaTeX);
2334 Dk4WxApplicationHelper::ChooseChildPosition(*drawco, tid);
2335 if (wxID_OK == tid.ShowModal()) {
2336 wxTextCtrl *pExportText = tid.GetExportTextCtrl();
2337 wxTextCtrl *pScreenText = tid.GetScreenTextCtrl();
2338 wxString stringExp = pExportText->GetValue();
2339 wxString stringScr = pScreenText->GetValue();
2340 wxCStrData sExportText = stringExp.c_str();
2341 wxCStrData sScreenText = stringScr.c_str();
2342 ptrExportText = (wxChar const *)sExportText;
2343 ptrScreenText = (wxChar const *)sScreenText;
2344 if ((NULL != ptrExportText)) {
2345 if (0 < dk4strx_len(ptrExportText)) {
2346 pObject = wxdobj_add_textlabel(
2347 m_pDrw, NULL, ptrExportText, &m_oStyle
2348 );
2349 if (NULL != pObject) {
2350 (pObject->det).t.a = 0;
2351 (pObject->det).t.x = m_ptMousePosGrid.x;
2352 (pObject->det).t.y = m_ptMousePosGrid.y;
2353 UpdateFonts();
2354 SetModified();
2355 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
2356 wxdobj_bb_simple_object(m_pDrw, pObject);
2357 if (
2358 bLaTeX
2359 && (NULL != ptrScreenText)
2360 && (0 < dk4strx_len(ptrScreenText))
2361 ) {
2362 (pObject->det).t.tsc =
2363 dk4strx_dup(ptrScreenText, NULL);
2364 if (NULL == (pObject->det).t.tsc) {
2365 /* ERROR: Memory */
2366 dk4error_set_simple_error_code(
2367 &m_oErrorReport,
2368 DK4_E_MEMORY_ALLOCATION_FAILED
2369 );
2370 }
2371 }
2372 UpdateFonts();
2373 }
2374 else {
2375 /* ERROR: Memory */
2376 dk4error_set_simple_error_code(
2377 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
2378 );
2379 }
2380 }
2381 else {
2382 /* ERROR: No input for export text */
2383 dk4error_set_simple_error_code(
2384 &m_oErrorReport, WXD_E_NO_EXPORT_TEXT
2385 );
2386 }
2387 }
2388 else {
2389 /* ERROR: No export text (memory) */
2390 dk4error_set_simple_error_code(
2391 &m_oErrorReport, WXD_E_NO_EXPORT_TEXT
2392 );
2393 }
2394 }
2395 else {
2396 /* Aborted by user */
2397 }
2398 #endif
2399 }
2400 else {
2401 /* ERROR: Mouse position outside coordinates */
2402 dk4error_set_simple_error_code(
2403 &m_oErrorReport, WXD_E_MOUSE_POS_NOT_AVAILABLE
2404 );
2405 }
2406
2407 }
2408
2409
2410
2411 void
MouseMoveImage1(void)2412 WxdkdrawFrame::MouseMoveImage1(void)
2413 {
2414
2415
2416 }
2417
2418
2419
2420 void
MouseMoveImage2(void)2421 WxdkdrawFrame::MouseMoveImage2(void)
2422 {
2423 bool bOldAcceptable;
2424
2425 if (m_bMousePos) {
2426 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
2427 bOldAcceptable = m_bAcceptablePoint;
2428 m_bAcceptablePoint = IsAcceptablePoint();
2429 if (bOldAcceptable != m_bAcceptablePoint) {
2430 SetMouseAndStatusTexts(m_iState);
2431 }
2432 }
2433
2434 }
2435
2436
2437
2438 void
MouseLeftImage1(void)2439 WxdkdrawFrame::MouseLeftImage1(void)
2440 {
2441
2442 if (m_bMousePos) {
2443 DK4_MEMCPY(&m_ptMouseMoveStart,&m_ptMousePosGrid,sizeof(Wxd_point_t));
2444 m_iState = S_IMG_2;
2445 m_bAcceptablePoint = false;
2446 SetMouseAndStatusTexts(m_iState);
2447 }
2448
2449 }
2450
2451
2452
2453 void
MouseLeftImage2(void)2454 WxdkdrawFrame::MouseLeftImage2(void)
2455 {
2456 wxString sDialogTitle(sTexts[409]);
2457 wxString sFileTypes(image_files_to_open);
2458 wxChar const *vptr;
2459 Wxd_object_t *pobj;
2460
2461 if (m_bMousePos) {
2462 if (IsAcceptablePoint()) {
2463 if (
2464 (m_ptMouseMoveStart.x != m_ptMousePosGrid.x)
2465 && (m_ptMouseMoveStart.y != m_ptMousePosGrid.y)
2466 ) {
2467 #if wxCHECK_VERSION(2, 9, 0)
2468 wxFileDialog dlg(
2469 this, sDialogTitle, m_sImageDir, wxEmptyString,
2470 sFileTypes, (wxFD_OPEN | wxFD_FILE_MUST_EXIST)
2471 );
2472 #else
2473 wxFileDialog dlg(
2474 this, sDialogTitle, m_sImageDir, wxEmptyString,
2475 sFileTypes, wxOPEN
2476 );
2477 #endif
2478 if(wxID_OK == dlg.ShowModal()) {
2479 wxString pa = dlg.GetPath();
2480 m_sImageDir = dlg.GetDirectory();
2481 {
2482 wxCStrData vstrdata = pa.c_str();
2483 vptr = (wxChar const *)vstrdata;
2484 if (NULL != vptr) {
2485 pobj = wxdobj_add_image(m_pDrw,NULL,vptr,&m_oStyle);
2486 if (NULL != pobj) {
2487 (pobj->det).i.br.xl = m_ptMouseMoveStart.x;
2488 (pobj->det).i.br.yb = m_ptMouseMoveStart.y;
2489 (pobj->det).i.br.xr = m_ptMousePosGrid.x;
2490 (pobj->det).i.br.yt = m_ptMousePosGrid.y;
2491 wxdobj_bb_correct(&((pobj->det).i.br));
2492 wxdobj_load_image(
2493 pobj,
2494 pAppHelp->GetDkEncoding(),
2495 pAppHelp->GetWxEncoding()
2496 );
2497 SetModified();
2498 wxdobj_bb_simple_object(m_pDrw, pobj);
2499 }
2500 else {
2501 /* ERROR: Memory */
2502 dk4error_set_simple_error_code(
2503 &m_oErrorReport,
2504 DK4_E_MEMORY_ALLOCATION_FAILED
2505 );
2506 }
2507 }
2508 else {
2509 /* ERROR: No string data */
2510 dk4error_set_simple_error_code(
2511 &m_oErrorReport, WXD_E_NO_FILENAME
2512 );
2513 }
2514 }
2515 }
2516 else {
2517 }
2518 m_iState = S_IMG_1;
2519 SetMouseAndStatusTexts(m_iState);
2520 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
2521 }
2522 }
2523 }
2524
2525 }
2526
2527
2528
2529 void
MouseMoveLibelemPlace(void)2530 WxdkdrawFrame::MouseMoveLibelemPlace(void)
2531 {
2532
2533 /*
2534 Reaction is same as placing an element to move
2535 */
2536 MouseMoveMovePlace();
2537 if (NULL != m_pCurrent) {
2538 wxdobj_bb_modified_object(m_pDrw, m_pCurrent);
2539 }
2540
2541 }
2542
2543
2544
2545 void
MouseLeftLibelemPlace(void)2546 WxdkdrawFrame::MouseLeftLibelemPlace(void)
2547 {
2548
2549 if ((m_bMousePos) && (m_bMouseDiff)) {
2550 if (0 != wxdobj_shift_marked(m_pDrw, &m_ptMouseMoveDiff, 0)) {
2551 wxdobj_shift_marked(m_pDrw, &m_ptMouseMoveDiff, 1);
2552 m_iState = S_NOOP;
2553 /*
2554 2021-05-19
2555 Make sure the element just inserted is not shown
2556 as selected element.
2557 */
2558 if (NULL != m_pCurrent) {
2559 wxdobj_unmark_recursively(m_pCurrent, OBJ_MARKER_1);
2560 }
2561 SetModified();
2562 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
2563 if (NULL != m_pCurrent) {
2564 wxdobj_bb_modified_object(m_pDrw, m_pCurrent);
2565 }
2566 m_pCurrent = NULL;
2567 AddLibelem();
2568 }
2569 }
2570
2571 }
2572
2573
2574
2575 void
MouseMovePointMoveSelect(void)2576 WxdkdrawFrame::MouseMovePointMoveSelect(void)
2577 {
2578 Wxd_object_t *prevobj;
2579 uint16_t prevpoint;
2580
2581
2582 if (m_bMousePos) {
2583 /*
2584 Save previous candidate object and point
2585 */
2586 prevobj = m_pCurrent;
2587 prevpoint = m_uCurrent;
2588 /*
2589 Check for new candicate
2590 */
2591 if (NULL != m_pCurrent) {
2592 m_pCurrent->mark = (uint8_t)(
2593 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
2594 );
2595 }
2596 m_pCurrent = wxdobj_point_move_find_object(
2597 m_pDrw, &m_ptMousePosRaw, &m_uCurrent,
2598 (2.0 * (double)(drawco->m_uGridSnap))
2599 );
2600 if (NULL != m_pCurrent) {
2601 m_pCurrent->mark |= OBJ_MARKER_1;
2602
2603 }
2604 /*
2605 On object or point change redraw the markup
2606 */
2607 if (
2608 ((NULL != m_pCurrent) && (NULL == prevobj))
2609 || ((NULL == m_pCurrent) && (NULL != prevobj))
2610 ) {
2611 SetMouseAndStatusTexts(m_iState);
2612 }
2613 if ((prevobj != m_pCurrent) || (prevpoint != m_uCurrent)) {
2614 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
2615 }
2616 }
2617
2618 }
2619
2620
2621
2622 void
MouseLeftPointMoveSelect(void)2623 WxdkdrawFrame::MouseLeftPointMoveSelect(void)
2624 {
2625
2626 if (m_bMousePos) {
2627 if (NULL != m_pCurrent) {
2628 m_pCurrent->mark = (uint8_t)(
2629 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
2630 );
2631 }
2632 m_pCurrent = wxdobj_point_move_find_object(
2633 m_pDrw, &m_ptMousePosRaw, &m_uCurrent,
2634 (2.0 * (double)(drawco->m_uGridSnap))
2635 );
2636 if (NULL != m_pCurrent) {
2637
2638
2639 m_pCurrent->mark |= OBJ_MARKER_1;
2640 m_bSnap = (
2641 (0 == cbPointMoveMode->GetSelection()) ? (true) : (false)
2642 );
2643
2644
2645 DK4_MEMCPY(\
2646 &m_ptMouseMoveStart,\
2647 &m_ptMousePosGrid,\
2648 sizeof(Wxd_point_t)\
2649 );
2650
2651
2652 m_ptMouseMoveDiff.x = (int32_t)0L;
2653 m_ptMouseMoveDiff.y = (int32_t)0L;
2654 m_bMouseDiff = true;
2655
2656
2657 if (
2658 wxdobj_get_control_point(
2659 &m_ptPointMoveOri, m_pCurrent, m_uCurrent
2660 )
2661 ) {
2662
2663
2664 switch ( (int)(m_pCurrent->ot) ) {
2665 case WXD_OT_ELLIPSE : case WXD_OT_CIRCLE : {
2666
2667
2668 DK4_MEMCPY(\
2669 &m_ellPointMoveOri,\
2670 &((m_pCurrent->det).e),\
2671 sizeof(Wxd_det_ellipse_t)\
2672 );
2673
2674
2675 } break;
2676 }
2677 if (m_bSnap) {
2678
2679
2680 wxdobj_set_control_point(
2681 m_pCurrent, &m_ptMousePosGrid, m_uCurrent
2682 );
2683
2684
2685 }
2686 m_iState = S_MOVEPT_PLACE;
2687 SetMouseAndStatusTexts(m_iState);
2688 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
2689 }
2690 else {
2691 /* ERROR: Failed to get control point */
2692 dk4error_set_simple_error_code(
2693 &m_oErrorReport, WXD_E_GET_CONTROL_POINT
2694 );
2695 }
2696 }
2697 }
2698
2699 }
2700
2701
2702
2703 void
MouseMovePointMovePlace(void)2704 WxdkdrawFrame::MouseMovePointMovePlace(void)
2705 {
2706 dk4_er_t er;
2707 Wxd_point_t pt;
2708
2709
2710 if (m_bMousePos && (NULL != m_pCurrent)) {
2711 if (m_bSnap || m_bMouseDiff) {
2712 if (m_bSnap) {
2713 if (
2714 wxdobj_set_control_point(
2715 m_pCurrent, &m_ptMousePosGrid, m_uCurrent
2716 )
2717 ) {
2718 switch ( (int)(m_pCurrent->ot) ) {
2719 case WXD_OT_BOX : {
2720 wxdobj_bb_correct(
2721 &((m_pCurrent->det).b.b), &m_uCurrent
2722 );
2723 } break;
2724 case WXD_OT_IMAGE : {
2725 wxdobj_bb_correct(
2726 &((m_pCurrent->det).i.br), &m_uCurrent
2727 );
2728 } break;
2729 }
2730 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
2731 wxdobj_bb_modified_object(m_pDrw, m_pCurrent);
2732 }
2733 else {
2734 /* ERROR: Failed to set control point */
2735 dk4error_set_simple_error_code(
2736 &m_oErrorReport, WXD_E_SET_CONTROL_POINT
2737 );
2738 }
2739 }
2740 else {
2741 dk4error_init(&er);
2742 pt.x = dk4ma_int32_t_add(
2743 m_ptPointMoveOri.x, m_ptMouseMoveDiff.x, &er
2744 );
2745 pt.y = dk4ma_int32_t_add(
2746 m_ptPointMoveOri.y, m_ptMouseMoveDiff.y, &er
2747 );
2748 if (DK4_E_NONE == er.ec) {
2749 if (
2750 wxdobj_set_control_point(m_pCurrent, &pt, m_uCurrent)
2751 ) {
2752 switch ( (int)(m_pCurrent->ot) ) {
2753 case WXD_OT_BOX : {
2754 wxdobj_bb_correct(
2755 &((m_pCurrent->det).b.b), &m_uCurrent
2756 );
2757 } break;
2758 case WXD_OT_IMAGE : {
2759 wxdobj_bb_correct(
2760 &((m_pCurrent->det).i.br), &m_uCurrent
2761 );
2762 } break;
2763 }
2764 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
2765 wxdobj_bb_modified_object(m_pDrw, m_pCurrent);
2766 }
2767 else {
2768 /* ERROR: Failed to set control point */
2769 dk4error_set_simple_error_code(
2770 &m_oErrorReport, WXD_E_SET_CONTROL_POINT
2771 );
2772 }
2773 }
2774 else {
2775 /* ERROR: Math overflow */
2776 dk4error_set_simple_error_code(
2777 &m_oErrorReport, WXD_E_OVERFLOW_COORDINATES
2778 );
2779 }
2780 }
2781 }
2782 else {
2783 /* ERROR: Failed to calculate mouse difference */
2784 dk4error_set_simple_error_code(
2785 &m_oErrorReport, WXD_E_OVERFLOW_COORDINATES
2786 );
2787 }
2788 }
2789 #if TRACE_DEBUG
2790 else {
2791 if (!(m_bMousePos)) {
2792 }
2793 if (NULL == m_pCurrent) {
2794 }
2795 }
2796 #endif
2797
2798 }
2799
2800
2801
2802 void
ModifySplineValue(Wxd_object_t * pCurrent,uint16_t uCurrent)2803 WxdkdrawFrame::ModifySplineValue(Wxd_object_t *pCurrent, uint16_t uCurrent)
2804 {
2805 double olds;
2806
2807 if (
2808 (NULL != pCurrent)
2809 && (
2810 (WXD_OT_O_SPLINE == pCurrent->ot)
2811 || (WXD_OT_C_SPLINE == pCurrent->ot)
2812 )
2813 && (uCurrent < (pCurrent->det).s.n)
2814 ) {
2815 WxdkdrawDlgSplineValue dlg(
2816 this, drawco, m_pDrw, sTexts, &(((pCurrent->det).s.p)[uCurrent].s)
2817 );
2818 Dk4WxApplicationHelper::ChooseChildPosition(*drawco, dlg);
2819 olds = ((pCurrent->det).s.p)[uCurrent].s;
2820 dlg.ShowModal();
2821 wxdobj_bb_modified_object(m_pDrw, pCurrent);
2822 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
2823 m_bUpdate = true;
2824 if (olds != ((pCurrent->det).s.p)[uCurrent].s) {
2825 SetModified();
2826 }
2827 }
2828 }
2829
2830
2831
2832 void
MouseLeftPointMovePlace(void)2833 WxdkdrawFrame::MouseLeftPointMovePlace(void)
2834 {
2835 dk4_er_t er;
2836 Wxd_point_t pt;
2837
2838 if (m_bMousePos && (NULL != m_pCurrent)) {
2839
2840 if (m_bSnap || m_bMouseDiff) {
2841 if (m_bSnap) {
2842 if (
2843 wxdobj_set_control_point(
2844 m_pCurrent, &m_ptMousePosGrid, m_uCurrent
2845 )
2846 ) {
2847 switch ( (int)(m_pCurrent->ot) ) {
2848 case WXD_OT_BOX : {
2849 wxdobj_bb_correct(
2850 &((m_pCurrent->det).b.b), &m_uCurrent
2851 );
2852 } break;
2853 case WXD_OT_IMAGE : {
2854 wxdobj_bb_correct(
2855 &((m_pCurrent->det).i.br), &m_uCurrent
2856 );
2857 /* 2020-03-24 Bugfix
2858 After changing the available space we must
2859 re-calculate the used space
2860 */
2861 wxdobj_image_placement(m_pCurrent);
2862 } break;
2863 }
2864 m_pCurrent->mark = (uint8_t)(
2865 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
2866 );
2867 if (
2868 (NULL != m_pCurrent)
2869 && (
2870 (WXD_OT_O_SPLINE == m_pCurrent->ot)
2871 || (WXD_OT_C_SPLINE == m_pCurrent->ot)
2872 )
2873 && (m_uCurrent < (m_pCurrent->det).s.n)
2874 ) {
2875 #if 0
2876 /* 2020-03-22 Modification
2877 Changing spline s value is now decoupled
2878 from moving spline points.
2879 */
2880 ModifySplineValue(m_pCurrent, m_uCurrent);
2881 #endif
2882 }
2883 m_pCurrent = NULL;
2884 m_uCurrent = (uint16_t)0U;
2885 m_iState = S_MOVEPT_SELECT;
2886 SetMouseAndStatusTexts(m_iState);
2887 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
2888 SetModified();
2889 }
2890 else {
2891 /* ERROR: Failed to set control point */
2892 dk4error_set_simple_error_code(
2893 &m_oErrorReport, WXD_E_SET_CONTROL_POINT
2894 );
2895 }
2896 }
2897 else {
2898 dk4error_init(&er);
2899 pt.x = dk4ma_int32_t_add(
2900 m_ptPointMoveOri.x, m_ptMouseMoveDiff.x, &er
2901 );
2902 pt.y = dk4ma_int32_t_add(
2903 m_ptPointMoveOri.y, m_ptMouseMoveDiff.y, &er
2904 );
2905 if (DK4_E_NONE == er.ec) {
2906 if (
2907 wxdobj_set_control_point(m_pCurrent, &pt, m_uCurrent)
2908 ) {
2909 switch ( (int)(m_pCurrent->ot) ) {
2910 case WXD_OT_BOX : {
2911 wxdobj_bb_correct(
2912 &((m_pCurrent->det).b.b), &m_uCurrent
2913 );
2914 } break;
2915 case WXD_OT_IMAGE : {
2916 wxdobj_bb_correct(
2917 &((m_pCurrent->det).i.br), &m_uCurrent
2918 );
2919 } break;
2920 }
2921 m_pCurrent->mark = (uint8_t)(
2922 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
2923 );
2924 if (
2925 (NULL != m_pCurrent)
2926 && (
2927 (WXD_OT_O_SPLINE == m_pCurrent->ot)
2928 || (WXD_OT_C_SPLINE == m_pCurrent->ot)
2929 )
2930 && (m_uCurrent < (m_pCurrent->det).s.n)
2931 ) {
2932 #if 0
2933 ModifySplineValue(m_pCurrent, m_uCurrent);
2934 #endif
2935 }
2936 m_pCurrent = NULL;
2937 m_uCurrent = (uint16_t)0U;
2938 m_iState = S_MOVEPT_SELECT;
2939 SetMouseAndStatusTexts(m_iState);
2940 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
2941 SetModified();
2942 }
2943 else {
2944 /* ERROR: Failed to set control point */
2945 dk4error_set_simple_error_code(
2946 &m_oErrorReport, WXD_E_SET_CONTROL_POINT
2947 );
2948 }
2949 }
2950 else {
2951 /* ERROR: Math overflow */
2952 dk4error_set_simple_error_code(
2953 &m_oErrorReport, WXD_E_OVERFLOW_COORDINATES
2954 );
2955 }
2956 }
2957 }
2958 else {
2959 /* ERROR: Failed to calculate mouse difference */
2960 dk4error_set_simple_error_code(
2961 &m_oErrorReport, WXD_E_OVERFLOW_COORDINATES
2962 );
2963 }
2964 }
2965
2966 }
2967
2968
2969
2970 void
MouseMovePointDelete(void)2971 WxdkdrawFrame::MouseMovePointDelete(void)
2972 {
2973 Wxd_object_t *prevobj;
2974 uint16_t prevpoint;
2975
2976 if (m_bMousePos) {
2977 prevobj = m_pCurrent;
2978 prevpoint = m_uCurrent;
2979 if (NULL != m_pCurrent) {
2980 m_pCurrent->mark = (uint8_t)(
2981 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
2982 );
2983 }
2984 m_pCurrent = wxdobj_point_del_find_object(
2985 m_pDrw, &m_ptMousePosRaw, &m_uCurrent,
2986 (2.0 * (double)(drawco->m_uGridSnap))
2987 );
2988 if (NULL != m_pCurrent) {
2989 m_pCurrent->mark |= OBJ_MARKER_1;
2990
2991 }
2992 if (
2993 ((NULL != m_pCurrent) && (NULL == prevobj))
2994 || ((NULL == m_pCurrent) && (NULL != prevobj))
2995 ) {
2996 SetMouseAndStatusTexts(m_iState);
2997 }
2998 if ((prevobj != m_pCurrent) || (prevpoint != m_uCurrent)) {
2999 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
3000 }
3001 }
3002
3003 }
3004
3005
3006
3007 void
MouseLeftPointDelete(void)3008 WxdkdrawFrame::MouseLeftPointDelete(void)
3009 {
3010 Wxd_object_t *prevobj;
3011 #if 0
3012 uint16_t prevpoint;
3013 #endif
3014
3015 if (m_bMousePos) {
3016 prevobj = m_pCurrent;
3017 #if 0
3018 prevpoint = m_uCurrent;
3019 #endif
3020 if (NULL != m_pCurrent) {
3021 m_pCurrent->mark = (uint8_t)(
3022 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
3023 );
3024 }
3025 m_pCurrent = wxdobj_point_del_find_object(
3026 m_pDrw, &m_ptMousePosRaw, &m_uCurrent,
3027 (2.0 * (double)(drawco->m_uGridSnap))
3028 );
3029 if (NULL != m_pCurrent) {
3030 wxdobj_delete_control_point(m_pCurrent, m_uCurrent);
3031 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
3032 wxdobj_bb_modified_object(m_pDrw, m_pCurrent);
3033 m_pCurrent = NULL;
3034 SetMouseAndStatusTexts(m_iState);
3035 SetModified();
3036 }
3037 else {
3038 if (NULL != prevobj) {
3039 SetMouseAndStatusTexts(m_iState);
3040 }
3041 }
3042 }
3043
3044 }
3045
3046
3047
3048 void
MouseMovePointAddSelect(void)3049 WxdkdrawFrame::MouseMovePointAddSelect(void)
3050 {
3051 Wxd_object_t *prevobj;
3052 uint16_t prevpoint;
3053 bool prevappend;
3054
3055 if (m_bMousePos) {
3056 prevobj = m_pCurrent;
3057 prevpoint = m_uCurrent;
3058 prevappend = m_bAppendPoint;
3059 if (NULL != m_pCurrent) {
3060 m_pCurrent->mark = (uint8_t)(
3061 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
3062 );
3063 }
3064 m_pCurrent = wxdobj_point_add_find_object(
3065 m_pDrw, &m_ptMousePosRaw, &m_uCurrent, &m_bAppendPoint,
3066 (2.0 * (double)(drawco->m_uGridSnap))
3067 );
3068 if (NULL != m_pCurrent) {
3069 m_pCurrent->mark |= OBJ_MARKER_1;
3070 }
3071 if (
3072 (prevobj != m_pCurrent)
3073 || (prevpoint != m_uCurrent)
3074 || (prevappend != m_bAppendPoint)
3075 ) {
3076 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
3077 }
3078 if (
3079 ((NULL == m_pCurrent) && (NULL != prevobj))
3080 || ((NULL != m_pCurrent) && (NULL == prevobj))
3081 ) {
3082 SetMouseAndStatusTexts(m_iState);
3083 }
3084 }
3085
3086 }
3087
3088
3089
3090 void
MouseLeftPointAddSelect(void)3091 WxdkdrawFrame::MouseLeftPointAddSelect(void)
3092 {
3093 bool bres = false;
3094
3095 if (m_bMousePos) {
3096 if (NULL != m_pCurrent) {
3097 m_pCurrent->mark = (uint8_t)(
3098 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
3099 );
3100 }
3101 m_pCurrent = wxdobj_point_add_find_object(
3102 m_pDrw, &m_ptMousePosRaw, &m_uCurrent, &m_bAppendPoint,
3103 (2.0 * (double)(drawco->m_uGridSnap))
3104 );
3105 if (NULL != m_pCurrent) {
3106 m_pCurrent->mark |= OBJ_MARKER_1;
3107 if (m_bAppendPoint) {
3108 bres = wxdobj_add_control_point(
3109 m_pCurrent, (uint16_t)(m_uCurrent + 1U), &m_ptMousePosGrid
3110 );
3111 if (bres) {
3112 m_uCurrent++;
3113 }
3114 }
3115 else {
3116 bres = wxdobj_add_control_point(
3117 m_pCurrent, m_uCurrent, &m_ptMousePosGrid
3118 );
3119 }
3120 if (bres) {
3121 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
3122 wxdobj_bb_modified_object(m_pDrw, m_pCurrent);
3123 m_iState = S_ADDPT_PLACE;
3124 SetMouseAndStatusTexts(m_iState);
3125 }
3126 }
3127 }
3128
3129 }
3130
3131
3132
3133 void
MouseMovePointAddPlace(void)3134 WxdkdrawFrame::MouseMovePointAddPlace(void)
3135 {
3136
3137 if (m_bMousePos) {
3138 if (NULL != m_pCurrent) {
3139 wxdobj_set_control_point(m_pCurrent,&m_ptMousePosGrid,m_uCurrent);
3140 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
3141 wxdobj_bb_modified_object(m_pDrw, m_pCurrent);
3142 }
3143 }
3144
3145 }
3146
3147
3148
3149 void
MouseLeftPointAddPlace(void)3150 WxdkdrawFrame::MouseLeftPointAddPlace(void)
3151 {
3152
3153 if (m_bMousePos) {
3154 if (NULL != m_pCurrent) {
3155 wxdobj_set_control_point(m_pCurrent,&m_ptMousePosGrid,m_uCurrent);
3156 m_iState = S_ADDPT_SELECT;
3157 m_pCurrent->mark = (uint8_t)(
3158 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
3159 );
3160 wxdobj_bb_modified_object(m_pDrw, m_pCurrent);
3161 m_pCurrent = NULL;
3162 SetMouseAndStatusTexts(m_iState);
3163 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
3164 SetModified();
3165 }
3166 }
3167
3168 }
3169
3170
3171
3172 void
MouseMoveDrawingSizeSelect(void)3173 WxdkdrawFrame::MouseMoveDrawingSizeSelect(void)
3174 {
3175 dk4_gra_point_t ppt;
3176 double dlim;
3177 double d;
3178 uint16_t prevSelected;
3179 uint16_t newSelected;
3180 bool prevHavePoint;
3181
3182
3183 if (m_bMousePos) {
3184 prevSelected = m_uCurrent;
3185 prevHavePoint = m_bHaveCornerPoint;
3186 newSelected = (uint16_t)0U;
3187 dlim = 2.0 * (double)(drawco->m_uGridSnap);
3188 ppt.x = (double)(m_ptMousePosRaw.x);
3189 ppt.y = (double)(m_ptMousePosRaw.y);
3190 d = wxdobj_dist_box(
3191 &(m_pDrw->bb), (uint32_t)0UL, &ppt, true, &newSelected
3192 );
3193 if (dlim >= d) {
3194 m_uCurrent = newSelected;
3195 m_bHaveCornerPoint = true;
3196 }
3197 else {
3198 m_uCurrent = (uint16_t)0U;
3199 m_bHaveCornerPoint = false;
3200 }
3201 if (
3202 (prevSelected != m_uCurrent)
3203 || (prevHavePoint != m_bHaveCornerPoint)
3204 ) {
3205 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
3206 }
3207 if (prevHavePoint != m_bHaveCornerPoint) {
3208 SetMouseAndStatusTexts(m_iState);
3209 }
3210 }
3211
3212 }
3213
3214
3215
3216 void
MouseLeftDrawingSizeSelect(void)3217 WxdkdrawFrame::MouseLeftDrawingSizeSelect(void)
3218 {
3219 dk4_gra_point_t ppt;
3220 double dlim;
3221 double d;
3222 uint16_t newSelected;
3223
3224 if (m_bMousePos) {
3225 newSelected = (uint16_t)0U;
3226 dlim = 2.0 * (double)(drawco->m_uGridSnap);
3227 ppt.x = (double)(m_ptMousePosRaw.x);
3228 ppt.y = (double)(m_ptMousePosRaw.y);
3229 d = wxdobj_dist_box(
3230 &(m_pDrw->bb), (uint32_t)0UL, &ppt, true, &newSelected
3231 );
3232 if (dlim >= d) {
3233 m_uCurrent = newSelected;
3234 m_bHaveCornerPoint = true;
3235 m_bSnap = (
3236 (0 == cbPointMoveMode->GetSelection()) ? (true) : (false)
3237 );
3238 DK4_MEMCPY(\
3239 &m_ptMouseMoveStart,\
3240 &m_ptMousePosGrid,\
3241 sizeof(Wxd_point_t)\
3242 );
3243 DK4_MEMCPY(\
3244 &m_ptPointMoveOri,\
3245 &m_ptMousePosGrid,\
3246 sizeof(Wxd_point_t)\
3247 );
3248 m_ptMouseMoveDiff.x = (int32_t)0L;
3249 m_ptMouseMoveDiff.y = (int32_t)0L;
3250 m_bMouseDiff = true;
3251 switch ( (int)m_uCurrent ) {
3252 case 3 : {
3253 m_ptPointMoveOri.x = m_oBorder.det.b.b.xl;
3254 m_ptPointMoveOri.y = m_oBorder.det.b.b.yt;
3255 } break;
3256 case 2 : {
3257 m_ptPointMoveOri.x = m_oBorder.det.b.b.xr;
3258 m_ptPointMoveOri.y = m_oBorder.det.b.b.yt;
3259 } break;
3260 case 1 : {
3261 m_ptPointMoveOri.x = m_oBorder.det.b.b.xr;
3262 m_ptPointMoveOri.y = m_oBorder.det.b.b.yb;
3263 } break;
3264 default : {
3265 m_ptPointMoveOri.x = m_oBorder.det.b.b.xl;
3266 m_ptPointMoveOri.y = m_oBorder.det.b.b.yb;
3267 } break;
3268 }
3269 if (m_bSnap) {
3270 wxdobj_set_control_point(
3271 &m_oBorder, &m_ptMousePosGrid, m_uCurrent
3272 );
3273 wxdobj_bb_correct(
3274 &(m_oBorder.det.b.b), &m_uCurrent
3275 );
3276 DK4_MEMCPY(\
3277 &(m_pDrw->bb),&(m_oBorder.det.b.b),sizeof(Wxd_bb_t)\
3278 );
3279 }
3280 else {
3281 }
3282 m_iState = S_DRWSZ_PLACE;
3283 SetMouseAndStatusTexts(m_iState);
3284 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
3285 }
3286 }
3287
3288 }
3289
3290
3291
3292 void
MouseMoveDrawingSizePlace(void)3293 WxdkdrawFrame::MouseMoveDrawingSizePlace(void)
3294 {
3295 dk4_er_t er;
3296 Wxd_point_t pt;
3297
3298 if (m_bMousePos) {
3299 if (m_bSnap) {
3300 wxdobj_set_control_point(
3301 &m_oBorder, &m_ptMousePosGrid, m_uCurrent
3302 );
3303 wxdobj_bb_correct(
3304 &(m_oBorder.det.b.b), &m_uCurrent
3305 );
3306 DK4_MEMCPY(\
3307 &(m_pDrw->bb),&(m_oBorder.det.b.b),sizeof(Wxd_bb_t)\
3308 );
3309 }
3310 else {
3311 if (m_bMouseDiff) {
3312 dk4error_init(&er);
3313 pt.x = dk4ma_int32_t_add(
3314 m_ptPointMoveOri.x, m_ptMouseMoveDiff.x, &er
3315 );
3316 pt.y = dk4ma_int32_t_add(
3317 m_ptPointMoveOri.y, m_ptMouseMoveDiff.y, &er
3318 );
3319 if (DK4_E_NONE == er.ec) {
3320 wxdobj_set_control_point(
3321 &m_oBorder, &pt, m_uCurrent
3322 );
3323 wxdobj_bb_correct(
3324 &(m_oBorder.det.b.b), &m_uCurrent
3325 );
3326 DK4_MEMCPY(\
3327 &(m_pDrw->bb),&(m_oBorder.det.b.b),sizeof(Wxd_bb_t)\
3328 );
3329 }
3330 }
3331 }
3332 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
3333 }
3334
3335 }
3336
3337
3338
3339 void
MouseLeftDrawingSizePlace(void)3340 WxdkdrawFrame::MouseLeftDrawingSizePlace(void)
3341 {
3342 dk4_er_t er;
3343 Wxd_point_t pt;
3344 bool bEqual = false;;
3345
3346 if (m_bMousePos) {
3347 if (m_bSnap) {
3348 wxdobj_set_control_point(
3349 &m_oBorder, &m_ptMousePosGrid, m_uCurrent
3350 );
3351 wxdobj_bb_correct(
3352 &(m_oBorder.det.b.b), &m_uCurrent
3353 );
3354 #if 0
3355 bEqual = wxdobj_bb_equal(&(m_pDrw->bb), &(m_oBorder.det.b.b));
3356 #endif
3357 bEqual = wxdobj_bb_equal(&(m_pDrw->bb), &m_oOldSize);
3358
3359 DK4_MEMCPY(\
3360 &(m_pDrw->bb),&(m_oBorder.det.b.b),sizeof(Wxd_bb_t)\
3361 );
3362 }
3363 else {
3364 if (m_bMouseDiff) {
3365 dk4error_init(&er);
3366 pt.x = dk4ma_int32_t_add(
3367 m_ptPointMoveOri.x, m_ptMouseMoveDiff.x, &er
3368 );
3369 pt.y = dk4ma_int32_t_add(
3370 m_ptPointMoveOri.y, m_ptMouseMoveDiff.y, &er
3371 );
3372 if (DK4_E_NONE == er.ec) {
3373 wxdobj_set_control_point(
3374 &m_oBorder, &pt, m_uCurrent
3375 );
3376 wxdobj_bb_correct(
3377 &(m_oBorder.det.b.b), &m_uCurrent
3378 );
3379 #if 0
3380 bEqual = wxdobj_bb_equal(
3381 &(m_pDrw->bb), &(m_oBorder.det.b.b)
3382 );
3383 #endif
3384 bEqual = wxdobj_bb_equal(&(m_pDrw->bb), &m_oOldSize);
3385
3386 DK4_MEMCPY(\
3387 &(m_pDrw->bb),&(m_oBorder.det.b.b),sizeof(Wxd_bb_t)\
3388 );
3389 }
3390 }
3391 }
3392 if ((!(bEqual)) && (0 != m_iv[IVI_C_COR_POSITION])) {
3393 OnCenterViewFunction();
3394 }
3395 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_GRID);
3396 m_iState = S_DRWSZ_SELECT;
3397 SetMouseAndStatusTexts(m_iState);
3398 if (0 != DK4_MEMCMP(&m_oOldSize,&(m_pDrw->bb),sizeof(Wxd_bb_t))) {
3399 SetModified();
3400 }
3401 DK4_MEMCPY(&m_oOldSize,&(m_pDrw->bb),sizeof(Wxd_bb_t));
3402 }
3403
3404 }
3405
3406
3407
3408 void
MouseMoveFlip(void)3409 WxdkdrawFrame::MouseMoveFlip(void)
3410 {
3411 Wxd_object_t *pOldCurrent;
3412
3413 if (m_bMousePos) {
3414 pOldCurrent = m_pCurrent;
3415 m_pCurrent = FindNearestObject(true);
3416 if (m_pCurrent != pOldCurrent) {
3417 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
3418 if (NULL != m_pCurrent) {
3419 wxdobj_mark_recursively(m_pCurrent, OBJ_MARKER_1);
3420 }
3421 if (
3422 ((NULL != m_pCurrent) && (NULL == pOldCurrent))
3423 || ((NULL == m_pCurrent) && (NULL != pOldCurrent))
3424 ) {
3425 SetMouseAndStatusTexts(m_iState);
3426 }
3427 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
3428 }
3429 }
3430 else {
3431 }
3432
3433 }
3434
3435
3436
3437 void
MouseLeftFlip(void)3438 WxdkdrawFrame::MouseLeftFlip(void)
3439 {
3440 Wxd_bb_t bball;
3441 Wxd_bb_t bbobj;
3442 bool bFirst;
3443 bool bSuccess;
3444 Wxd_object_t *pobj;
3445
3446 if (m_bMousePos) {
3447 m_pCurrent = FindNearestObject(true);
3448 if (NULL != m_pCurrent) {
3449 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
3450 switch ( (int)(m_pCurrent->ot) ) {
3451 case WXD_OT_GROUP_BEGIN : {
3452 wxdobj_mark_recursively(m_pCurrent, OBJ_MARKER_1);
3453 /*
3454 Gather bounding box information
3455 */
3456 wxdobj_det_init_bb(&bball);
3457 bFirst = true;
3458 dk4sto_it_reset(m_pDrw->i_flat);
3459 do {
3460 pobj = (Wxd_object_t *)dk4sto_it_next(m_pDrw->i_flat);
3461 if (
3462 (NULL != pobj)
3463 && (wxdobj_is_marked(pobj, OBJ_MARKER_1))
3464 ) {
3465 if (wxdobj_control_pt_to_bb(&bbobj, pobj)) {
3466 if (bFirst) {
3467 DK4_MEMCPY(&bball,&bbobj,sizeof(Wxd_bb_t));
3468 bFirst = false;
3469 }
3470 else {
3471 wxdobj_bb_add_bb(&bball, &bbobj);
3472 }
3473 }
3474 }
3475 } while (NULL != pobj);
3476 /*
3477 Run test
3478 */
3479 bSuccess = true;
3480 dk4sto_it_reset(m_pDrw->i_flat);
3481 do {
3482 pobj = (Wxd_object_t *)dk4sto_it_next(m_pDrw->i_flat);
3483 if (
3484 (NULL != pobj)
3485 && (wxdobj_is_marked(pobj, OBJ_MARKER_1))
3486 ) {
3487 bFirst = wxdobj_flip_object(
3488 pobj, &bball, m_bVerticalFlip, false
3489 );
3490 if (!(bFirst)) { bSuccess = false; }
3491 }
3492 } while (NULL != pobj);
3493 /*
3494 Real run
3495 */
3496 if (bSuccess) {
3497 bSuccess = false;
3498 dk4sto_it_reset(m_pDrw->i_flat);
3499 do {
3500 pobj =
3501 (Wxd_object_t *)dk4sto_it_next(m_pDrw->i_flat);
3502 if (
3503 (NULL != pobj)
3504 && (wxdobj_is_marked(pobj, OBJ_MARKER_1))
3505 ) {
3506 wxdobj_flip_object(
3507 pobj, &bball, m_bVerticalFlip, true
3508 );
3509 bSuccess = true;
3510 }
3511 } while (NULL != pobj);
3512 wxdobj_bb_modified_object(m_pDrw, m_pCurrent);
3513 if (bSuccess) {
3514 SetModified();
3515 }
3516 }
3517 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
3518 } break;
3519 case WXD_OT_TEXT :
3520 case WXD_OT_POLYLINE :
3521 case WXD_OT_O_SPLINE :
3522 case WXD_OT_O_ARC :
3523 case WXD_OT_POLYGON :
3524 case WXD_OT_C_SPLINE :
3525 case WXD_OT_C_ARC :
3526 case WXD_OT_ELLIPSE : {
3527 if (wxdobj_control_pt_to_bb(&bbobj, m_pCurrent)) {
3528 if (
3529 wxdobj_flip_object(
3530 m_pCurrent, &bbobj, m_bVerticalFlip, false
3531 )
3532 ) {
3533 wxdobj_flip_object(
3534 m_pCurrent, &bbobj, m_bVerticalFlip, true
3535 );
3536 wxdobj_bb_modified_object(m_pDrw, m_pCurrent);
3537 SetModified();
3538 }
3539 }
3540 } break;
3541 case WXD_OT_CIRCLE :
3542 case WXD_OT_BOX :
3543 case WXD_OT_IMAGE :
3544 case WXD_OT_DOT_FILLED :
3545 case WXD_OT_DOT_WHITE : {
3546 /* Intentionally empty */
3547 } break;
3548 }
3549 m_pCurrent = NULL;
3550 SetMouseAndStatusTexts(m_iState);
3551 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
3552 }
3553 }
3554
3555 }
3556
3557
3558
3559 void
MouseMoveGroupOne(void)3560 WxdkdrawFrame::MouseMoveGroupOne(void)
3561 {
3562 Wxd_object_t *pOldCurrent;
3563
3564 if (m_bMousePos) {
3565 pOldCurrent = m_pCurrent;
3566 m_pCurrent = FindNearestObject(true);
3567 if (m_pCurrent != pOldCurrent) {
3568 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
3569 if (NULL != m_pCurrent) {
3570 wxdobj_mark_recursively(m_pCurrent, OBJ_MARKER_1);
3571 }
3572 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
3573 SetMouseAndStatusTexts(m_iState);
3574 }
3575 }
3576
3577 }
3578
3579
3580
3581 void
GroupNewForMarkedObjects(void)3582 WxdkdrawFrame::GroupNewForMarkedObjects(void)
3583 {
3584 dk4_er_t er;
3585 Wxd_object_t *pobj;
3586 Wxd_object_t *pngrp;
3587 int res;
3588 bool bFoundObject;
3589 bool bError;
3590
3591 pngrp = wxdobj_drw_add_group(m_pDrw, NULL);
3592 if (NULL != pngrp) {
3593 bError = false;
3594 do {
3595 bFoundObject = false;
3596 dk4sto_it_reset(m_pDrw->i_stru);
3597 do {
3598 pobj = (Wxd_object_t *)dk4sto_it_next(m_pDrw->i_stru);
3599 if (NULL != pobj) {
3600 if (wxdobj_is_marked(pobj, OBJ_MARKER_2)) {
3601 bFoundObject = true;
3602 dk4error_init(&er);
3603 res = dk4sto_add((pngrp->det).g.s_e, pobj, &er);
3604 if (0 != res) {
3605 dk4error_init(&er);
3606 res = dk4sto_remove(m_pDrw->s_stru, pobj, &er);
3607 if (0 != res) {
3608 pobj->pa = pngrp;
3609 }
3610 else {
3611 bError = true;
3612 (void)dk4sto_remove(
3613 (pngrp->det).g.s_e, pobj, NULL
3614 );
3615 /* ERROR: Failed to delete */
3616 dk4error_set_simple_error_code(
3617 &m_oErrorReport, WXD_E_MOVE_TO_GROUP
3618 );
3619 }
3620 }
3621 else {
3622 bError = true;
3623 /* ERROR: Failed to insert (memory) */
3624 dk4error_set_simple_error_code(
3625 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
3626 );
3627 }
3628 }
3629 }
3630 } while ((NULL != pobj) && (!(bFoundObject)) && (!(bError)));
3631 } while ((bFoundObject) && (!(bError)));
3632 wxdobj_bb_group_structural(m_pDrw, pngrp);
3633 }
3634 else {
3635 /* ERROR: Memory */
3636 dk4error_set_simple_error_code(
3637 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
3638 );
3639 }
3640 }
3641
3642
3643
3644 void
UngroupObjects(Wxd_object_t * pgrp)3645 WxdkdrawFrame::UngroupObjects(Wxd_object_t *pgrp)
3646 {
3647 Wxd_object_t *pobj; /* Current object */
3648 int res; /* Storage operation result */
3649 bool bFound; /* Found an object in current pass */
3650 bool bError; /* Error occured, stop */
3651
3652 bError = false;
3653 do {
3654 bFound = false;
3655 dk4sto_it_reset((pgrp->det).g.i_e);
3656 do {
3657 pobj = (Wxd_object_t *)dk4sto_it_next((pgrp->det).g.i_e);
3658 if (NULL != pobj) {
3659 bFound = true;
3660 res = dk4sto_add(m_pDrw->s_stru, pobj, NULL);
3661 if (0 != res) {
3662 res = dk4sto_remove((pgrp->det).g.s_e, pobj, NULL);
3663 if (0 != res) {
3664 dk4sto_it_reset((pgrp->det).g.i_e);
3665 pobj->pa = NULL;
3666 }
3667 else {
3668 (void)dk4sto_remove(m_pDrw->s_stru, pobj, NULL);
3669 dk4error_set_simple_error_code(
3670 &m_oErrorReport, WXD_E_UNGROUP_OBJECT
3671 );
3672 }
3673 }
3674 else {
3675 /* ERROR: Failed to add */
3676 dk4error_set_simple_error_code(
3677 &m_oErrorReport, WXD_E_UNGROUP_OBJECT
3678 );
3679 }
3680 }
3681 } while ((NULL != pobj) && (!(bFound)) && (!(bError)));
3682 } while (bFound && (!(bError)));
3683 if (!(bError)) {
3684 res = dk4sto_remove(m_pDrw->s_stru, pgrp, NULL);
3685 if (0 != res) {
3686 if (NULL != (pgrp->det).g.i_e) {
3687 dk4sto_it_close((pgrp->det).g.i_e);
3688 (pgrp->det).g.i_e = NULL;
3689 }
3690 if (NULL != (pgrp->det).g.s_e) {
3691 dk4sto_close((pgrp->det).g.s_e);
3692 (pgrp->det).g.s_e = NULL;
3693 }
3694 pgrp->pa = NULL;
3695 pgrp->psti = NULL;
3696 pgrp->play = NULL;
3697 dk4mem_free(pgrp);
3698 }
3699 else {
3700 /* ERROR: Failed to remove */
3701 dk4error_set_simple_error_code(
3702 &m_oErrorReport, WXD_E_UNGROUP_OBJECT
3703 );
3704 }
3705 }
3706
3707 }
3708
3709
3710
3711 void
MouseLeftGroupOne(void)3712 WxdkdrawFrame::MouseLeftGroupOne(void)
3713 {
3714
3715 if (m_bMousePos) {
3716 m_pCurrent = FindNearestObject(true);
3717 if (NULL != m_pCurrent) {
3718 if (wxdobj_is_marked(m_pCurrent, OBJ_MARKER_2)) {
3719 wxdobj_unmark_recursively(m_pCurrent, OBJ_MARKER_2);
3720 }
3721 else {
3722 wxdobj_mark_recursively(m_pCurrent, OBJ_MARKER_2);
3723 }
3724 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
3725 m_pCurrent = NULL;
3726 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
3727 SetMouseAndStatusTexts(m_iState);
3728 }
3729 else {
3730 if (2 <= wxdobj_num_marked_2(m_pDrw)) {
3731 GroupNewForMarkedObjects();
3732 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
3733 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_2);
3734 m_pCurrent = NULL;
3735 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
3736 SetMouseAndStatusTexts(m_iState);
3737 SetModified();
3738 }
3739 else {
3740 /* Intentionally empty, do not group a single element */
3741 }
3742 }
3743 }
3744
3745 }
3746
3747
3748
3749 void
MouseMoveUngroup(void)3750 WxdkdrawFrame::MouseMoveUngroup(void)
3751 {
3752 Wxd_object_t *pOldCurrent;
3753
3754 if (m_bMousePos) {
3755 pOldCurrent = m_pCurrent;
3756 m_pCurrent = FindNearestObject(true);
3757 if (NULL != m_pCurrent) {
3758 if (WXD_OT_GROUP_BEGIN != m_pCurrent->ot) {
3759 m_pCurrent = NULL;
3760 }
3761 }
3762 if (m_pCurrent != pOldCurrent) {
3763 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
3764 if (NULL != m_pCurrent) {
3765 wxdobj_mark_recursively(m_pCurrent, OBJ_MARKER_1);
3766 }
3767 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
3768 SetMouseAndStatusTexts(m_iState);
3769 }
3770 }
3771
3772 }
3773
3774
3775
3776 void
MouseLeftUngroup(void)3777 WxdkdrawFrame::MouseLeftUngroup(void)
3778 {
3779 Wxd_object_t *pobj;
3780
3781 if (m_bMousePos) {
3782 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
3783 m_pCurrent = NULL;
3784 pobj = FindNearestObject(true);
3785 if (NULL != pobj) {
3786 UngroupObjects(pobj);
3787 SetModified();
3788 }
3789 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
3790 SetMouseAndStatusTexts(m_iState);
3791 }
3792
3793 }
3794
3795
3796
3797
3798 void
MarkObjectsForRectangleGrouping(void)3799 WxdkdrawFrame::MarkObjectsForRectangleGrouping(void)
3800 {
3801 Wxd_bb_t ibb; /* Bounding box using int values */
3802 dk4_bb_t bbdbl; /* Bounding box using double values */
3803 Wxd_object_t *pobj; /* Current object to check */
3804
3805 /* Initialize ibb with mouse coordinates
3806 */
3807 ibb.xl = m_ptMouseMoveStart.x;
3808 ibb.xr = m_ptMousePosGrid.x;
3809 ibb.yb = m_ptMouseMoveStart.y;
3810 ibb.yt = m_ptMousePosGrid.y;
3811 wxdobj_bb_correct(&ibb);
3812 /*
3813 Unmark all objects
3814 */
3815 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
3816 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_2);
3817 /*
3818 Convert mouse coordinates to double coordinates
3819 */
3820 bbdbl.xmin = (double)(ibb.xl);
3821 bbdbl.xmax = (double)(ibb.xr);
3822 bbdbl.ymin = (double)(ibb.yb);
3823 bbdbl.ymax = (double)(ibb.yt);
3824 bbdbl.fl = ((unsigned char)3U);
3825 /*
3826 Check all objects in structural storage
3827 */
3828 dk4sto_it_reset(m_pDrw->i_stru);
3829 do {
3830 pobj = (Wxd_object_t *)dk4sto_it_next(m_pDrw->i_stru);
3831 if (NULL != pobj) {
3832 if (0 != dk4bb_contains_bb(&bbdbl, &(pobj->bb), 1)) {
3833 wxdobj_mark_recursively(pobj, OBJ_MARKER_2);
3834 }
3835 }
3836 } while (NULL != pobj);
3837 }
3838
3839
3840 void
MouseMoveGroupRect1(void)3841 WxdkdrawFrame::MouseMoveGroupRect1(void)
3842 {
3843
3844
3845 }
3846
3847
3848
3849 void
MouseLeftGroupRect1(void)3850 WxdkdrawFrame::MouseLeftGroupRect1(void)
3851 {
3852
3853 if (m_bMousePos) {
3854 DK4_MEMCPY(&m_ptMouseMoveStart,&m_ptMousePosGrid,sizeof(Wxd_point_t));
3855 m_iState = S_GROUP_RECT_2;
3856 SetMouseAndStatusTexts(m_iState);
3857 }
3858
3859 }
3860
3861
3862
3863 void
MouseMoveGroupRect2(void)3864 WxdkdrawFrame::MouseMoveGroupRect2(void)
3865 {
3866
3867 if (m_bMousePos) {
3868 MarkObjectsForRectangleGrouping();
3869 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
3870 }
3871
3872 }
3873
3874
3875
3876 void
MouseLeftGroupRect2(void)3877 WxdkdrawFrame::MouseLeftGroupRect2(void)
3878 {
3879
3880 if (m_bMousePos) {
3881 MarkObjectsForRectangleGrouping();
3882 if (2 <= wxdobj_num_marked_2(m_pDrw)) {
3883 GroupNewForMarkedObjects();
3884 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
3885 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_2);
3886 m_pCurrent = NULL;
3887 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
3888 m_iState = S_GROUP_RECT_1;
3889 SetMouseAndStatusTexts(m_iState);
3890 SetModified();
3891 }
3892 else {
3893 /* Intentionally empty, do not group a single element */
3894 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
3895
3896 }
3897 }
3898
3899 }
3900
3901
3902
3903 void
MouseMoveDetails(void)3904 WxdkdrawFrame::MouseMoveDetails(void)
3905 {
3906 Wxd_object_t *pOldCurrent;
3907
3908 if (m_bMousePos) {
3909 pOldCurrent = m_pCurrent;
3910 m_pCurrent = FindNearestObject();
3911 if (m_pCurrent != pOldCurrent) {
3912 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
3913 if (NULL != m_pCurrent) {
3914 m_pCurrent->mark |= OBJ_MARKER_1;
3915 }
3916 if (
3917 ((NULL != m_pCurrent) && (NULL == pOldCurrent))
3918 || ((NULL == m_pCurrent) && (NULL != pOldCurrent))
3919 ) {
3920 SetMouseAndStatusTexts(m_iState);
3921 }
3922 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
3923 }
3924 }
3925
3926 }
3927
3928
3929
3930 void
ChangeOneLabelText(wxChar ** ptxt,wxTextCtrl * ptc,bool bKeepOld)3931 WxdkdrawFrame::ChangeOneLabelText(
3932 wxChar **ptxt,
3933 wxTextCtrl *ptc,
3934 bool bKeepOld
3935 )
3936 {
3937 wxString str = ptc->GetValue();
3938 {
3939 wxCStrData strd = str.c_str();
3940 {
3941 wxChar const *pstr = (wxChar const *)strd;
3942 if (NULL != pstr) {
3943 if (0 < dk4strx_len(pstr)) {
3944 wxChar *pnstr = dk4strx_dup(pstr, NULL);
3945 if (NULL != pnstr) {
3946 if (NULL != *ptxt) {
3947 dk4mem_free(*ptxt);
3948 }
3949 *ptxt = pnstr;
3950 }
3951 else {
3952 /* ERROR: Memory */
3953 dk4error_set_simple_error_code(
3954 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
3955 );
3956 }
3957 }
3958 else {
3959 if (!(bKeepOld)) {
3960 if (NULL != *ptxt) {
3961 dk4mem_free(*ptxt);
3962 *ptxt = NULL;
3963 }
3964 }
3965 }
3966 }
3967 else {
3968 if (!(bKeepOld)) {
3969 if (NULL != *ptxt) {
3970 dk4mem_free(*ptxt);
3971 *ptxt = NULL;
3972 }
3973 }
3974 }
3975 }
3976 }
3977 }
3978
3979
3980
3981 void
RetrieveTextDetails(wxTextCtrl * ptce,wxTextCtrl * ptcs,bool bLaTeX)3982 WxdkdrawFrame::RetrieveTextDetails(
3983 wxTextCtrl *ptce,
3984 wxTextCtrl *ptcs,
3985 bool bLaTeX
3986 )
3987 {
3988 if (bLaTeX) {
3989 ChangeOneLabelText(&((m_pCurrent->det).t.t), ptce);
3990 ChangeOneLabelText(&((m_pCurrent->det).t.tsc), ptcs, false);
3991 }
3992 else {
3993 ChangeOneLabelText(&((m_pCurrent->det).t.t), ptce);
3994 if (NULL != (m_pCurrent->det).t.tsc) {
3995 dk4mem_free((m_pCurrent->det).t.tsc);
3996 (m_pCurrent->det).t.tsc = NULL;
3997 }
3998 }
3999 }
4000
4001
4002
4003 void
ModifyDetailsText(void)4004 WxdkdrawFrame::ModifyDetailsText(void)
4005 {
4006 bool bLaTeX = false;
4007
4008 bLaTeX = wxdobj_text_is_latex(m_pCurrent);
4009 WxdkdrawDlgTextInput tid(
4010 this, sTexts, sNlWx,
4011 &((m_pCurrent->det).t.t), &((m_pCurrent->det).t.tsc),
4012 bLaTeX, &m_oErrorReport
4013 );
4014 Dk4WxApplicationHelper::ChooseChildPosition(*drawco, tid);
4015 if (wxID_OK == tid.ShowModal()) {
4016 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
4017 SetModified();
4018 }
4019
4020 #if 0
4021 if (NULL != (m_pCurrent->det).t.t) {
4022 /*
4023 Export text available
4024 */
4025 wxString te((m_pCurrent->det).t.t);
4026 if (bLaTeX && (NULL != (m_pCurrent->det).t.tsc)) {
4027 /* Screen text available and in use
4028 */
4029 wxString ts((m_pCurrent->det).t.tsc);
4030 {
4031 WxdkdrawDlgTextInput tid(this, sTexts, sNlWx, bLaTeX);
4032 Dk4WxApplicationHelper::ChooseChildPosition(*drawco, tid);
4033 wxTextCtrl *ptce = tid.GetExportTextCtrl();
4034 wxTextCtrl *ptcs = tid.GetScreenTextCtrl();
4035 ptce->SetValue(te);
4036 ptcs->SetValue(ts);
4037 if (wxID_OK == tid.ShowModal()) {
4038 RetrieveTextDetails(ptce, ptcs, bLaTeX);
4039 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
4040 SetModified();
4041 }
4042 }
4043 }
4044 else {
4045 /* No screen text
4046 */
4047 WxdkdrawDlgTextInput tid(this, sTexts, sNlWx, bLaTeX);
4048 Dk4WxApplicationHelper::ChooseChildPosition(*drawco, tid);
4049 wxTextCtrl *ptce = tid.GetExportTextCtrl();
4050 wxTextCtrl *ptcs = tid.GetScreenTextCtrl();
4051 ptce->SetValue(te);
4052 if (wxID_OK == tid.ShowModal()) {
4053 RetrieveTextDetails(ptce, ptcs, bLaTeX);
4054 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
4055 SetModified();
4056 }
4057 }
4058 }
4059 else {
4060 /*
4061 No export text (yet)
4062 */
4063 WxdkdrawDlgTextInput tid(this, sTexts, sNlWx, bLaTeX);
4064 Dk4WxApplicationHelper::ChooseChildPosition(*drawco, tid);
4065 wxTextCtrl *ptce = tid.GetExportTextCtrl();
4066 wxTextCtrl *ptcs = tid.GetScreenTextCtrl();
4067 if (wxID_OK == tid.ShowModal()) {
4068 RetrieveTextDetails(ptce, ptcs, bLaTeX);
4069 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
4070 SetModified();
4071 }
4072 }
4073 #endif
4074
4075 }
4076
4077
4078
4079 /** Find the exponent of powers of 2 contained in a number.
4080 @param x Number to inspect.
4081 @return Exponent of powers of 2 contained in product on success, 0 on error.
4082 */
4083 static
4084 uint32_t
powers_of_two_in_product(uint32_t x)4085 powers_of_two_in_product(uint32_t x)
4086 {
4087 uint32_t back = (uint32_t)0UL;
4088
4089 while ((uint32_t)0UL == (x % ((uint32_t)2UL))) {
4090 back++;
4091 x = x / ((uint32_t)2UL);
4092 }
4093
4094 return back;
4095 }
4096
4097
4098
4099 /** Find a suitable scroll step to scroll through a given length.
4100 @param snap Grid distance, result should be a product or an
4101 1/x fraction of this.
4102 @param lgt Length to scroll through.
4103 @param mins Minimum number of scroll steps.
4104 @return Positive step width on success, 0 on error.
4105 */
4106 static
4107 uint32_t
step_length(uint32_t snap,uint32_t lgt,uint32_t mins)4108 step_length(uint32_t snap, uint32_t lgt, uint32_t mins)
4109 {
4110 dk4_er_t er;
4111 double d_l;
4112 double d_s;
4113 double d_m;
4114 double c;
4115 uint32_t back = (uint32_t)0UL;
4116 uint32_t maxe;
4117 uint32_t expo = (uint32_t)0UL;
4118
4119 #if 0
4120 /* 2020-03-24 Modification
4121 Turned to initialization due to complaints by clang static analyzer.
4122 */
4123 expo = (uint32_t)0UL;
4124 #endif
4125 d_l = (double)lgt;
4126 d_s = (double)snap;
4127 d_m = (double)mins;
4128 back = snap;
4129 if (snap > (lgt / mins)) {
4130 dk4error_init(&er);
4131 maxe = powers_of_two_in_product(snap);
4132
4133 c = ceil(0.0 - ((log(d_l/(d_s*d_m)))/ log(2.0)));
4134 if (0.0 < c) {
4135 expo = dk4ma_uint32_from_double(c, &er);
4136
4137 if (DK4_E_NONE == er.ec) {
4138 if ((uint32_t)0UL < expo) {
4139 if (expo > maxe) { expo = maxe; }
4140 while((int32_t)0L < expo--) {
4141 back = back / ((uint32_t)2UL);
4142 }
4143 }
4144 }
4145 }
4146 }
4147 return back;
4148 }
4149
4150
4151
4152
4153 void
ModifyDetailsBox(void)4154 WxdkdrawFrame::ModifyDetailsBox(void)
4155 {
4156 dk4_er_t er;
4157 size_t ui;
4158 uint32_t w;
4159 uint32_t h;
4160 uint32_t s;
4161 uint32_t m;
4162
4163 ui = ((0 != cbGridUnit->GetSelection()) ? (501) : (500));
4164 dk4error_init(&er);
4165 w = (uint32_t)dk4ma_int32_t_abs(
4166 dk4ma_int32_t_sub(
4167 (m_pCurrent->det).b.b.xr, (m_pCurrent->det).b.b.xl, &er
4168 ),
4169 &er
4170 );
4171 h = (uint32_t)dk4ma_int32_t_abs(
4172 dk4ma_int32_t_sub(
4173 (m_pCurrent->det).b.b.yt, (m_pCurrent->det).b.b.yb, &er
4174 ),
4175 &er
4176 );
4177 if (DK4_E_NONE == er.ec) {
4178 if (h < w) { w = h; }
4179 w = w / (uint32_t)2UL; /* Have half of minimum side length */
4180
4181 s = step_length(drawco->m_uGridSnap, w, (uint32_t)8UL);
4182
4183 if ((uint32_t)0UL < s) {
4184 m = (w / s);
4185 if (w == m * s) { m--; }
4186 if (((uint32_t)0UL) < m) {
4187 WxdkdrawDlgBoxRadius dlg(
4188 this, drawco, m_pDrw, m_pCurrent, sTexts, sNlWx,
4189 s, m, ui
4190 );
4191 m_iState = S_DETAILS_2;
4192 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
4193 if (wxID_OK == dlg.ShowModal()) {
4194 SetModified();
4195 }
4196 m_iState = S_DETAILS;
4197 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
4198 }
4199 else {
4200 /* ERROR: Box too small */
4201 dk4error_set_simple_error_code(
4202 &m_oErrorReport, WXD_E_BOX_TOO_SMALL
4203 );
4204 }
4205 }
4206 else {
4207 /* ERROR: Box too small */
4208 dk4error_set_simple_error_code(
4209 &m_oErrorReport, WXD_E_BOX_TOO_SMALL
4210 );
4211 }
4212 }
4213 else {
4214 /* ERROR: Overflow */
4215 dk4error_set_simple_error_code(
4216 &m_oErrorReport, WXD_E_OVERFLOW_COORDINATES
4217 );
4218 }
4219
4220 }
4221
4222
4223
4224 void
ChangeImageFile(wxString & pa)4225 WxdkdrawFrame::ChangeImageFile(wxString & pa)
4226 {
4227 wxChar const *vptr;
4228 wxChar *nptr;
4229 wxCStrData vstrdata = pa.c_str();
4230 vptr = (wxChar const *)vstrdata;
4231 if (NULL != vptr) {
4232 if (0 < dk4strx_len(vptr)) {
4233 nptr = dk4strx_dup(vptr, NULL);
4234 if (NULL != nptr) {
4235 if (NULL != (m_pCurrent->det).i.fn) {
4236 dk4mem_free((m_pCurrent->det).i.fn);
4237 }
4238 (m_pCurrent->det).i.fn = nptr;
4239 if (NULL != (m_pCurrent->det).i.bm) {
4240 delete((m_pCurrent->det).i.bm);
4241 (m_pCurrent->det).i.bm = NULL;
4242 }
4243 (m_pCurrent->det).i.t = wxBITMAP_TYPE_INVALID;
4244 wxdobj_load_image(
4245 m_pCurrent,
4246 pAppHelp->GetDkEncoding(), pAppHelp->GetWxEncoding()
4247 );
4248 SetModified();
4249 }
4250 else {
4251 /* ERROR: Memory */
4252 dk4error_set_simple_error_code(
4253 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
4254 );
4255 }
4256 }
4257 else {
4258 /* ERROR: Empty name */
4259 dk4error_set_simple_error_code(&m_oErrorReport, WXD_E_NO_FILENAME);
4260 }
4261 }
4262 }
4263
4264
4265
4266 static
4267 wxChar const *
final_path_component(wxChar const * fn)4268 final_path_component(wxChar const *fn)
4269 {
4270 wxChar const *back = NULL;
4271 wxChar const *rptr = NULL;
4272 wxChar const *ptr;
4273
4274 if (NULL != fn) {
4275 ptr = fn;
4276 while (wxT('\0') != *ptr) {
4277 #if DK4_HAVE_BACKSLASH_AS_SEP
4278 if (wxT('\\') == *ptr) {
4279 rptr = ptr;
4280 }
4281 #else
4282 if (wxT('/') == *ptr) {
4283 rptr = ptr;
4284 }
4285 #endif
4286 ptr++;
4287 }
4288 if (NULL != rptr) {
4289 back = ++rptr;
4290 }
4291 else {
4292 back = fn;
4293 }
4294 }
4295 return back;
4296 }
4297
4298
4299
4300 void
ModifyDetailsImage(void)4301 WxdkdrawFrame::ModifyDetailsImage(void)
4302 {
4303 wxString sDialogTitle(sTexts[409]);
4304 wxString sFileTypes(image_files_to_open);
4305 wxString sCurrentFileName(final_path_component((m_pCurrent->det).i.fn));
4306 #if wxCHECK_VERSION(2, 9, 0)
4307 wxFileDialog dlg(
4308 this, sDialogTitle, m_sImageDir, sCurrentFileName,
4309 sFileTypes, (wxFD_OPEN | wxFD_FILE_MUST_EXIST)
4310 );
4311 #else
4312 wxFileDialog dlg(
4313 this, sDialogTitle, m_sImageDir, sCurrentFileName,
4314 sFileTypes, wxOPEN
4315 );
4316 #endif
4317
4318 if(wxID_OK == dlg.ShowModal()) {
4319 wxString pa = dlg.GetPath();
4320 m_sImageDir = dlg.GetDirectory();
4321 ChangeImageFile(pa);
4322 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
4323 SetModified();
4324 }
4325 {
4326 WxdkdrawDlgImageOptions iodlg(this, m_pCurrent, sTexts);
4327 if (wxID_OK == iodlg.ShowModal()) {
4328 SetModified();
4329 }
4330 }
4331 m_bUpdate = true;
4332
4333 }
4334
4335
4336
4337 void
ModifyDetailsDotFilled(void)4338 WxdkdrawFrame::ModifyDetailsDotFilled(void)
4339 {
4340
4341 m_iState = S_DETAILS_2;
4342 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
4343 m_pCurrent->mark |= OBJ_MARKER_1;
4344 {
4345 WxdkdrawDlgDotFilled dlg(this, drawco, m_pDrw, m_pCurrent, sTexts);
4346 Dk4WxApplicationHelper::ChooseChildPosition(*drawco, dlg);
4347 if (wxID_OK == dlg.ShowModal()) {
4348 SetModified();
4349 }
4350 }
4351 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
4352 m_iState = S_DETAILS;
4353 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
4354
4355 }
4356
4357
4358
4359 void
ModifyDetailsDotWhite(void)4360 WxdkdrawFrame::ModifyDetailsDotWhite(void)
4361 {
4362
4363 ModifyDetailsDotFilled();
4364
4365 }
4366
4367
4368
4369 void
MouseLeftDetails(void)4370 WxdkdrawFrame::MouseLeftDetails(void)
4371 {
4372
4373 if (m_bMousePos) {
4374 m_pCurrent = FindNearestObject();
4375 if (NULL != m_pCurrent) {
4376 switch ( (int)(m_pCurrent->ot) ) {
4377 case WXD_OT_TEXT : {
4378 ModifyDetailsText();
4379 } break;
4380 case WXD_OT_BOX : {
4381 ModifyDetailsBox();
4382 } break;
4383 case WXD_OT_IMAGE : {
4384 ModifyDetailsImage();
4385 } break;
4386 case WXD_OT_DOT_FILLED : {
4387 ModifyDetailsDotFilled();
4388 } break;
4389 case WXD_OT_DOT_WHITE : {
4390 ModifyDetailsDotWhite();
4391 } break;
4392 }
4393 m_pCurrent = NULL;
4394 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
4395 SetMouseAndStatusTexts(m_iState);
4396 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
4397 }
4398 }
4399
4400 }
4401
4402
4403
4404 void
MouseMiddleDelete(void)4405 WxdkdrawFrame::MouseMiddleDelete(void)
4406 {
4407
4408 if (m_bMousePos) {
4409 DK4_MEMCPY(&m_ptMouseMoveStart,&m_ptMousePosGrid,sizeof(Wxd_point_t));
4410 m_iState = S_REGION_DELETE;
4411 SetMouseAndStatusTexts(m_iState);
4412 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
4413 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_2);
4414 }
4415
4416 }
4417
4418
4419
4420 void
MarkObjectsForRectangleDeletion(void)4421 WxdkdrawFrame::MarkObjectsForRectangleDeletion(void)
4422 {
4423 Wxd_bb_t ibb; /* Bounding box using int values */
4424 dk4_bb_t bbdbl; /* Bounding box using double values */
4425 Wxd_object_t *pobj; /* Current object to check */
4426
4427 /* Initialize ibb with mouse coordinates
4428 */
4429 ibb.xl = m_ptMouseMoveStart.x;
4430 ibb.xr = m_ptMousePosGrid.x;
4431 ibb.yb = m_ptMouseMoveStart.y;
4432 ibb.yt = m_ptMousePosGrid.y;
4433 wxdobj_bb_correct(&ibb);
4434 /*
4435 Unmark all objects
4436 */
4437 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
4438 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_2);
4439 /*
4440 Convert mouse coordinates to double coordinates
4441 */
4442 bbdbl.xmin = (double)(ibb.xl);
4443 bbdbl.xmax = (double)(ibb.xr);
4444 bbdbl.ymin = (double)(ibb.yb);
4445 bbdbl.ymax = (double)(ibb.yt);
4446 bbdbl.fl = ((unsigned char)3U);
4447 /*
4448 Check all objects in structural storage
4449 */
4450 dk4sto_it_reset(m_pDrw->i_stru);
4451 do {
4452 pobj = (Wxd_object_t *)dk4sto_it_next(m_pDrw->i_stru);
4453 if (NULL != pobj) {
4454 if (0 != dk4bb_contains_bb(&bbdbl, &(pobj->bb), 1)) {
4455 wxdobj_mark_recursively(pobj, OBJ_MARKER_1);
4456 }
4457 }
4458 } while (NULL != pobj);
4459 }
4460
4461
4462
4463 void
MouseMoveRegionDelete(void)4464 WxdkdrawFrame::MouseMoveRegionDelete(void)
4465 {
4466
4467 if (m_bMousePos) {
4468 MarkObjectsForRectangleDeletion();
4469 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
4470 }
4471
4472 }
4473
4474
4475
4476 void
MouseLeftRegionDelete(void)4477 WxdkdrawFrame::MouseLeftRegionDelete(void)
4478 {
4479 Wxd_object_t *pobj;
4480 bool bModified;
4481 bool bFoundChange;
4482
4483 if (m_bMousePos) {
4484 /*
4485 Find objects to delete
4486 */
4487 MarkObjectsForRectangleDeletion();
4488 /*
4489 Delete marked elements
4490 */
4491 bModified = false;
4492 do {
4493 bFoundChange = false;
4494 dk4sto_it_reset(m_pDrw->i_stru);
4495 do {
4496 pobj = (Wxd_object_t *)dk4sto_it_next(m_pDrw->i_stru);
4497 if (NULL != pobj) {
4498 if (wxdobj_is_marked(pobj, OBJ_MARKER_1)) {
4499 bModified = true;
4500 bFoundChange = true;
4501 wxdobj_obj_delete_from_drawing(m_pDrw, pobj);
4502 }
4503 }
4504 } while ((NULL != pobj) && (!(bFoundChange)));
4505 } while (bFoundChange);
4506 /*
4507 Go back to S_DELETE state
4508 */
4509 wxdobj_drw_require_redraw(
4510 m_pDrw,
4511 ((bModified) ? (WXD_REFRESH_DRAWING) : (WXD_REFRESH_MARKUP))
4512 );
4513 m_iState = S_DELETE;
4514 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
4515 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_2);
4516 m_pCurrent = NULL;
4517 SetMouseAndStatusTexts(m_iState);
4518 if (bModified) { SetModified(); }
4519 }
4520
4521 }
4522
4523
4524
4525 void
MouseMoveConvert(void)4526 WxdkdrawFrame::MouseMoveConvert(void)
4527 {
4528 Wxd_object_t *pOldCurrent;
4529
4530 if (m_bMousePos) {
4531 pOldCurrent = m_pCurrent;
4532 m_pCurrent = FindNearestObject();
4533 if (m_pCurrent != pOldCurrent) {
4534 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
4535 if (NULL != m_pCurrent) {
4536 m_pCurrent->mark |= OBJ_MARKER_1;
4537 }
4538 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
4539 SetMouseAndStatusTexts(m_iState);
4540 }
4541 }
4542
4543 }
4544
4545
4546
4547 void
ConvertSplineToPoly(Wxd_object_t * pobj)4548 WxdkdrawFrame::ConvertSplineToPoly(Wxd_object_t *pobj)
4549 {
4550 Wxd_det_t nd; /* New details */
4551
4552 if ((uint16_t)0U < (pobj->det).s.n) {
4553 if (NULL != (pobj->det).s.p) {
4554 DK4_MEMRES(&nd,sizeof(Wxd_det_t));
4555 nd.p.n = (pobj->det).s.n;
4556 nd.p.p = dk4mem_new(Wxd_point_t,(size_t)(nd.p.n),NULL);
4557 if (NULL != nd.p.p) {
4558 for (uint16_t i = 0; i < nd.p.n; i++) {
4559 (nd.p.p)[i].x = ((pobj->det).s.p)[i].x;
4560 (nd.p.p)[i].y = ((pobj->det).s.p)[i].y;
4561 }
4562 dk4mem_free((pobj->det).s.p);
4563 DK4_MEMCPY(&(pobj->det),&nd,sizeof(Wxd_det_t));
4564 pobj->ot = m_iObjToCreate;
4565 SetModified();
4566 }
4567 else {
4568 /* ERROR: Memory */
4569 dk4error_set_simple_error_code(
4570 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
4571 );
4572 }
4573 }
4574 }
4575
4576 }
4577
4578
4579
4580 void
ConvertArcToPoly(Wxd_object_t * pobj)4581 WxdkdrawFrame::ConvertArcToPoly(Wxd_object_t *pobj)
4582 {
4583 dk4_er_t er;
4584 Wxd_det_t nd; /* New details */
4585
4586 DK4_MEMRES(&nd,sizeof(Wxd_det_t));
4587
4588 if (
4589 (WXD_OT_POLYGON == m_iObjToCreate)
4590 && (WXD_OT_C_ARC == pobj->ot)
4591 && (0 != (pobj->det).a.d)
4592 ) {
4593
4594 nd.p.n = 4U;
4595 nd.p.p = dk4mem_new(Wxd_point_t,(size_t)4,NULL);
4596 if (NULL != nd.p.p) {
4597 dk4error_init(&er);
4598 (nd.p.p)[0].x = (pobj->det).a.x1;
4599 (nd.p.p)[0].y = (pobj->det).a.y1;
4600 (nd.p.p)[1].x = (pobj->det).a.x2;
4601 (nd.p.p)[1].y = (pobj->det).a.y2;
4602 (nd.p.p)[2].x = (pobj->det).a.x3;
4603 (nd.p.p)[2].y = (pobj->det).a.y3;
4604 (nd.p.p)[3].x = dk4ma_int32_from_double((pobj->det).a.x, &er);
4605 (nd.p.p)[3].y = dk4ma_int32_from_double((pobj->det).a.y, &er);
4606 if (DK4_E_NONE == er.ec) {
4607 DK4_MEMCPY(&(pobj->det),&nd,sizeof(Wxd_det_t));
4608 pobj->ot = m_iObjToCreate;
4609 SetModified();
4610 }
4611 else {
4612 dk4mem_free(nd.p.p);
4613 /* ERROR: Numeric overflow */
4614 dk4error_set_simple_error_code(
4615 &m_oErrorReport, WXD_E_OVERFLOW_COORDINATES
4616 );
4617 }
4618 }
4619 else {
4620 /* ERROR: Memory */
4621 dk4error_set_simple_error_code(
4622 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
4623 );
4624 }
4625 }
4626 else {
4627 nd.p.n = 3U;
4628 nd.p.p = dk4mem_new(Wxd_point_t,(size_t)3,NULL);
4629 if (NULL != nd.p.p) {
4630 (nd.p.p)[0].x = (pobj->det).a.x1;
4631 (nd.p.p)[0].y = (pobj->det).a.y1;
4632 (nd.p.p)[1].x = (pobj->det).a.x2;
4633 (nd.p.p)[1].y = (pobj->det).a.y2;
4634 (nd.p.p)[2].x = (pobj->det).a.x3;
4635 (nd.p.p)[2].y = (pobj->det).a.y3;
4636 DK4_MEMCPY(&(pobj->det),&nd,sizeof(Wxd_det_t));
4637 pobj->ot = m_iObjToCreate;
4638 SetModified();
4639 }
4640 else {
4641 /* ERROR: Memory */
4642 dk4error_set_simple_error_code(
4643 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
4644 );
4645 }
4646 }
4647
4648 }
4649
4650
4651
4652 void
ConvertBoxToPoly(Wxd_object_t * pobj)4653 WxdkdrawFrame::ConvertBoxToPoly(Wxd_object_t *pobj)
4654 {
4655
4656 Wxd_det_t nd; /* New details */
4657
4658 DK4_MEMRES(&nd,sizeof(Wxd_det_t));
4659 nd.p.n = 4;
4660 nd.p.p = dk4mem_new(Wxd_point_t,(size_t)4,NULL);
4661 if (NULL != nd.p.p) {
4662 (nd.p.p)[0].x = (pobj->det).b.b.xl;
4663 (nd.p.p)[0].y = (pobj->det).b.b.yb;
4664 (nd.p.p)[1].x = (pobj->det).b.b.xr;
4665 (nd.p.p)[1].y = (pobj->det).b.b.yb;
4666 (nd.p.p)[2].x = (pobj->det).b.b.xr;
4667 (nd.p.p)[2].y = (pobj->det).b.b.yt;
4668 (nd.p.p)[2].x = (pobj->det).b.b.xl;
4669 (nd.p.p)[2].y = (pobj->det).b.b.yt;
4670 DK4_MEMCPY(&(pobj->det),&nd,sizeof(Wxd_det_t));
4671 pobj->ot = m_iObjToCreate;
4672 SetModified();
4673 }
4674 else {
4675 /* ERROR: Memory */
4676 dk4error_set_simple_error_code(
4677 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
4678 );
4679 }
4680
4681 }
4682
4683
4684
4685 void
ConvertPolyToSpline(Wxd_object_t * pobj)4686 WxdkdrawFrame::ConvertPolyToSpline(Wxd_object_t *pobj)
4687 {
4688 Wxd_det_t nd; /* New details */
4689 double s; /* Spline value */
4690
4691 DK4_MEMRES(&nd,sizeof(Wxd_det_t));
4692 if (((uint16_t)0U < (pobj->det).p.n) && (NULL != (pobj->det).p.p)) {
4693 nd.s.n = (pobj->det).p.n;
4694 nd.s.p = dk4mem_new(Wxd_spline_point_t,(size_t)(nd.s.n),NULL);
4695 if (NULL != nd.s.p) {
4696 s = ((m_bSplineInterpolated) ? (-1.0) : (1.0));
4697 for (uint16_t i = (uint16_t)0U; i < nd.s.n; i++) {
4698 (nd.s.p)[i].x = ((pobj->det).p.p)[i].x;
4699 (nd.s.p)[i].y = ((pobj->det).p.p)[i].y;
4700 (nd.s.p)[i].s = s;
4701 }
4702 if (WXD_OT_O_SPLINE == m_iObjToCreate) {
4703 (nd.s.p)[0].s = 0.0;
4704 (nd.s.p)[(size_t)(nd.s.n - (uint16_t)1U)].s = 0.0;
4705 }
4706 DK4_MEMCPY(&(pobj->det),&nd,sizeof(Wxd_det_t));
4707 pobj->ot = m_iObjToCreate;
4708 SetModified();
4709 }
4710 else {
4711 /* ERROR: Memory */
4712 dk4error_set_simple_error_code(
4713 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
4714 );
4715 }
4716 }
4717 else {
4718 /* ERROR: Bad original object */
4719 dk4error_set_simple_error_code(
4720 &m_oErrorReport, WXD_E_CANNOT_CONVERT
4721 );
4722 }
4723
4724 }
4725
4726
4727
4728 void
ConvertSplineToSpline(Wxd_object_t * pobj)4729 WxdkdrawFrame::ConvertSplineToSpline(Wxd_object_t *pobj)
4730 {
4731 double s; /* Spline value */
4732
4733 if (((uint16_t)0U < (pobj->det).s.n) && (NULL != (pobj->det).s.p)) {
4734 s = ((m_bSplineInterpolated) ? (-1.0) : (1.0));
4735 for (uint16_t i = (uint16_t)0U; i < (pobj->det).s.n; i++) {
4736 ((pobj->det).s.p)[i].s = s;
4737 }
4738 if (WXD_OT_O_SPLINE == m_iObjToCreate) {
4739 ((pobj->det).s.p)[0].s = 0.0;
4740 ((pobj->det).s.p)[(size_t)((pobj->det).s.n - (uint16_t)1U)].s = 0.0;
4741 }
4742 pobj->ot = m_iObjToCreate;
4743 SetModified();
4744 }
4745 else {
4746 /* ERROR: Bad original object */
4747 dk4error_set_simple_error_code(
4748 &m_oErrorReport, WXD_E_CANNOT_CONVERT
4749 );
4750 }
4751
4752 }
4753
4754
4755
4756 void
ConvertArcToSpline(Wxd_object_t * pobj)4757 WxdkdrawFrame::ConvertArcToSpline(Wxd_object_t *pobj)
4758 {
4759 dk4_er_t er; /* For double to int32_t conversion */
4760 Wxd_det_t nd; /* New details */
4761 double s; /* Spline value */
4762
4763 DK4_MEMRES(&nd,sizeof(Wxd_det_t));
4764 s = ((m_bSplineInterpolated) ? (-1.0) : (1.0));
4765 if (
4766 (WXD_OT_C_SPLINE == m_iObjToCreate)
4767 && (WXD_OT_C_ARC == pobj->ot)
4768 && ((int8_t)0 != (pobj->det).a.d)
4769 ) {
4770 nd.s.n = 4U;
4771 nd.s.p = dk4mem_new(Wxd_spline_point_t,(size_t)4,NULL);
4772 if (NULL != nd.s.p) {
4773 dk4error_init(&er);
4774 (nd.s.p)[0].x = (pobj->det).a.x1;
4775 (nd.s.p)[0].y = (pobj->det).a.y1;
4776 (nd.s.p)[0].s = 0.0;
4777 (nd.s.p)[1].x = (pobj->det).a.x2;
4778 (nd.s.p)[1].y = (pobj->det).a.y2;
4779 (nd.s.p)[1].s = s;
4780 (nd.s.p)[2].x = (pobj->det).a.x3;
4781 (nd.s.p)[2].y = (pobj->det).a.y3;
4782 (nd.s.p)[2].s = 0.0;
4783 (nd.s.p)[3].x = dk4ma_int32_from_double((pobj->det).a.x, &er);
4784 (nd.s.p)[3].y = dk4ma_int32_from_double((pobj->det).a.y, &er);
4785 (nd.s.p)[3].s = 0.0;
4786 if (DK4_E_NONE == er.ec) {
4787 DK4_MEMCPY(&(pobj->det),&nd,sizeof(Wxd_det_t));
4788 pobj->ot = m_iObjToCreate;
4789 SetModified();
4790 }
4791 else {
4792 dk4mem_free(nd.s.p);
4793 /* ERROR: Numeric overflow */
4794 dk4error_set_simple_error_code(
4795 &m_oErrorReport, WXD_E_OVERFLOW_COORDINATES
4796 );
4797 }
4798 }
4799 else {
4800 /* ERROR: Memory */
4801 dk4error_set_simple_error_code(
4802 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
4803 );
4804 }
4805 }
4806 else {
4807 nd.s.n = 3U;
4808 nd.s.p = dk4mem_new(Wxd_spline_point_t,(size_t)3,NULL);
4809 if (NULL != nd.s.p) {
4810 (nd.s.p)[0].x = (pobj->det).a.x1;
4811 (nd.s.p)[0].y = (pobj->det).a.y1;
4812 (nd.s.p)[0].s = 0.0;
4813 (nd.s.p)[1].x = (pobj->det).a.x2;
4814 (nd.s.p)[1].y = (pobj->det).a.y2;
4815 (nd.s.p)[1].s = s;
4816 (nd.s.p)[2].x = (pobj->det).a.x3;
4817 (nd.s.p)[2].y = (pobj->det).a.y3;
4818 (nd.s.p)[2].s = 0.0;
4819 DK4_MEMCPY(&(pobj->det),&nd,sizeof(Wxd_det_t));
4820 pobj->ot = m_iObjToCreate;
4821 SetModified();
4822 }
4823 else {
4824 /* ERROR: Memory */
4825 dk4error_set_simple_error_code(
4826 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
4827 );
4828 }
4829 }
4830
4831 }
4832
4833
4834
4835 void
ConvertBoxToSpline(Wxd_object_t * pobj)4836 WxdkdrawFrame::ConvertBoxToSpline(Wxd_object_t *pobj)
4837 {
4838 dk4_er_t er; /* For double to int32_t conversion */
4839 Wxd_det_t nd; /* New details */
4840 double s; /* Spline value */
4841 int32_t w; /* Box width */
4842 int32_t h; /* Box height */
4843 int32_t r; /* Box radius */
4844 /* FALSE POSITIVE reported by some compilers:
4845 warning: 'r' may be used uninitialized in this function
4846 All conditions required to to set r in section (1)
4847 are also required when using r in section (2).
4848 */
4849
4850
4851 DK4_MEMRES(&nd,sizeof(Wxd_det_t));
4852 s = ((m_bSplineInterpolated) ? (-1.0) : (1.0));
4853 dk4error_init(&er);
4854 if (
4855 (WXD_OT_C_SPLINE == m_iObjToCreate)
4856 && (!(m_bSplineInterpolated))
4857 && ((uint32_t)0UL < (pobj->det).b.r)
4858 ) {
4859 /* (1) */
4860 w = dk4ma_int32_t_sub((pobj->det).b.b.xr, (pobj->det).b.b.xl, &er);
4861 w = dk4ma_int32_t_abs(w, &er);
4862 h = dk4ma_int32_t_sub((pobj->det).b.b.yt, (pobj->det).b.b.yb, &er);
4863 h = dk4ma_int32_t_abs(h, &er);
4864 if (w > h) w = h;
4865 r = w / (int32_t)2L;
4866 if ((uint32_t)r > (pobj->det).b.r) {
4867 r = (int32_t)((pobj->det).b.r);
4868 }
4869 }
4870 if (
4871 (WXD_OT_C_SPLINE == m_iObjToCreate)
4872 && (!(m_bSplineInterpolated))
4873 && ((uint32_t)0UL < (pobj->det).b.r)
4874 && (DK4_E_NONE == er.ec)
4875 ) {
4876 /* (2) */
4877 nd.s.n = 12;
4878 nd.s.p = dk4mem_new(Wxd_spline_point_t,(size_t)12,NULL);
4879 if (NULL != nd.s.p) {
4880 (nd.s.p)[0].x = (pobj->det).b.b.xl + r;
4881 (nd.s.p)[0].y = (pobj->det).b.b.yb;
4882 (nd.s.p)[0].s = 0.0;
4883 (nd.s.p)[1].x = (pobj->det).b.b.xr - r;
4884 (nd.s.p)[1].y = (pobj->det).b.b.yb;
4885 (nd.s.p)[1].s = 0.0;
4886 (nd.s.p)[2].x = (pobj->det).b.b.xr;
4887 (nd.s.p)[2].y = (pobj->det).b.b.yb;
4888 (nd.s.p)[2].s = 1.0;
4889 (nd.s.p)[3].x = (pobj->det).b.b.xr;
4890 (nd.s.p)[3].y = (pobj->det).b.b.yb + r;
4891 (nd.s.p)[3].s = 0.0;
4892 (nd.s.p)[4].x = (pobj->det).b.b.xr;
4893 (nd.s.p)[4].y = (pobj->det).b.b.yt - r;
4894 (nd.s.p)[4].s = 0.0;
4895 (nd.s.p)[5].x = (pobj->det).b.b.xr;
4896 (nd.s.p)[5].y = (pobj->det).b.b.yt;
4897 (nd.s.p)[5].s = 1.0;
4898 (nd.s.p)[6].x = (pobj->det).b.b.xr - r;
4899 (nd.s.p)[6].y = (pobj->det).b.b.yt;
4900 (nd.s.p)[6].s = 0.0;
4901 (nd.s.p)[7].x = (pobj->det).b.b.xl + r;
4902 (nd.s.p)[7].y = (pobj->det).b.b.yt;
4903 (nd.s.p)[7].s = 0.0;
4904 (nd.s.p)[8].x = (pobj->det).b.b.xl;
4905 (nd.s.p)[8].y = (pobj->det).b.b.yt;
4906 (nd.s.p)[8].s = 1.0;
4907 (nd.s.p)[9].x = (pobj->det).b.b.xl;
4908 (nd.s.p)[9].y = (pobj->det).b.b.yt - r;
4909 (nd.s.p)[9].s = 0.0;
4910 (nd.s.p)[10].x = (pobj->det).b.b.xl;
4911 (nd.s.p)[10].y = (pobj->det).b.b.yb + r;
4912 (nd.s.p)[10].s = 0.0;
4913 (nd.s.p)[11].x = (pobj->det).b.b.xl;
4914 (nd.s.p)[11].y = (pobj->det).b.b.yb;
4915 (nd.s.p)[11].s = 1.0;
4916 DK4_MEMCPY(&(pobj->det),&nd,sizeof(Wxd_det_t));
4917 pobj->ot = m_iObjToCreate;
4918 SetModified();
4919 }
4920 else {
4921 /* ERROR: Memory */
4922 dk4error_set_simple_error_code(
4923 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
4924 );
4925 }
4926 }
4927 else {
4928 nd.s.n = 4;
4929 nd.s.p = dk4mem_new(Wxd_spline_point_t,(size_t)4,NULL);
4930 if (NULL != nd.s.p) {
4931 (nd.s.p)[0].x = (pobj->det).b.b.xl;
4932 (nd.s.p)[0].y = (pobj->det).b.b.yb;
4933 (nd.s.p)[0].s = s;
4934 (nd.s.p)[1].x = (pobj->det).b.b.xr;
4935 (nd.s.p)[1].y = (pobj->det).b.b.yb;
4936 (nd.s.p)[1].s = s;
4937 (nd.s.p)[2].x = (pobj->det).b.b.xr;
4938 (nd.s.p)[2].y = (pobj->det).b.b.yt;
4939 (nd.s.p)[2].s = s;
4940 (nd.s.p)[3].x = (pobj->det).b.b.xl;
4941 (nd.s.p)[3].y = (pobj->det).b.b.yt;
4942 (nd.s.p)[3].s = s;
4943 DK4_MEMCPY(&(pobj->det),&nd,sizeof(Wxd_det_t));
4944 pobj->ot = m_iObjToCreate;
4945 if (WXD_OT_C_SPLINE != pobj->ot) {
4946 ((pobj->det).s.p)[0].s = 0.0;
4947 ((pobj->det).s.p)[(size_t)((pobj->det).s.n-(uint16_t)1U)].s=0.0;
4948 }
4949 SetModified();
4950 }
4951 else {
4952 /* ERROR: Memory */
4953 dk4error_set_simple_error_code(
4954 &m_oErrorReport, DK4_E_MEMORY_ALLOCATION_FAILED
4955 );
4956 }
4957 }
4958
4959 }
4960
4961
4962
4963 void
ConvertPolyToArc(Wxd_object_t * pobj)4964 WxdkdrawFrame::ConvertPolyToArc(Wxd_object_t *pobj)
4965 {
4966 Wxd_det_t nd;
4967
4968 DK4_MEMRES(&nd,sizeof(Wxd_det_t));
4969 if (((uint16_t)2U < (pobj->det).p.n) && (NULL != (pobj->det).p.p)) {
4970 nd.a.x1 = ((pobj->det).p.p)[0].x;
4971 nd.a.y1 = ((pobj->det).p.p)[0].y;
4972 nd.a.x2 = ((pobj->det).p.p)[1].x;
4973 nd.a.y2 = ((pobj->det).p.p)[1].y;
4974 nd.a.x3 = ((pobj->det).p.p)[2].x;
4975 nd.a.y3 = ((pobj->det).p.p)[2].y;
4976 wxdarc_calculation(
4977 &(nd.a.x), &(nd.a.y), &(nd.a.r), &(nd.a.a), &(nd.a.b), &(nd.a.d),
4978 nd.a.x1, nd.a.y1, nd.a.x2, nd.a.y2, nd.a.x3, nd.a.y3
4979 );
4980 dk4mem_free((pobj->det).p.p);
4981 DK4_MEMCPY(&(pobj->det),&nd,sizeof(Wxd_det_t));
4982 pobj->ot = m_iObjToCreate;
4983 SetModified();
4984 }
4985 else {
4986 /* ERROR: Bad original object */
4987 dk4error_set_simple_error_code(
4988 &m_oErrorReport, WXD_E_CANNOT_CONVERT
4989 );
4990 }
4991
4992 }
4993
4994
4995
4996 void
ConvertSplineToArc(Wxd_object_t * pobj)4997 WxdkdrawFrame::ConvertSplineToArc(Wxd_object_t *pobj)
4998 {
4999 Wxd_det_t nd;
5000
5001 DK4_MEMRES(&nd,sizeof(Wxd_det_t));
5002 if (((uint16_t)2U < (pobj->det).s.n) && (NULL != (pobj->det).s.p)) {
5003 nd.a.x1 = ((pobj->det).s.p)[0].x;
5004 nd.a.y1 = ((pobj->det).s.p)[0].y;
5005 nd.a.x2 = ((pobj->det).s.p)[1].x;
5006 nd.a.y2 = ((pobj->det).s.p)[1].y;
5007 nd.a.x3 = ((pobj->det).s.p)[2].x;
5008 nd.a.y3 = ((pobj->det).s.p)[2].y;
5009 wxdarc_calculation(
5010 &(nd.a.x), &(nd.a.y), &(nd.a.r), &(nd.a.a), &(nd.a.b), &(nd.a.d),
5011 nd.a.x1, nd.a.y1, nd.a.x2, nd.a.y2, nd.a.x3, nd.a.y3
5012 );
5013 dk4mem_free((pobj->det).s.p);
5014 DK4_MEMCPY(&(pobj->det),&nd,sizeof(Wxd_det_t));
5015 pobj->ot = m_iObjToCreate;
5016 SetModified();
5017 }
5018 else {
5019 /* ERROR: Bad original object */
5020 dk4error_set_simple_error_code(
5021 &m_oErrorReport, WXD_E_CANNOT_CONVERT
5022 );
5023 }
5024
5025 }
5026
5027
5028
5029 void
ConvertCircleToDot(Wxd_object_t * pobj)5030 WxdkdrawFrame::ConvertCircleToDot(Wxd_object_t *pobj)
5031 {
5032 dk4_er_t er;
5033 Wxd_det_t nd;
5034 uint16_t d; /* New diameter */
5035
5036 DK4_MEMRES(&nd,sizeof(Wxd_det_t));
5037 dk4error_init(&er);
5038 d = dk4ma_uint16_from(
5039 (dk4_um_t)dk4ma_uint32_t_div(
5040 dk4ma_uint32_t_mul((pobj->det).e.rx, (uint32_t)2UL, &er),
5041 m_pDrw->baselw, &er
5042 ),
5043 &er
5044 );
5045 if (DK4_E_NONE == er.ec) {
5046 nd.d.x = (pobj->det).e.x;
5047 nd.d.y = (pobj->det).e.y;
5048 nd.d.d = d;
5049 DK4_MEMCPY(&(pobj->det),&nd,sizeof(Wxd_det_t));
5050 pobj->ot = m_iObjToCreate;
5051 SetModified();
5052 }
5053 else {
5054 /* ERROR: Numeric overflow */
5055 dk4error_set_simple_error_code(
5056 &m_oErrorReport, WXD_E_OVERFLOW_COORDINATES
5057 );
5058 }
5059
5060 }
5061
5062
5063
5064 void
ObjectTypeConversion(Wxd_object_t * pobj)5065 WxdkdrawFrame::ObjectTypeConversion(Wxd_object_t *pobj)
5066 {
5067 if (NULL != pobj) {
5068 if (wxdobj_can_convert(m_iObjToCreate, pobj)) {
5069 switch ( (int)m_iObjToCreate ) {
5070 case WXD_OT_POLYLINE : case WXD_OT_POLYGON : {
5071 switch ( (int)(pobj->ot) ) {
5072 case WXD_OT_POLYLINE : case WXD_OT_POLYGON : {
5073 pobj->ot = m_iObjToCreate;
5074 } break;
5075 case WXD_OT_O_SPLINE : case WXD_OT_C_SPLINE : {
5076 ConvertSplineToPoly(pobj);
5077 } break;
5078 case WXD_OT_O_ARC : case WXD_OT_C_ARC : {
5079 ConvertArcToPoly(pobj);
5080 } break;
5081 case WXD_OT_BOX : {
5082 ConvertBoxToPoly(pobj);
5083 } break;
5084 }
5085 } break;
5086 case WXD_OT_O_SPLINE : case WXD_OT_C_SPLINE : {
5087 switch ( (int)(pobj->ot) ) {
5088 case WXD_OT_POLYLINE : case WXD_OT_POLYGON : {
5089 ConvertPolyToSpline(pobj);
5090 } break;
5091 case WXD_OT_O_SPLINE : case WXD_OT_C_SPLINE : {
5092 ConvertSplineToSpline(pobj);
5093 } break;
5094 case WXD_OT_O_ARC : case WXD_OT_C_ARC : {
5095 ConvertArcToSpline(pobj);
5096 } break;
5097 case WXD_OT_BOX : {
5098 ConvertBoxToSpline(pobj);
5099 } break;
5100 }
5101 } break;
5102 case WXD_OT_O_ARC : case WXD_OT_C_ARC : {
5103 switch ( (int)(pobj->ot) ) {
5104 case WXD_OT_C_ARC : case WXD_OT_O_ARC : {
5105 pobj->ot = m_iObjToCreate;
5106 } break;
5107 case WXD_OT_POLYLINE : case WXD_OT_POLYGON : {
5108 ConvertPolyToArc(pobj);
5109 } break;
5110 case WXD_OT_O_SPLINE : case WXD_OT_C_SPLINE : {
5111 ConvertSplineToArc(pobj);
5112 } break;
5113 }
5114 } break;
5115 case WXD_OT_DOT_FILLED : case WXD_OT_DOT_WHITE : {
5116 switch ( (int)(pobj->ot) ) {
5117 case WXD_OT_DOT_FILLED : case WXD_OT_DOT_WHITE : {
5118 pobj->ot = m_iObjToCreate;
5119 } break;
5120 case WXD_OT_CIRCLE : {
5121 ConvertCircleToDot(pobj);
5122 } break;
5123 }
5124 } break;
5125 }
5126 wxdobj_bb_simple_object(m_pDrw, pobj);
5127 }
5128 }
5129 }
5130
5131
5132
5133 void
MouseLeftConvert(void)5134 WxdkdrawFrame::MouseLeftConvert(void)
5135 {
5136
5137 if (m_bMousePos) {
5138 m_pCurrent = FindNearestObject();
5139 if (NULL != m_pCurrent) {
5140 ObjectTypeConversion(m_pCurrent);
5141 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
5142 m_pCurrent = NULL;
5143 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
5144 SetMouseAndStatusTexts(m_iState);
5145 }
5146 }
5147
5148 }
5149
5150
5151
5152 void
MouseMoveRotate(void)5153 WxdkdrawFrame::MouseMoveRotate(void)
5154 {
5155 Wxd_point_t center;
5156 Wxd_object_t *prevobj;
5157
5158 if (m_bMousePos) {
5159 prevobj = m_pCurrent;
5160 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
5161 m_pCurrent = wxdobj_rotate_find_object(
5162 m_pDrw, &m_ptMousePosRaw, &m_uCurrent,
5163 (2.0 * (double)(drawco->m_uGridSnap))
5164 );
5165 if (NULL != m_pCurrent) {
5166 if (wxdobj_get_control_point(¢er, m_pCurrent, m_uCurrent)) {
5167 while (NULL != m_pCurrent->pa) { m_pCurrent = m_pCurrent->pa; }
5168 if (
5169 wxdobj_rotate_object(
5170 m_pCurrent, center.x, center.y,
5171 m_bSplineInterpolated, false
5172 )
5173
5174 ) {
5175 wxdobj_mark_recursively(m_pCurrent, OBJ_MARKER_1);
5176 } else {
5177 m_pCurrent = NULL;
5178 }
5179 }
5180 else {
5181 m_pCurrent = NULL;
5182 }
5183 }
5184 else {
5185 }
5186 if (
5187 ((NULL != m_pCurrent) && (NULL == prevobj))
5188 || ((NULL == m_pCurrent) && (NULL != prevobj))
5189 ) {
5190 SetMouseAndStatusTexts(m_iState);
5191 }
5192 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
5193 }
5194
5195 }
5196
5197
5198
5199 void
MouseLeftRotate(void)5200 WxdkdrawFrame::MouseLeftRotate(void)
5201 {
5202 Wxd_point_t center;
5203
5204 if (m_bMousePos) {
5205 wxdobj_unmark_all(m_pDrw, OBJ_MARKER_1);
5206 m_pCurrent = wxdobj_rotate_find_object(
5207 m_pDrw, &m_ptMousePosRaw, &m_uCurrent,
5208 (2.0 * (double)(drawco->m_uGridSnap))
5209 );
5210 if (NULL != m_pCurrent) {
5211 if (wxdobj_get_control_point(¢er, m_pCurrent, m_uCurrent)) {
5212 while (NULL != m_pCurrent->pa) { m_pCurrent = m_pCurrent->pa; }
5213 if (
5214 wxdobj_rotate_object(
5215 m_pCurrent, center.x, center.y,
5216 m_bSplineInterpolated, false
5217 )
5218 ) {
5219 wxdobj_rotate_object(
5220 m_pCurrent, center.x, center.y,
5221 m_bSplineInterpolated, true
5222 );
5223 wxdobj_bb_modified_object(m_pDrw, m_pCurrent);
5224 SetModified();
5225 }
5226 else {
5227 m_pCurrent = NULL;
5228 }
5229 }
5230 else {
5231 m_pCurrent = NULL;
5232 }
5233 }
5234 SetMouseAndStatusTexts(m_iState);
5235 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_DRAWING);
5236 }
5237
5238 }
5239
5240
5241
5242 void
MouseMoveModspline(void)5243 WxdkdrawFrame::MouseMoveModspline(void)
5244 {
5245 Wxd_object_t *prevobj;
5246 uint16_t prevpoint;
5247
5248 if (m_bMousePos) {
5249 /*
5250 Save previous candidate object and point
5251 */
5252 prevobj = m_pCurrent;
5253 prevpoint = m_uCurrent;
5254 /*
5255 Check for new candicate
5256 */
5257 if (NULL != m_pCurrent) {
5258 m_pCurrent->mark = (uint8_t)(
5259 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
5260 );
5261 }
5262 m_pCurrent = wxdobj_modify_spline_find_object(
5263 m_pDrw, &m_ptMousePosRaw, &m_uCurrent,
5264 (2.0 * (double)(drawco->m_uGridSnap))
5265 );
5266 if (NULL != m_pCurrent) {
5267 m_pCurrent->mark |= OBJ_MARKER_1;
5268
5269 }
5270 /*
5271 On object or point change redraw the markup
5272 */
5273 if (
5274 ((NULL != m_pCurrent) && (NULL == prevobj))
5275 || ((NULL == m_pCurrent) && (NULL != prevobj))
5276 ) {
5277 SetMouseAndStatusTexts(m_iState);
5278 }
5279 if ((prevobj != m_pCurrent) || (prevpoint != m_uCurrent)) {
5280 wxdobj_drw_require_redraw(m_pDrw, WXD_REFRESH_MARKUP);
5281 }
5282 }
5283
5284 }
5285
5286
5287
5288 void
MouseLeftModspline(void)5289 WxdkdrawFrame::MouseLeftModspline(void)
5290 {
5291
5292 if (m_bMousePos) {
5293 if (NULL != m_pCurrent) {
5294 m_pCurrent->mark = (uint8_t)(
5295 (m_pCurrent->mark) & (~(OBJ_MARKER_1))
5296 );
5297 }
5298 m_pCurrent = wxdobj_modify_spline_find_object(
5299 m_pDrw, &m_ptMousePosRaw, &m_uCurrent,
5300 (2.0 * (double)(drawco->m_uGridSnap))
5301 );
5302 if (NULL != m_pCurrent) {
5303 ModifySplineValue(m_pCurrent, m_uCurrent);
5304 m_pCurrent = NULL;
5305 m_uCurrent = (uint16_t)0U;
5306 SetMouseAndStatusTexts(m_iState);
5307 }
5308 }
5309
5310 }
5311
5312
5313
5314 /* vim: set ai sw=4 ts=4 : */
5315
5316