]> git.saurik.com Git - wxWidgets.git/blame_incremental - contrib/src/ogl/lines.cpp
regenerated makefiles
[wxWidgets.git] / contrib / src / ogl / lines.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: lines.cpp
3// Purpose: wxLineShape
4// Author: Julian Smart
5// Modified by:
6// Created: 12/07/98
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12#ifdef __GNUG__
13#pragma implementation "lines.h"
14#pragma implementation "linesp.h"
15#endif
16
17// For compilers that support precompilation, includes "wx.h".
18#include "wx/wxprec.h"
19
20#ifdef __BORLANDC__
21#pragma hdrstop
22#endif
23
24#ifndef WX_PRECOMP
25#include <wx/wx.h>
26#endif
27
28#if wxUSE_PROLOGIO
29#include <wx/deprecated/wxexpr.h>
30#endif
31
32#ifdef new
33#undef new
34#endif
35
36#include <ctype.h>
37#include <math.h>
38
39#include "wx/ogl/ogl.h"
40
41
42// Line shape
43IMPLEMENT_DYNAMIC_CLASS(wxLineShape, wxShape)
44
45wxLineShape::wxLineShape()
46{
47 m_sensitivity = OP_CLICK_LEFT | OP_CLICK_RIGHT;
48 m_draggable = FALSE;
49 m_attachmentTo = 0;
50 m_attachmentFrom = 0;
51/*
52 m_actualTextWidth = 0.0;
53 m_actualTextHeight = 0.0;
54*/
55 m_from = NULL;
56 m_to = NULL;
57 m_erasing = FALSE;
58 m_arrowSpacing = 5.0; // For the moment, don't bother saving this to file.
59 m_ignoreArrowOffsets = FALSE;
60 m_isSpline = FALSE;
61 m_maintainStraightLines = FALSE;
62 m_alignmentStart = 0;
63 m_alignmentEnd = 0;
64
65 m_lineControlPoints = NULL;
66
67 // Clear any existing regions (created in an earlier constructor)
68 // and make the three line regions.
69 ClearRegions();
70 wxShapeRegion *newRegion = new wxShapeRegion;
71 newRegion->SetName(wxT("Middle"));
72 newRegion->SetSize(150, 50);
73 m_regions.Append((wxObject *)newRegion);
74
75 newRegion = new wxShapeRegion;
76 newRegion->SetName(wxT("Start"));
77 newRegion->SetSize(150, 50);
78 m_regions.Append((wxObject *)newRegion);
79
80 newRegion = new wxShapeRegion;
81 newRegion->SetName(wxT("End"));
82 newRegion->SetSize(150, 50);
83 m_regions.Append((wxObject *)newRegion);
84
85 for (int i = 0; i < 3; i++)
86 m_labelObjects[i] = NULL;
87}
88
89wxLineShape::~wxLineShape()
90{
91 if (m_lineControlPoints)
92 {
93 ClearPointList(*m_lineControlPoints);
94 delete m_lineControlPoints;
95 }
96 for (int i = 0; i < 3; i++)
97 {
98 if (m_labelObjects[i])
99 {
100 m_labelObjects[i]->Select(FALSE);
101 m_labelObjects[i]->RemoveFromCanvas(m_canvas);
102 delete m_labelObjects[i];
103 m_labelObjects[i] = NULL;
104 }
105 }
106 ClearArrowsAtPosition(-1);
107}
108
109void wxLineShape::MakeLineControlPoints(int n)
110{
111 if (m_lineControlPoints)
112 {
113 ClearPointList(*m_lineControlPoints);
114 delete m_lineControlPoints;
115 }
116 m_lineControlPoints = new wxList;
117
118 int i = 0;
119 for (i = 0; i < n; i++)
120 {
121 wxRealPoint *point = new wxRealPoint(-999, -999);
122 m_lineControlPoints->Append((wxObject*) point);
123 }
124}
125
126wxNode *wxLineShape::InsertLineControlPoint(wxDC* dc)
127{
128 if (dc)
129 Erase(*dc);
130
131 wxNode *last = m_lineControlPoints->GetLast();
132 wxNode *second_last = last->GetPrevious();
133 wxRealPoint *last_point = (wxRealPoint *)last->GetData();
134 wxRealPoint *second_last_point = (wxRealPoint *)second_last->GetData();
135
136 // Choose a point half way between the last and penultimate points
137 double line_x = ((last_point->x + second_last_point->x)/2);
138 double line_y = ((last_point->y + second_last_point->y)/2);
139
140 wxRealPoint *point = new wxRealPoint(line_x, line_y);
141 wxNode *node = m_lineControlPoints->Insert(last, (wxObject*) point);
142 return node;
143}
144
145bool wxLineShape::DeleteLineControlPoint()
146{
147 if (m_lineControlPoints->GetCount() < 3)
148 return FALSE;
149
150 wxNode *last = m_lineControlPoints->GetLast();
151 wxNode *second_last = last->GetPrevious();
152
153 wxRealPoint *second_last_point = (wxRealPoint *)second_last->GetData();
154 delete second_last_point;
155 delete second_last;
156
157 return TRUE;
158}
159
160void wxLineShape::Initialise()
161{
162 if (m_lineControlPoints)
163 {
164 // Just move the first and last control points
165 wxNode *first = m_lineControlPoints->GetFirst();
166 wxRealPoint *first_point = (wxRealPoint *)first->GetData();
167
168 wxNode *last = m_lineControlPoints->GetLast();
169 wxRealPoint *last_point = (wxRealPoint *)last->GetData();
170
171 // If any of the line points are at -999, we must
172 // initialize them by placing them half way between the first
173 // and the last.
174 wxNode *node = first->GetNext();
175 while (node)
176 {
177 wxRealPoint *point = (wxRealPoint *)node->GetData();
178 if (point->x == -999)
179 {
180 double x1, y1, x2, y2;
181 if (first_point->x < last_point->x)
182 { x1 = first_point->x; x2 = last_point->x; }
183 else
184 { x2 = first_point->x; x1 = last_point->x; }
185
186 if (first_point->y < last_point->y)
187 { y1 = first_point->y; y2 = last_point->y; }
188 else
189 { y2 = first_point->y; y1 = last_point->y; }
190
191 point->x = ((x2 - x1)/2 + x1);
192 point->y = ((y2 - y1)/2 + y1);
193 }
194 node = node->GetNext();
195 }
196 }
197}
198
199// Format a text string according to the region size, adding
200// strings with positions to region text list
201void wxLineShape::FormatText(wxDC& dc, const wxString& s, int i)
202{
203 double w, h;
204 ClearText(i);
205
206 if (m_regions.GetCount() < 1)
207 return;
208 wxNode *node = m_regions.Item(i);
209 if (!node)
210 return;
211
212 wxShapeRegion *region = (wxShapeRegion *)node->GetData();
213 region->SetText(s);
214 dc.SetFont(* region->GetFont());
215
216 region->GetSize(&w, &h);
217 // Initialize the size if zero
218 if (((w == 0) || (h == 0)) && (s.Length() > 0))
219 {
220 w = 100; h = 50;
221 region->SetSize(w, h);
222 }
223
224 wxStringList *string_list = oglFormatText(dc, s, (w-5), (h-5), region->GetFormatMode());
225 node = (wxNode*)string_list->GetFirst();
226 while (node)
227 {
228 wxChar *s = (wxChar *)node->GetData();
229 wxShapeTextLine *line = new wxShapeTextLine(0.0, 0.0, s);
230 region->GetFormattedText().Append((wxObject *)line);
231 node = node->GetNext();
232 }
233 delete string_list;
234 double actualW = w;
235 double actualH = h;
236 if (region->GetFormatMode() & FORMAT_SIZE_TO_CONTENTS)
237 {
238 oglGetCentredTextExtent(dc, &(region->GetFormattedText()), m_xpos, m_ypos, w, h, &actualW, &actualH);
239 if ((actualW != w ) || (actualH != h))
240 {
241 double xx, yy;
242 GetLabelPosition(i, &xx, &yy);
243 EraseRegion(dc, region, xx, yy);
244 if (m_labelObjects[i])
245 {
246 m_labelObjects[i]->Select(FALSE, &dc);
247 m_labelObjects[i]->Erase(dc);
248 m_labelObjects[i]->SetSize(actualW, actualH);
249 }
250
251 region->SetSize(actualW, actualH);
252
253 if (m_labelObjects[i])
254 {
255 m_labelObjects[i]->Select(TRUE, & dc);
256 m_labelObjects[i]->Draw(dc);
257 }
258 }
259 }
260 oglCentreText(dc, &(region->GetFormattedText()), m_xpos, m_ypos, actualW, actualH, region->GetFormatMode());
261 m_formatted = TRUE;
262}
263
264void wxLineShape::DrawRegion(wxDC& dc, wxShapeRegion *region, double x, double y)
265{
266 if (GetDisableLabel())
267 return;
268
269 double w, h;
270 double xx, yy;
271 region->GetSize(&w, &h);
272
273 // Get offset from x, y
274 region->GetPosition(&xx, &yy);
275
276 double xp = xx + x;
277 double yp = yy + y;
278
279 // First, clear a rectangle for the text IF there is any
280 if (region->GetFormattedText().GetCount() > 0)
281 {
282 dc.SetPen(GetBackgroundPen());
283 dc.SetBrush(GetBackgroundBrush());
284
285 // Now draw the text
286 if (region->GetFont()) dc.SetFont(* region->GetFont());
287
288 dc.DrawRectangle((long)(xp - w/2.0), (long)(yp - h/2.0), (long)w, (long)h);
289
290 if (m_pen) dc.SetPen(* m_pen);
291 dc.SetTextForeground(* region->GetActualColourObject());
292
293#ifdef __WXMSW__
294 dc.SetTextBackground(GetBackgroundBrush().GetColour());
295#endif
296
297 oglDrawFormattedText(dc, &(region->GetFormattedText()), xp, yp, w, h, region->GetFormatMode());
298 }
299}
300
301void wxLineShape::EraseRegion(wxDC& dc, wxShapeRegion *region, double x, double y)
302{
303 if (GetDisableLabel())
304 return;
305
306 double w, h;
307 double xx, yy;
308 region->GetSize(&w, &h);
309
310 // Get offset from x, y
311 region->GetPosition(&xx, &yy);
312
313 double xp = xx + x;
314 double yp = yy + y;
315
316 if (region->GetFormattedText().GetCount() > 0)
317 {
318 dc.SetPen(GetBackgroundPen());
319 dc.SetBrush(GetBackgroundBrush());
320
321 dc.DrawRectangle((long)(xp - w/2.0), (long)(yp - h/2.0), (long)w, (long)h);
322 }
323}
324
325// Get the reference point for a label. Region x and y
326// are offsets from this.
327// position is 0, 1, 2
328void wxLineShape::GetLabelPosition(int position, double *x, double *y)
329{
330 switch (position)
331 {
332 case 0:
333 {
334 // Want to take the middle section for the label
335 int n = m_lineControlPoints->GetCount();
336 int half_way = (int)(n/2);
337
338 // Find middle of this line
339 wxNode *node = m_lineControlPoints->Item(half_way - 1);
340 wxRealPoint *point = (wxRealPoint *)node->GetData();
341 wxNode *next_node = node->GetNext();
342 wxRealPoint *next_point = (wxRealPoint *)next_node->GetData();
343
344 double dx = (next_point->x - point->x);
345 double dy = (next_point->y - point->y);
346 *x = (double)(point->x + dx/2.0);
347 *y = (double)(point->y + dy/2.0);
348 break;
349 }
350 case 1:
351 {
352 wxNode *node = m_lineControlPoints->GetFirst();
353 *x = ((wxRealPoint *)node->GetData())->x;
354 *y = ((wxRealPoint *)node->GetData())->y;
355 break;
356 }
357 case 2:
358 {
359 wxNode *node = m_lineControlPoints->GetLast();
360 *x = ((wxRealPoint *)node->GetData())->x;
361 *y = ((wxRealPoint *)node->GetData())->y;
362 break;
363 }
364 default:
365 break;
366 }
367}
368
369/*
370 * Find whether line is supposed to be vertical or horizontal and
371 * make it so.
372 *
373 */
374void GraphicsStraightenLine(wxRealPoint *point1, wxRealPoint *point2)
375{
376 double dx = point2->x - point1->x;
377 double dy = point2->y - point1->y;
378
379 if (dx == 0.0)
380 return;
381 else if (fabs(dy/dx) > 1.0)
382 {
383 point2->x = point1->x;
384 }
385 else point2->y = point1->y;
386}
387
388void wxLineShape::Straighten(wxDC *dc)
389{
390 if (!m_lineControlPoints || m_lineControlPoints->GetCount() < 3)
391 return;
392
393 if (dc)
394 Erase(* dc);
395
396 wxNode *first_point_node = m_lineControlPoints->GetFirst();
397 wxNode *last_point_node = m_lineControlPoints->GetLast();
398 wxNode *second_last_point_node = last_point_node->GetPrevious();
399
400 wxRealPoint *last_point = (wxRealPoint *)last_point_node->GetData();
401 wxRealPoint *second_last_point = (wxRealPoint *)second_last_point_node->GetData();
402
403 GraphicsStraightenLine(last_point, second_last_point);
404
405 wxNode *node = first_point_node;
406 while (node && (node != second_last_point_node))
407 {
408 wxRealPoint *point = (wxRealPoint *)node->GetData();
409 wxRealPoint *next_point = (wxRealPoint *)(node->GetNext()->GetData());
410
411 GraphicsStraightenLine(point, next_point);
412 node = node->GetNext();
413 }
414
415 if (dc)
416 Draw(* dc);
417}
418
419
420void wxLineShape::Unlink()
421{
422 if (m_to)
423 m_to->GetLines().DeleteObject(this);
424 if (m_from)
425 m_from->GetLines().DeleteObject(this);
426 m_to = NULL;
427 m_from = NULL;
428}
429
430void wxLineShape::SetEnds(double x1, double y1, double x2, double y2)
431{
432 // Find centre point
433 wxNode *first_point_node = m_lineControlPoints->GetFirst();
434 wxNode *last_point_node = m_lineControlPoints->GetLast();
435 wxRealPoint *first_point = (wxRealPoint *)first_point_node->GetData();
436 wxRealPoint *last_point = (wxRealPoint *)last_point_node->GetData();
437
438 first_point->x = x1;
439 first_point->y = y1;
440 last_point->x = x2;
441 last_point->y = y2;
442
443 m_xpos = (double)((x1 + x2)/2.0);
444 m_ypos = (double)((y1 + y2)/2.0);
445}
446
447// Get absolute positions of ends
448void wxLineShape::GetEnds(double *x1, double *y1, double *x2, double *y2)
449{
450 wxNode *first_point_node = m_lineControlPoints->GetFirst();
451 wxNode *last_point_node = m_lineControlPoints->GetLast();
452 wxRealPoint *first_point = (wxRealPoint *)first_point_node->GetData();
453 wxRealPoint *last_point = (wxRealPoint *)last_point_node->GetData();
454
455 *x1 = first_point->x; *y1 = first_point->y;
456 *x2 = last_point->x; *y2 = last_point->y;
457}
458
459void wxLineShape::SetAttachments(int from_attach, int to_attach)
460{
461 m_attachmentFrom = from_attach;
462 m_attachmentTo = to_attach;
463}
464
465bool wxLineShape::HitTest(double x, double y, int *attachment, double *distance)
466{
467 if (!m_lineControlPoints)
468 return FALSE;
469
470 // Look at label regions in case mouse is over a label
471 bool inLabelRegion = FALSE;
472 for (int i = 0; i < 3; i ++)
473 {
474 wxNode *regionNode = m_regions.Item(i);
475 if (regionNode)
476 {
477 wxShapeRegion *region = (wxShapeRegion *)regionNode->GetData();
478 if (region->m_formattedText.GetCount() > 0)
479 {
480 double xp, yp, cx, cy, cw, ch;
481 GetLabelPosition(i, &xp, &yp);
482 // Offset region from default label position
483 region->GetPosition(&cx, &cy);
484 region->GetSize(&cw, &ch);
485 cx += xp;
486 cy += yp;
487 double rLeft = (double)(cx - (cw/2.0));
488 double rTop = (double)(cy - (ch/2.0));
489 double rRight = (double)(cx + (cw/2.0));
490 double rBottom = (double)(cy + (ch/2.0));
491 if (x > rLeft && x < rRight && y > rTop && y < rBottom)
492 {
493 inLabelRegion = TRUE;
494 i = 3;
495 }
496 }
497 }
498 }
499
500 wxNode *node = m_lineControlPoints->GetFirst();
501
502 while (node && node->GetNext())
503 {
504 wxRealPoint *point1 = (wxRealPoint *)node->GetData();
505 wxRealPoint *point2 = (wxRealPoint *)node->GetNext()->GetData();
506
507 // For inaccurate mousing allow 8 pixel corridor
508 int extra = 4;
509
510 double dx = point2->x - point1->x;
511 double dy = point2->y - point1->y;
512 double seg_len = sqrt(dx*dx+dy*dy);
513 double distance_from_seg =
514 seg_len*((x-point1->x)*dy-(y-point1->y)*dx)/(dy*dy+dx*dx);
515 double distance_from_prev =
516 seg_len*((y-point1->y)*dy+(x-point1->x)*dx)/(dy*dy+dx*dx);
517
518 if ((fabs(distance_from_seg) < extra &&
519 distance_from_prev >= 0 && distance_from_prev <= seg_len)
520 || inLabelRegion)
521 {
522 *attachment = 0;
523 *distance = distance_from_seg;
524 return TRUE;
525 }
526
527 node = node->GetNext();
528 }
529 return FALSE;
530}
531
532void wxLineShape::DrawArrows(wxDC& dc)
533{
534 // Distance along line of each arrow: space them out evenly.
535 double startArrowPos = 0.0;
536 double endArrowPos = 0.0;
537 double middleArrowPos = 0.0;
538
539 wxNode *node = m_arcArrows.GetFirst();
540 while (node)
541 {
542 wxArrowHead *arrow = (wxArrowHead *)node->GetData();
543 switch (arrow->GetArrowEnd())
544 {
545 case ARROW_POSITION_START:
546 {
547 if ((arrow->GetXOffset() != 0.0) && !m_ignoreArrowOffsets)
548 // If specified, x offset is proportional to line length
549 DrawArrow(dc, arrow, arrow->GetXOffset(), TRUE);
550 else
551 {
552 DrawArrow(dc, arrow, startArrowPos, FALSE); // Absolute distance
553 startArrowPos += arrow->GetSize() + arrow->GetSpacing();
554 }
555 break;
556 }
557 case ARROW_POSITION_END:
558 {
559 if ((arrow->GetXOffset() != 0.0) && !m_ignoreArrowOffsets)
560 DrawArrow(dc, arrow, arrow->GetXOffset(), TRUE);
561 else
562 {
563 DrawArrow(dc, arrow, endArrowPos, FALSE);
564 endArrowPos += arrow->GetSize() + arrow->GetSpacing();
565 }
566 break;
567 }
568 case ARROW_POSITION_MIDDLE:
569 {
570 arrow->SetXOffset(middleArrowPos);
571 if ((arrow->GetXOffset() != 0.0) && !m_ignoreArrowOffsets)
572 DrawArrow(dc, arrow, arrow->GetXOffset(), TRUE);
573 else
574 {
575 DrawArrow(dc, arrow, middleArrowPos, FALSE);
576 middleArrowPos += arrow->GetSize() + arrow->GetSpacing();
577 }
578 break;
579 }
580 }
581 node = node->GetNext();
582 }
583}
584
585void wxLineShape::DrawArrow(wxDC& dc, wxArrowHead *arrow, double xOffset, bool proportionalOffset)
586{
587 wxNode *first_line_node = m_lineControlPoints->GetFirst();
588 wxRealPoint *first_line_point = (wxRealPoint *)first_line_node->GetData();
589 wxNode *second_line_node = first_line_node->GetNext();
590 wxRealPoint *second_line_point = (wxRealPoint *)second_line_node->GetData();
591
592 wxNode *last_line_node = m_lineControlPoints->GetLast();
593 wxRealPoint *last_line_point = (wxRealPoint *)last_line_node->GetData();
594 wxNode *second_last_line_node = last_line_node->GetPrevious();
595 wxRealPoint *second_last_line_point = (wxRealPoint *)second_last_line_node->GetData();
596
597 // Position where we want to start drawing
598 double positionOnLineX, positionOnLineY;
599
600 // Position of start point of line, at the end of which we draw the arrow.
601 double startPositionX, startPositionY;
602
603 switch (arrow->GetPosition())
604 {
605 case ARROW_POSITION_START:
606 {
607 // If we're using a proportional offset, calculate just where this will
608 // be on the line.
609 double realOffset = xOffset;
610 if (proportionalOffset)
611 {
612 double totalLength =
613 (double)sqrt((second_line_point->x - first_line_point->x)*(second_line_point->x - first_line_point->x) +
614 (second_line_point->y - first_line_point->y)*(second_line_point->y - first_line_point->y));
615 realOffset = (double)(xOffset * totalLength);
616 }
617 GetPointOnLine(second_line_point->x, second_line_point->y,
618 first_line_point->x, first_line_point->y,
619 realOffset, &positionOnLineX, &positionOnLineY);
620 startPositionX = second_line_point->x;
621 startPositionY = second_line_point->y;
622 break;
623 }
624 case ARROW_POSITION_END:
625 {
626 // If we're using a proportional offset, calculate just where this will
627 // be on the line.
628 double realOffset = xOffset;
629 if (proportionalOffset)
630 {
631 double totalLength =
632 (double)sqrt((second_last_line_point->x - last_line_point->x)*(second_last_line_point->x - last_line_point->x) +
633 (second_last_line_point->y - last_line_point->y)*(second_last_line_point->y - last_line_point->y));
634 realOffset = (double)(xOffset * totalLength);
635 }
636 GetPointOnLine(second_last_line_point->x, second_last_line_point->y,
637 last_line_point->x, last_line_point->y,
638 realOffset, &positionOnLineX, &positionOnLineY);
639 startPositionX = second_last_line_point->x;
640 startPositionY = second_last_line_point->y;
641 break;
642 }
643 case ARROW_POSITION_MIDDLE:
644 {
645 // Choose a point half way between the last and penultimate points
646 double x = ((last_line_point->x + second_last_line_point->x)/2);
647 double y = ((last_line_point->y + second_last_line_point->y)/2);
648
649 // If we're using a proportional offset, calculate just where this will
650 // be on the line.
651 double realOffset = xOffset;
652 if (proportionalOffset)
653 {
654 double totalLength =
655 (double)sqrt((second_last_line_point->x - x)*(second_last_line_point->x - x) +
656 (second_last_line_point->y - y)*(second_last_line_point->y - y));
657 realOffset = (double)(xOffset * totalLength);
658 }
659
660 GetPointOnLine(second_last_line_point->x, second_last_line_point->y,
661 x, y, realOffset, &positionOnLineX, &positionOnLineY);
662 startPositionX = second_last_line_point->x;
663 startPositionY = second_last_line_point->y;
664 break;
665 }
666 }
667
668 /*
669 * Add yOffset to arrow, if any
670 */
671
672 const double myPi = (double) 3.14159265;
673 // The translation that the y offset may give
674 double deltaX = 0.0;
675 double deltaY = 0.0;
676 if ((arrow->GetYOffset() != 0.0) && !m_ignoreArrowOffsets)
677 {
678 /*
679 |(x4, y4)
680 |d
681 |
682 (x1, y1)--------------(x3, y3)------------------(x2, y2)
683 x4 = x3 - d * sin(theta)
684 y4 = y3 + d * cos(theta)
685
686 Where theta = tan(-1) of (y3-y1)/(x3-x1)
687 */
688 double x1 = startPositionX;
689 double y1 = startPositionY;
690 double x3 = positionOnLineX;
691 double y3 = positionOnLineY;
692 double d = -arrow->GetYOffset(); // Negate so +offset is above line
693
694 double theta = 0.0;
695 if (x3 == x1)
696 theta = (double)(myPi/2.0);
697 else
698 theta = (double)atan((y3-y1)/(x3-x1));
699
700 double x4 = (double)(x3 - (d*sin(theta)));
701 double y4 = (double)(y3 + (d*cos(theta)));
702
703 deltaX = x4 - positionOnLineX;
704 deltaY = y4 - positionOnLineY;
705 }
706
707 switch (arrow->_GetType())
708 {
709 case ARROW_ARROW:
710 {
711 double arrowLength = arrow->GetSize();
712 double arrowWidth = (double)(arrowLength/3.0);
713
714 double tip_x, tip_y, side1_x, side1_y, side2_x, side2_y;
715 oglGetArrowPoints(startPositionX+deltaX, startPositionY+deltaY,
716 positionOnLineX+deltaX, positionOnLineY+deltaY,
717 arrowLength, arrowWidth, &tip_x, &tip_y,
718 &side1_x, &side1_y, &side2_x, &side2_y);
719
720 wxPoint points[4];
721 points[0].x = (int) tip_x; points[0].y = (int) tip_y;
722 points[1].x = (int) side1_x; points[1].y = (int) side1_y;
723 points[2].x = (int) side2_x; points[2].y = (int) side2_y;
724 points[3].x = (int) tip_x; points[3].y = (int) tip_y;
725
726 dc.SetPen(* m_pen);
727 dc.SetBrush(* m_brush);
728 dc.DrawPolygon(4, points);
729 break;
730 }
731 case ARROW_HOLLOW_CIRCLE:
732 case ARROW_FILLED_CIRCLE:
733 {
734 // Find point on line of centre of circle, which is a radius away
735 // from the end position
736 double diameter = (double)(arrow->GetSize());
737 double x, y;
738 GetPointOnLine(startPositionX+deltaX, startPositionY+deltaY,
739 positionOnLineX+deltaX, positionOnLineY+deltaY,
740 (double)(diameter/2.0),
741 &x, &y);
742
743 // Convert ellipse centre to top-left coordinates
744 double x1 = (double)(x - (diameter/2.0));
745 double y1 = (double)(y - (diameter/2.0));
746
747 dc.SetPen(* m_pen);
748 if (arrow->_GetType() == ARROW_HOLLOW_CIRCLE)
749 dc.SetBrush(* g_oglWhiteBackgroundBrush);
750 else
751 dc.SetBrush(* m_brush);
752
753 dc.DrawEllipse((long) x1, (long) y1, (long) diameter, (long) diameter);
754 break;
755 }
756 case ARROW_SINGLE_OBLIQUE:
757 {
758 break;
759 }
760 case ARROW_METAFILE:
761 {
762 if (arrow->GetMetaFile())
763 {
764 // Find point on line of centre of object, which is a half-width away
765 // from the end position
766 /*
767 * width
768 * <-- start pos <-----><-- positionOnLineX
769 * _____
770 * --------------| x | <-- e.g. rectangular arrowhead
771 * -----
772 */
773 double x, y;
774 GetPointOnLine(startPositionX, startPositionY,
775 positionOnLineX, positionOnLineY,
776 (double)(arrow->GetMetaFile()->m_width/2.0),
777 &x, &y);
778
779 // Calculate theta for rotating the metafile.
780 /*
781 |
782 | o(x2, y2) 'o' represents the arrowhead.
783 | /
784 | /
785 | /theta
786 | /(x1, y1)
787 |______________________
788 */
789 double theta = 0.0;
790 double x1 = startPositionX;
791 double y1 = startPositionY;
792 double x2 = positionOnLineX;
793 double y2 = positionOnLineY;
794
795 if ((x1 == x2) && (y1 == y2))
796 theta = 0.0;
797
798 else if ((x1 == x2) && (y1 > y2))
799 theta = (double)(3.0*myPi/2.0);
800
801 else if ((x1 == x2) && (y2 > y1))
802 theta = (double)(myPi/2.0);
803
804 else if ((x2 > x1) && (y2 >= y1))
805 theta = (double)atan((y2 - y1)/(x2 - x1));
806
807 else if (x2 < x1)
808 theta = (double)(myPi + atan((y2 - y1)/(x2 - x1)));
809
810 else if ((x2 > x1) && (y2 < y1))
811 theta = (double)(2*myPi + atan((y2 - y1)/(x2 - x1)));
812
813 else
814 {
815 wxLogFatalError(wxT("Unknown arrowhead rotation case in lines.cc"));
816 }
817
818 // Rotate about the centre of the object, then place
819 // the object on the line.
820 if (arrow->GetMetaFile()->GetRotateable())
821 arrow->GetMetaFile()->Rotate(0.0, 0.0, theta);
822
823 if (m_erasing)
824 {
825 // If erasing, just draw a rectangle.
826 double minX, minY, maxX, maxY;
827 arrow->GetMetaFile()->GetBounds(&minX, &minY, &maxX, &maxY);
828 // Make erasing rectangle slightly bigger or you get droppings.
829 int extraPixels = 4;
830 dc.DrawRectangle((long)(deltaX + x + minX - (extraPixels/2.0)), (long)(deltaY + y + minY - (extraPixels/2.0)),
831 (long)(maxX - minX + extraPixels), (long)(maxY - minY + extraPixels));
832 }
833 else
834 arrow->GetMetaFile()->Draw(dc, x+deltaX, y+deltaY);
835 }
836 break;
837 }
838 default:
839 {
840 }
841 }
842}
843
844void wxLineShape::OnErase(wxDC& dc)
845{
846 wxPen *old_pen = m_pen;
847 wxBrush *old_brush = m_brush;
848 wxPen bg_pen = GetBackgroundPen();
849 wxBrush bg_brush = GetBackgroundBrush();
850 SetPen(&bg_pen);
851 SetBrush(&bg_brush);
852
853 double bound_x, bound_y;
854 GetBoundingBoxMax(&bound_x, &bound_y);
855 if (m_font) dc.SetFont(* m_font);
856
857 // Undraw text regions
858 for (int i = 0; i < 3; i++)
859 {
860 wxNode *node = m_regions.Item(i);
861 if (node)
862 {
863 double x, y;
864 wxShapeRegion *region = (wxShapeRegion *)node->GetData();
865 GetLabelPosition(i, &x, &y);
866 EraseRegion(dc, region, x, y);
867 }
868 }
869
870 // Undraw line
871 dc.SetPen(GetBackgroundPen());
872 dc.SetBrush(GetBackgroundBrush());
873
874 // Drawing over the line only seems to work if the line has a thickness
875 // of 1.
876 if (old_pen && (old_pen->GetWidth() > 1))
877 {
878 dc.DrawRectangle((long)(m_xpos - (bound_x/2.0) - 2.0), (long)(m_ypos - (bound_y/2.0) - 2.0),
879 (long)(bound_x+4.0), (long)(bound_y+4.0));
880 }
881 else
882 {
883 m_erasing = TRUE;
884 GetEventHandler()->OnDraw(dc);
885 GetEventHandler()->OnEraseControlPoints(dc);
886 m_erasing = FALSE;
887 }
888
889 if (old_pen) SetPen(old_pen);
890 if (old_brush) SetBrush(old_brush);
891}
892
893void wxLineShape::GetBoundingBoxMin(double *w, double *h)
894{
895 double x1 = 10000;
896 double y1 = 10000;
897 double x2 = -10000;
898 double y2 = -10000;
899
900 wxNode *node = m_lineControlPoints->GetFirst();
901 while (node)
902 {
903 wxRealPoint *point = (wxRealPoint *)node->GetData();
904
905 if (point->x < x1) x1 = point->x;
906 if (point->y < y1) y1 = point->y;
907 if (point->x > x2) x2 = point->x;
908 if (point->y > y2) y2 = point->y;
909
910 node = node->GetNext();
911 }
912 *w = (double)(x2 - x1);
913 *h = (double)(y2 - y1);
914}
915
916/*
917 * For a node image of interest, finds the position of this arc
918 * amongst all the arcs which are attached to THIS SIDE of the node image,
919 * and the number of same.
920 */
921void wxLineShape::FindNth(wxShape *image, int *nth, int *no_arcs, bool incoming)
922{
923 int n = -1;
924 int num = 0;
925 wxNode *node = image->GetLines().GetFirst();
926 int this_attachment;
927 if (image == m_to)
928 this_attachment = m_attachmentTo;
929 else
930 this_attachment = m_attachmentFrom;
931
932 // Find number of lines going into/out of this particular attachment point
933 while (node)
934 {
935 wxLineShape *line = (wxLineShape *)node->GetData();
936
937 if (line->m_from == image)
938 {
939 // This is the nth line attached to 'image'
940 if ((line == this) && !incoming)
941 n = num;
942
943 // Increment num count if this is the same side (attachment number)
944 if (line->m_attachmentFrom == this_attachment)
945 num ++;
946 }
947
948 if (line->m_to == image)
949 {
950 // This is the nth line attached to 'image'
951 if ((line == this) && incoming)
952 n = num;
953
954 // Increment num count if this is the same side (attachment number)
955 if (line->m_attachmentTo == this_attachment)
956 num ++;
957 }
958
959 node = node->GetNext();
960 }
961 *nth = n;
962 *no_arcs = num;
963}
964
965void wxLineShape::OnDrawOutline(wxDC& dc, double x, double y, double w, double h)
966{
967 wxPen *old_pen = m_pen;
968 wxBrush *old_brush = m_brush;
969
970 wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
971 SetPen(& dottedPen);
972 SetBrush( wxTRANSPARENT_BRUSH );
973
974 GetEventHandler()->OnDraw(dc);
975
976 if (old_pen) SetPen(old_pen);
977 else SetPen(NULL);
978 if (old_brush) SetBrush(old_brush);
979 else SetBrush(NULL);
980}
981
982bool wxLineShape::OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display)
983{
984 double x_offset = x - old_x;
985 double y_offset = y - old_y;
986
987 if (m_lineControlPoints && !(x_offset == 0.0 && y_offset == 0.0))
988 {
989 wxNode *node = m_lineControlPoints->GetFirst();
990 while (node)
991 {
992 wxRealPoint *point = (wxRealPoint *)node->GetData();
993 point->x += x_offset;
994 point->y += y_offset;
995 node = node->GetNext();
996 }
997
998 }
999
1000 // Move temporary label rectangles if necessary
1001 for (int i = 0; i < 3; i++)
1002 {
1003 if (m_labelObjects[i])
1004 {
1005 m_labelObjects[i]->Erase(dc);
1006 double xp, yp, xr, yr;
1007 GetLabelPosition(i, &xp, &yp);
1008 wxNode *node = m_regions.Item(i);
1009 if (node)
1010 {
1011 wxShapeRegion *region = (wxShapeRegion *)node->GetData();
1012 region->GetPosition(&xr, &yr);
1013 }
1014 else
1015 {
1016 xr = 0.0; yr = 0.0;
1017 }
1018
1019 m_labelObjects[i]->Move(dc, xp+xr, yp+yr);
1020 }
1021 }
1022 return TRUE;
1023}
1024
1025void wxLineShape::OnMoveLink(wxDC& dc, bool moveControlPoints)
1026{
1027 if (!m_from || !m_to)
1028 return;
1029
1030 if (m_lineControlPoints->GetCount() > 2)
1031 Initialise();
1032
1033 // Do each end - nothing in the middle. User has to move other points
1034 // manually if necessary.
1035 double end_x, end_y;
1036 double other_end_x, other_end_y;
1037
1038 FindLineEndPoints(&end_x, &end_y, &other_end_x, &other_end_y);
1039
1040 wxNode *first = m_lineControlPoints->GetFirst();
1041 wxRealPoint *first_point = (wxRealPoint *)first->GetData();
1042 wxNode *last = m_lineControlPoints->GetLast();
1043 wxRealPoint *last_point = (wxRealPoint *)last->GetData();
1044
1045/* This is redundant, surely? Done by SetEnds.
1046 first_point->x = end_x; first_point->y = end_y;
1047 last_point->x = other_end_x; last_point->y = other_end_y;
1048*/
1049
1050 double oldX = m_xpos;
1051 double oldY = m_ypos;
1052
1053 SetEnds(end_x, end_y, other_end_x, other_end_y);
1054
1055 // Do a second time, because one may depend on the other.
1056 FindLineEndPoints(&end_x, &end_y, &other_end_x, &other_end_y);
1057 SetEnds(end_x, end_y, other_end_x, other_end_y);
1058
1059 // Try to move control points with the arc
1060 double x_offset = m_xpos - oldX;
1061 double y_offset = m_ypos - oldY;
1062
1063// if (moveControlPoints && m_lineControlPoints && !(x_offset == 0.0 && y_offset == 0.0))
1064 // Only move control points if it's a self link. And only works if attachment mode is ON.
1065 if ((m_from == m_to) && (m_from->GetAttachmentMode() != ATTACHMENT_MODE_NONE) && moveControlPoints && m_lineControlPoints && !(x_offset == 0.0 && y_offset == 0.0))
1066 {
1067 wxNode *node = m_lineControlPoints->GetFirst();
1068 while (node)
1069 {
1070 if ((node != m_lineControlPoints->GetFirst()) && (node != m_lineControlPoints->GetLast()))
1071 {
1072 wxRealPoint *point = (wxRealPoint *)node->GetData();
1073 point->x += x_offset;
1074 point->y += y_offset;
1075 }
1076 node = node->GetNext();
1077 }
1078 }
1079
1080 Move(dc, m_xpos, m_ypos);
1081}
1082
1083// Finds the x, y points at the two ends of the line.
1084// This function can be used by e.g. line-routing routines to
1085// get the actual points on the two node images where the lines will be drawn
1086// to/from.
1087void wxLineShape::FindLineEndPoints(double *fromX, double *fromY, double *toX, double *toY)
1088{
1089 if (!m_from || !m_to)
1090 return;
1091
1092 // Do each end - nothing in the middle. User has to move other points
1093 // manually if necessary.
1094 double end_x, end_y;
1095 double other_end_x, other_end_y;
1096
1097 wxNode *first = m_lineControlPoints->GetFirst();
1098 wxRealPoint *first_point = (wxRealPoint *)first->GetData();
1099 wxNode *last = m_lineControlPoints->GetLast();
1100 wxRealPoint *last_point = (wxRealPoint *)last->GetData();
1101
1102 wxNode *second = first->GetNext();
1103 wxRealPoint *second_point = (wxRealPoint *)second->GetData();
1104
1105 wxNode *second_last = last->GetPrevious();
1106 wxRealPoint *second_last_point = (wxRealPoint *)second_last->GetData();
1107
1108 if (m_lineControlPoints->GetCount() > 2)
1109 {
1110 if (m_from->GetAttachmentMode() != ATTACHMENT_MODE_NONE)
1111 {
1112 int nth, no_arcs;
1113 FindNth(m_from, &nth, &no_arcs, FALSE); // Not incoming
1114 m_from->GetAttachmentPosition(m_attachmentFrom, &end_x, &end_y, nth, no_arcs, this);
1115 }
1116 else
1117 (void) m_from->GetPerimeterPoint(m_from->GetX(), m_from->GetY(),
1118 (double)second_point->x, (double)second_point->y,
1119 &end_x, &end_y);
1120
1121 if (m_to->GetAttachmentMode() != ATTACHMENT_MODE_NONE)
1122 {
1123 int nth, no_arcs;
1124 FindNth(m_to, &nth, &no_arcs, TRUE); // Incoming
1125 m_to->GetAttachmentPosition(m_attachmentTo, &other_end_x, &other_end_y, nth, no_arcs, this);
1126 }
1127 else
1128 (void) m_to->GetPerimeterPoint(m_to->GetX(), m_to->GetY(),
1129 (double)second_last_point->x, (double)second_last_point->y,
1130 &other_end_x, &other_end_y);
1131 }
1132 else
1133 {
1134 double fromX = m_from->GetX();
1135 double fromY = m_from->GetY();
1136 double toX = m_to->GetX();
1137 double toY = m_to->GetY();
1138
1139 if (m_from->GetAttachmentMode() != ATTACHMENT_MODE_NONE)
1140 {
1141 int nth, no_arcs;
1142 FindNth(m_from, &nth, &no_arcs, FALSE);
1143 m_from->GetAttachmentPosition(m_attachmentFrom, &end_x, &end_y, nth, no_arcs, this);
1144 fromX = end_x;
1145 fromY = end_y;
1146 }
1147
1148 if (m_to->GetAttachmentMode() != ATTACHMENT_MODE_NONE)
1149 {
1150 int nth, no_arcs;
1151 FindNth(m_to, &nth, &no_arcs, TRUE);
1152 m_to->GetAttachmentPosition(m_attachmentTo, &other_end_x, &other_end_y, nth, no_arcs, this);
1153 toX = other_end_x;
1154 toY = other_end_y;
1155 }
1156
1157 if (m_from->GetAttachmentMode() == ATTACHMENT_MODE_NONE)
1158 (void) m_from->GetPerimeterPoint(m_from->GetX(), m_from->GetY(),
1159 toX, toY,
1160 &end_x, &end_y);
1161
1162 if (m_to->GetAttachmentMode() == ATTACHMENT_MODE_NONE)
1163 (void) m_to->GetPerimeterPoint(m_to->GetX(), m_to->GetY(),
1164 fromX, fromY,
1165 &other_end_x, &other_end_y);
1166 }
1167 *fromX = end_x;
1168 *fromY = end_y;
1169 *toX = other_end_x;
1170 *toY = other_end_y;
1171}
1172
1173void wxLineShape::OnDraw(wxDC& dc)
1174{
1175 if (m_lineControlPoints)
1176 {
1177 if (m_pen)
1178 dc.SetPen(* m_pen);
1179 if (m_brush)
1180 dc.SetBrush(* m_brush);
1181
1182 int n = m_lineControlPoints->GetCount();
1183 wxPoint *points = new wxPoint[n];
1184 int i;
1185 for (i = 0; i < n; i++)
1186 {
1187 wxRealPoint* point = (wxRealPoint*) m_lineControlPoints->Item(i)->GetData();
1188 points[i].x = WXROUND(point->x);
1189 points[i].y = WXROUND(point->y);
1190 }
1191
1192 if (m_isSpline)
1193 dc.DrawSpline(n, points);
1194 else
1195 dc.DrawLines(n, points);
1196
1197#ifdef __WXMSW__
1198 // For some reason, last point isn't drawn under Windows.
1199 dc.DrawPoint(points[n-1]);
1200#endif
1201
1202 delete[] points;
1203
1204
1205 // Problem with pen - if not a solid pen, does strange things
1206 // to the arrowhead. So make (get) a new pen that's solid.
1207 if (m_pen && (m_pen->GetStyle() != wxSOLID))
1208 {
1209 wxPen *solid_pen =
1210 wxThePenList->FindOrCreatePen(m_pen->GetColour(), 1, wxSOLID);
1211 if (solid_pen)
1212 dc.SetPen(* solid_pen);
1213 }
1214 DrawArrows(dc);
1215 }
1216}
1217
1218void wxLineShape::OnDrawControlPoints(wxDC& dc)
1219{
1220 if (!m_drawHandles)
1221 return;
1222
1223 // Draw temporary label rectangles if necessary
1224 for (int i = 0; i < 3; i++)
1225 {
1226 if (m_labelObjects[i])
1227 m_labelObjects[i]->Draw(dc);
1228 }
1229 wxShape::OnDrawControlPoints(dc);
1230}
1231
1232void wxLineShape::OnEraseControlPoints(wxDC& dc)
1233{
1234 // Erase temporary label rectangles if necessary
1235 for (int i = 0; i < 3; i++)
1236 {
1237 if (m_labelObjects[i])
1238 m_labelObjects[i]->Erase(dc);
1239 }
1240 wxShape::OnEraseControlPoints(dc);
1241}
1242
1243void wxLineShape::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
1244{
1245}
1246
1247void wxLineShape::OnBeginDragLeft(double x, double y, int keys, int attachment)
1248{
1249}
1250
1251void wxLineShape::OnEndDragLeft(double x, double y, int keys, int attachment)
1252{
1253}
1254
1255/*
1256void wxLineShape::SetArrowSize(double length, double width)
1257{
1258 arrow_length = length;
1259 arrow_width = width;
1260}
1261
1262void wxLineShape::SetStartArrow(int style)
1263{
1264 start_style = style;
1265}
1266
1267void wxLineShape::SetMiddleArrow(int style)
1268{
1269 middle_style = style;
1270}
1271
1272void wxLineShape::SetEndArrow(int style)
1273{
1274 end_style = style;
1275}
1276*/
1277
1278void wxLineShape::OnDrawContents(wxDC& dc)
1279{
1280 if (GetDisableLabel())
1281 return;
1282
1283 for (int i = 0; i < 3; i++)
1284 {
1285 wxNode *node = m_regions.Item(i);
1286 if (node)
1287 {
1288 wxShapeRegion *region = (wxShapeRegion *)node->GetData();
1289 double x, y;
1290 GetLabelPosition(i, &x, &y);
1291 DrawRegion(dc, region, x, y);
1292 }
1293 }
1294}
1295
1296void wxLineShape::SetTo(wxShape *object)
1297{
1298 m_to = object;
1299}
1300
1301void wxLineShape::SetFrom(wxShape *object)
1302{
1303 m_from = object;
1304}
1305
1306void wxLineShape::MakeControlPoints()
1307{
1308 if (m_canvas && m_lineControlPoints)
1309 {
1310 wxNode *first = m_lineControlPoints->GetFirst();
1311 wxNode *last = m_lineControlPoints->GetLast();
1312 wxRealPoint *first_point = (wxRealPoint *)first->GetData();
1313 wxRealPoint *last_point = (wxRealPoint *)last->GetData();
1314
1315 wxLineControlPoint *control = new wxLineControlPoint(m_canvas, this, CONTROL_POINT_SIZE,
1316 first_point->x, first_point->y,
1317 CONTROL_POINT_ENDPOINT_FROM);
1318 control->m_point = first_point;
1319 m_canvas->AddShape(control);
1320 m_controlPoints.Append(control);
1321
1322
1323 wxNode *node = first->GetNext();
1324 while (node != last)
1325 {
1326 wxRealPoint *point = (wxRealPoint *)node->GetData();
1327
1328 control = new wxLineControlPoint(m_canvas, this, CONTROL_POINT_SIZE,
1329 point->x, point->y,
1330 CONTROL_POINT_LINE);
1331 control->m_point = point;
1332
1333 m_canvas->AddShape(control);
1334 m_controlPoints.Append(control);
1335
1336 node = node->GetNext();
1337 }
1338 control = new wxLineControlPoint(m_canvas, this, CONTROL_POINT_SIZE,
1339 last_point->x, last_point->y,
1340 CONTROL_POINT_ENDPOINT_TO);
1341 control->m_point = last_point;
1342 m_canvas->AddShape(control);
1343 m_controlPoints.Append(control);
1344
1345 }
1346
1347}
1348
1349void wxLineShape::ResetControlPoints()
1350{
1351 if (m_canvas && m_lineControlPoints && m_controlPoints.GetCount() > 0)
1352 {
1353 wxNode *node = m_controlPoints.GetFirst();
1354 wxNode *control_node = m_lineControlPoints->GetFirst();
1355 while (node && control_node)
1356 {
1357 wxRealPoint *point = (wxRealPoint *)control_node->GetData();
1358 wxLineControlPoint *control = (wxLineControlPoint *)node->GetData();
1359 control->SetX(point->x);
1360 control->SetY(point->y);
1361
1362 node = node->GetNext();
1363 control_node = control_node->GetNext();
1364 }
1365 }
1366}
1367
1368#if wxUSE_PROLOGIO
1369void wxLineShape::WriteAttributes(wxExpr *clause)
1370{
1371 wxShape::WriteAttributes(clause);
1372
1373 if (m_from)
1374 clause->AddAttributeValue("from", m_from->GetId());
1375 if (m_to)
1376 clause->AddAttributeValue("to", m_to->GetId());
1377
1378 if (m_attachmentTo != 0)
1379 clause->AddAttributeValue("attachment_to", (long)m_attachmentTo);
1380 if (m_attachmentFrom != 0)
1381 clause->AddAttributeValue("attachment_from", (long)m_attachmentFrom);
1382
1383 if (m_alignmentStart != 0)
1384 clause->AddAttributeValue("align_start", (long)m_alignmentStart);
1385 if (m_alignmentEnd != 0)
1386 clause->AddAttributeValue("align_end", (long)m_alignmentEnd);
1387
1388 clause->AddAttributeValue("is_spline", (long)m_isSpline);
1389 if (m_maintainStraightLines)
1390 clause->AddAttributeValue("keep_lines_straight", (long)m_maintainStraightLines);
1391
1392 // Make a list of lists for the (sp)line controls
1393 wxExpr *list = new wxExpr(wxExprList);
1394 wxNode *node = m_lineControlPoints->GetFirst();
1395 while (node)
1396 {
1397 wxRealPoint *point = (wxRealPoint *)node->GetData();
1398 wxExpr *point_list = new wxExpr(wxExprList);
1399 wxExpr *x_expr = new wxExpr((double) point->x);
1400 wxExpr *y_expr = new wxExpr((double) point->y);
1401 point_list->Append(x_expr);
1402 point_list->Append(y_expr);
1403 list->Append(point_list);
1404
1405 node = node->GetNext();
1406 }
1407 clause->AddAttributeValue("controls", list);
1408
1409 // Write arc arrows in new OGL format, if there are any.
1410 // This is a list of lists. Each sublist comprises:
1411 // (arrowType arrowEnd xOffset arrowSize)
1412 if (m_arcArrows.GetCount() > 0)
1413 {
1414 wxExpr *arrow_list = new wxExpr(wxExprList);
1415 node = m_arcArrows.GetFirst();
1416 while (node)
1417 {
1418 wxArrowHead *head = (wxArrowHead *)node->GetData();
1419 wxExpr *head_list = new wxExpr(wxExprList);
1420 head_list->Append(new wxExpr((long)head->_GetType()));
1421 head_list->Append(new wxExpr((long)head->GetArrowEnd()));
1422 head_list->Append(new wxExpr(head->GetXOffset()));
1423 head_list->Append(new wxExpr(head->GetArrowSize()));
1424 head_list->Append(new wxExpr(wxExprString, head->GetName()));
1425 head_list->Append(new wxExpr(head->GetId()));
1426
1427 // New members of wxArrowHead
1428 head_list->Append(new wxExpr(head->GetYOffset()));
1429 head_list->Append(new wxExpr(head->GetSpacing()));
1430
1431 arrow_list->Append(head_list);
1432
1433 node = node->GetNext();
1434 }
1435 clause->AddAttributeValue("arrows", arrow_list);
1436 }
1437}
1438
1439void wxLineShape::ReadAttributes(wxExpr *clause)
1440{
1441 wxShape::ReadAttributes(clause);
1442
1443 int iVal = (int) m_isSpline;
1444 clause->AssignAttributeValue(wxT("is_spline"), &iVal);
1445 m_isSpline = (iVal != 0);
1446
1447 iVal = (int) m_maintainStraightLines;
1448 clause->AssignAttributeValue(wxT("keep_lines_straight"), &iVal);
1449 m_maintainStraightLines = (iVal != 0);
1450
1451 clause->AssignAttributeValue(wxT("align_start"), &m_alignmentStart);
1452 clause->AssignAttributeValue(wxT("align_end"), &m_alignmentEnd);
1453
1454 // Compatibility: check for no regions.
1455 if (m_regions.GetCount() == 0)
1456 {
1457 wxShapeRegion *newRegion = new wxShapeRegion;
1458 newRegion->SetName("Middle");
1459 newRegion->SetSize(150, 50);
1460 m_regions.Append((wxObject *)newRegion);
1461 if (m_text.GetCount() > 0)
1462 {
1463 newRegion->ClearText();
1464 wxNode *node = m_text.GetFirst();
1465 while (node)
1466 {
1467 wxShapeTextLine *textLine = (wxShapeTextLine *)node->GetData();
1468 wxNode *next = node->GetNext();
1469 newRegion->GetFormattedText().Append((wxObject *)textLine);
1470 delete node;
1471 node = next;
1472 }
1473 }
1474
1475 newRegion = new wxShapeRegion;
1476 newRegion->SetName(wxT("Start"));
1477 newRegion->SetSize(150, 50);
1478 m_regions.Append((wxObject *)newRegion);
1479
1480 newRegion = new wxShapeRegion;
1481 newRegion->SetName(wxT("End"));
1482 newRegion->SetSize(150, 50);
1483 m_regions.Append((wxObject *)newRegion);
1484 }
1485
1486 m_attachmentTo = 0;
1487 m_attachmentFrom = 0;
1488
1489 clause->AssignAttributeValue(wxT("attachment_to"), &m_attachmentTo);
1490 clause->AssignAttributeValue(wxT("attachment_from"), &m_attachmentFrom);
1491
1492 wxExpr *line_list = NULL;
1493
1494 // When image is created, there are default control points. Override
1495 // them if there are some in the file.
1496 clause->AssignAttributeValue(wxT("controls"), &line_list);
1497
1498 if (line_list)
1499 {
1500 // Read a list of lists for the spline controls
1501 if (m_lineControlPoints)
1502 {
1503 ClearPointList(*m_lineControlPoints);
1504 }
1505 else
1506 m_lineControlPoints = new wxList;
1507
1508 wxExpr *node = line_list->value.first;
1509
1510 while (node)
1511 {
1512 wxExpr *xexpr = node->value.first;
1513 double x = xexpr->RealValue();
1514
1515 wxExpr *yexpr = xexpr->next;
1516 double y = yexpr->RealValue();
1517
1518 wxRealPoint *point = new wxRealPoint(x, y);
1519 m_lineControlPoints->Append((wxObject*) point);
1520
1521 node = node->next;
1522 }
1523 }
1524
1525 // Read arrow list, for new OGL code
1526 wxExpr *arrow_list = NULL;
1527
1528 clause->AssignAttributeValue(wxT("arrows"), &arrow_list);
1529 if (arrow_list)
1530 {
1531 wxExpr *node = arrow_list->value.first;
1532
1533 while (node)
1534 {
1535 WXTYPE arrowType = ARROW_ARROW;
1536 int arrowEnd = 0;
1537 double xOffset = 0.0;
1538 double arrowSize = 0.0;
1539 wxString arrowName;
1540 long arrowId = -1;
1541
1542 wxExpr *type_expr = node->Nth(0);
1543 wxExpr *end_expr = node->Nth(1);
1544 wxExpr *dist_expr = node->Nth(2);
1545 wxExpr *size_expr = node->Nth(3);
1546 wxExpr *name_expr = node->Nth(4);
1547 wxExpr *id_expr = node->Nth(5);
1548
1549 // New members of wxArrowHead
1550 wxExpr *yOffsetExpr = node->Nth(6);
1551 wxExpr *spacingExpr = node->Nth(7);
1552
1553 if (type_expr)
1554 arrowType = (int)type_expr->IntegerValue();
1555 if (end_expr)
1556 arrowEnd = (int)end_expr->IntegerValue();
1557 if (dist_expr)
1558 xOffset = dist_expr->RealValue();
1559 if (size_expr)
1560 arrowSize = size_expr->RealValue();
1561 if (name_expr)
1562 arrowName = name_expr->StringValue();
1563 if (id_expr)
1564 arrowId = id_expr->IntegerValue();
1565
1566 if (arrowId == -1)
1567 arrowId = wxNewId();
1568 else
1569 wxRegisterId(arrowId);
1570
1571 wxArrowHead *arrowHead = AddArrow(arrowType, arrowEnd, arrowSize, xOffset, arrowName, NULL, arrowId);
1572 if (yOffsetExpr)
1573 arrowHead->SetYOffset(yOffsetExpr->RealValue());
1574 if (spacingExpr)
1575 arrowHead->SetSpacing(spacingExpr->RealValue());
1576
1577 node = node->next;
1578 }
1579 }
1580}
1581#endif
1582
1583void wxLineShape::Copy(wxShape& copy)
1584{
1585 wxShape::Copy(copy);
1586
1587 wxASSERT( copy.IsKindOf(CLASSINFO(wxLineShape)) );
1588
1589 wxLineShape& lineCopy = (wxLineShape&) copy;
1590
1591 lineCopy.m_to = m_to;
1592 lineCopy.m_from = m_from;
1593 lineCopy.m_attachmentTo = m_attachmentTo;
1594 lineCopy.m_attachmentFrom = m_attachmentFrom;
1595 lineCopy.m_isSpline = m_isSpline;
1596 lineCopy.m_alignmentStart = m_alignmentStart;
1597 lineCopy.m_alignmentEnd = m_alignmentEnd;
1598 lineCopy.m_maintainStraightLines = m_maintainStraightLines;
1599 lineCopy.m_lineOrientations.Clear();
1600
1601 wxNode *node = m_lineOrientations.GetFirst();
1602 while (node)
1603 {
1604 lineCopy.m_lineOrientations.Append(node->GetData());
1605 node = node->GetNext();
1606 }
1607
1608 if (lineCopy.m_lineControlPoints)
1609 {
1610 ClearPointList(*lineCopy.m_lineControlPoints);
1611 delete lineCopy.m_lineControlPoints;
1612 }
1613
1614 lineCopy.m_lineControlPoints = new wxList;
1615
1616 node = m_lineControlPoints->GetFirst();
1617 while (node)
1618 {
1619 wxRealPoint *point = (wxRealPoint *)node->GetData();
1620 wxRealPoint *new_point = new wxRealPoint(point->x, point->y);
1621 lineCopy.m_lineControlPoints->Append((wxObject*) new_point);
1622 node = node->GetNext();
1623 }
1624
1625 // Copy arrows
1626 lineCopy.ClearArrowsAtPosition(-1);
1627 node = m_arcArrows.GetFirst();
1628 while (node)
1629 {
1630 wxArrowHead *arrow = (wxArrowHead *)node->GetData();
1631 lineCopy.m_arcArrows.Append(new wxArrowHead(*arrow));
1632 node = node->GetNext();
1633 }
1634}
1635
1636// Override select, to create/delete temporary label-moving objects
1637void wxLineShape::Select(bool select, wxDC* dc)
1638{
1639 wxShape::Select(select, dc);
1640 if (select)
1641 {
1642 for (int i = 0; i < 3; i++)
1643 {
1644 wxNode *node = m_regions.Item(i);
1645 if (node)
1646 {
1647 wxShapeRegion *region = (wxShapeRegion *)node->GetData();
1648 if (region->m_formattedText.GetCount() > 0)
1649 {
1650 double w, h, x, y, xx, yy;
1651 region->GetSize(&w, &h);
1652 region->GetPosition(&x, &y);
1653 GetLabelPosition(i, &xx, &yy);
1654 if (m_labelObjects[i])
1655 {
1656 m_labelObjects[i]->Select(FALSE);
1657 m_labelObjects[i]->RemoveFromCanvas(m_canvas);
1658 delete m_labelObjects[i];
1659 }
1660 m_labelObjects[i] = OnCreateLabelShape(this, region, w, h);
1661 m_labelObjects[i]->AddToCanvas(m_canvas);
1662 m_labelObjects[i]->Show(TRUE);
1663 if (dc)
1664 m_labelObjects[i]->Move(*dc, (double)(x + xx), (double)(y + yy));
1665 m_labelObjects[i]->Select(TRUE, dc);
1666 }
1667 }
1668 }
1669 }
1670 else
1671 {
1672 for (int i = 0; i < 3; i++)
1673 {
1674 if (m_labelObjects[i])
1675 {
1676 m_labelObjects[i]->Select(FALSE, dc);
1677 m_labelObjects[i]->Erase(*dc);
1678 m_labelObjects[i]->RemoveFromCanvas(m_canvas);
1679 delete m_labelObjects[i];
1680 m_labelObjects[i] = NULL;
1681 }
1682 }
1683 }
1684}
1685
1686/*
1687 * Line control point
1688 *
1689 */
1690
1691IMPLEMENT_DYNAMIC_CLASS(wxLineControlPoint, wxControlPoint)
1692
1693wxLineControlPoint::wxLineControlPoint(wxShapeCanvas *theCanvas, wxShape *object, double size, double x, double y, int the_type):
1694 wxControlPoint(theCanvas, object, size, x, y, the_type)
1695{
1696 m_xpos = x;
1697 m_ypos = y;
1698 m_type = the_type;
1699 m_point = NULL;
1700}
1701
1702wxLineControlPoint::~wxLineControlPoint()
1703{
1704}
1705
1706void wxLineControlPoint::OnDraw(wxDC& dc)
1707{
1708 wxRectangleShape::OnDraw(dc);
1709}
1710
1711// Implement movement of Line point
1712void wxLineControlPoint::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
1713{
1714 m_shape->GetEventHandler()->OnSizingDragLeft(this, draw, x, y, keys, attachment);
1715}
1716
1717void wxLineControlPoint::OnBeginDragLeft(double x, double y, int keys, int attachment)
1718{
1719 m_shape->GetEventHandler()->OnSizingBeginDragLeft(this, x, y, keys, attachment);
1720}
1721
1722void wxLineControlPoint::OnEndDragLeft(double x, double y, int keys, int attachment)
1723{
1724 m_shape->GetEventHandler()->OnSizingEndDragLeft(this, x, y, keys, attachment);
1725}
1726
1727// Control points ('handles') redirect control to the actual shape, to make it easier
1728// to override sizing behaviour.
1729void wxLineShape::OnSizingDragLeft(wxControlPoint* pt, bool draw, double x, double y, int keys, int attachment)
1730{
1731 wxLineControlPoint* lpt = (wxLineControlPoint*) pt;
1732
1733 wxClientDC dc(GetCanvas());
1734 GetCanvas()->PrepareDC(dc);
1735
1736 dc.SetLogicalFunction(OGLRBLF);
1737
1738 wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1739 dc.SetPen(dottedPen);
1740 dc.SetBrush((* wxTRANSPARENT_BRUSH));
1741
1742 if (lpt->m_type == CONTROL_POINT_LINE)
1743 {
1744 m_canvas->Snap(&x, &y);
1745
1746 lpt->SetX(x); lpt->SetY(y);
1747 lpt->m_point->x = x; lpt->m_point->y = y;
1748
1749 wxLineShape *lineShape = (wxLineShape *)this;
1750
1751 wxPen *old_pen = lineShape->GetPen();
1752 wxBrush *old_brush = lineShape->GetBrush();
1753
1754 wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1755 lineShape->SetPen(& dottedPen);
1756 lineShape->SetBrush(wxTRANSPARENT_BRUSH);
1757
1758 lineShape->GetEventHandler()->OnMoveLink(dc, FALSE);
1759
1760 lineShape->SetPen(old_pen);
1761 lineShape->SetBrush(old_brush);
1762 }
1763
1764 if (lpt->m_type == CONTROL_POINT_ENDPOINT_FROM || lpt->m_type == CONTROL_POINT_ENDPOINT_TO)
1765 {
1766// lpt->SetX(x); lpt->SetY(y);
1767 }
1768
1769}
1770
1771void wxLineShape::OnSizingBeginDragLeft(wxControlPoint* pt, double x, double y, int keys, int attachment)
1772{
1773 wxLineControlPoint* lpt = (wxLineControlPoint*) pt;
1774
1775 wxClientDC dc(GetCanvas());
1776 GetCanvas()->PrepareDC(dc);
1777
1778 wxLineShape *lineShape = (wxLineShape *)this;
1779 if (lpt->m_type == CONTROL_POINT_LINE)
1780 {
1781 lpt->m_originalPos = * (lpt->m_point);
1782 m_canvas->Snap(&x, &y);
1783
1784 this->Erase(dc);
1785
1786 // Redraw start and end objects because we've left holes
1787 // when erasing the line
1788 lineShape->GetFrom()->OnDraw(dc);
1789 lineShape->GetFrom()->OnDrawContents(dc);
1790 lineShape->GetTo()->OnDraw(dc);
1791 lineShape->GetTo()->OnDrawContents(dc);
1792
1793 this->SetDisableLabel(TRUE);
1794 dc.SetLogicalFunction(OGLRBLF);
1795
1796 lpt->m_xpos = x; lpt->m_ypos = y;
1797 lpt->m_point->x = x; lpt->m_point->y = y;
1798
1799 wxPen *old_pen = lineShape->GetPen();
1800 wxBrush *old_brush = lineShape->GetBrush();
1801
1802 wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1803 lineShape->SetPen(& dottedPen);
1804 lineShape->SetBrush(wxTRANSPARENT_BRUSH);
1805
1806 lineShape->GetEventHandler()->OnMoveLink(dc, FALSE);
1807
1808 lineShape->SetPen(old_pen);
1809 lineShape->SetBrush(old_brush);
1810 }
1811
1812 if (lpt->m_type == CONTROL_POINT_ENDPOINT_FROM || lpt->m_type == CONTROL_POINT_ENDPOINT_TO)
1813 {
1814 m_canvas->SetCursor(wxCursor(wxCURSOR_BULLSEYE));
1815 lpt->m_oldCursor = wxSTANDARD_CURSOR;
1816 }
1817}
1818
1819void wxLineShape::OnSizingEndDragLeft(wxControlPoint* pt, double x, double y, int keys, int attachment)
1820{
1821 wxLineControlPoint* lpt = (wxLineControlPoint*) pt;
1822
1823 wxClientDC dc(GetCanvas());
1824 GetCanvas()->PrepareDC(dc);
1825
1826 this->SetDisableLabel(FALSE);
1827 wxLineShape *lineShape = (wxLineShape *)this;
1828
1829 if (lpt->m_type == CONTROL_POINT_LINE)
1830 {
1831 m_canvas->Snap(&x, &y);
1832
1833 wxRealPoint pt = wxRealPoint(x, y);
1834
1835 // Move the control point back to where it was;
1836 // MoveControlPoint will move it to the new position
1837 // if it decides it wants. We only moved the position
1838 // during user feedback so we could redraw the line
1839 // as it changed shape.
1840 lpt->m_xpos = lpt->m_originalPos.x; lpt->m_ypos = lpt->m_originalPos.y;
1841 lpt->m_point->x = lpt->m_originalPos.x; lpt->m_point->y = lpt->m_originalPos.y;
1842
1843 OnMoveMiddleControlPoint(dc, lpt, pt);
1844 }
1845 if (lpt->m_type == CONTROL_POINT_ENDPOINT_FROM)
1846 {
1847 if (lpt->m_oldCursor)
1848 m_canvas->SetCursor(* lpt->m_oldCursor);
1849
1850// this->Erase(dc);
1851
1852// lpt->m_xpos = x; lpt->m_ypos = y;
1853
1854 if (lineShape->GetFrom())
1855 {
1856 lineShape->GetFrom()->MoveLineToNewAttachment(dc, lineShape, x, y);
1857 }
1858 }
1859 if (lpt->m_type == CONTROL_POINT_ENDPOINT_TO)
1860 {
1861 if (lpt->m_oldCursor)
1862 m_canvas->SetCursor(* lpt->m_oldCursor);
1863
1864// lpt->m_xpos = x; lpt->m_ypos = y;
1865
1866 if (lineShape->GetTo())
1867 {
1868 lineShape->GetTo()->MoveLineToNewAttachment(dc, lineShape, x, y);
1869 }
1870 }
1871
1872 // Needed?
1873#if 0
1874 int i = 0;
1875 for (i = 0; i < lineShape->GetLineControlPoints()->GetCount(); i++)
1876 if (((wxRealPoint *)(lineShape->GetLineControlPoints()->Item(i)->GetData())) == lpt->m_point)
1877 break;
1878
1879 // N.B. in OnMoveControlPoint, an event handler in Hardy could have deselected
1880 // the line and therefore deleted 'this'. -> GPF, intermittently.
1881 // So assume at this point that we've been blown away.
1882
1883 lineShape->OnMoveControlPoint(i+1, x, y);
1884#endif
1885}
1886
1887// This is called only when a non-end control point is moved.
1888bool wxLineShape::OnMoveMiddleControlPoint(wxDC& dc, wxLineControlPoint* lpt, const wxRealPoint& pt)
1889{
1890 lpt->m_xpos = pt.x; lpt->m_ypos = pt.y;
1891 lpt->m_point->x = pt.x; lpt->m_point->y = pt.y;
1892
1893 GetEventHandler()->OnMoveLink(dc);
1894
1895 return TRUE;
1896}
1897
1898// Implement movement of endpoint to a new attachment
1899// OBSOLETE: done by dragging with the left button.
1900
1901#if 0
1902void wxLineControlPoint::OnDragRight(bool draw, double x, double y, int keys, int attachment)
1903{
1904 if (m_type == CONTROL_POINT_ENDPOINT_FROM || m_type == CONTROL_POINT_ENDPOINT_TO)
1905 {
1906 m_xpos = x; m_ypos = y;
1907 }
1908}
1909
1910void wxLineControlPoint::OnBeginDragRight(double x, double y, int keys, int attachment)
1911{
1912 wxClientDC dc(GetCanvas());
1913 GetCanvas()->PrepareDC(dc);
1914
1915 wxLineShape *lineShape = (wxLineShape *)m_shape;
1916 if (m_type == CONTROL_POINT_ENDPOINT_FROM || m_type == CONTROL_POINT_ENDPOINT_TO)
1917 {
1918 Erase(dc);
1919 lineShape->GetEventHandler()->OnDraw(dc);
1920 if (m_type == CONTROL_POINT_ENDPOINT_FROM)
1921 {
1922 lineShape->GetFrom()->GetEventHandler()->OnDraw(dc);
1923 lineShape->GetFrom()->GetEventHandler()->OnDrawContents(dc);
1924 }
1925 else
1926 {
1927 lineShape->GetTo()->GetEventHandler()->OnDraw(dc);
1928 lineShape->GetTo()->GetEventHandler()->OnDrawContents(dc);
1929 }
1930 m_canvas->SetCursor(wxCursor(wxCURSOR_BULLSEYE));
1931 m_oldCursor = wxSTANDARD_CURSOR;
1932 }
1933}
1934
1935void wxLineControlPoint::OnEndDragRight(double x, double y, int keys, int attachment)
1936{
1937 wxClientDC dc(GetCanvas());
1938 GetCanvas()->PrepareDC(dc);
1939
1940 wxLineShape *lineShape = (wxLineShape *)m_shape;
1941 if (m_type == CONTROL_POINT_ENDPOINT_FROM)
1942 {
1943 if (m_oldCursor)
1944 m_canvas->SetCursor(m_oldCursor);
1945
1946 m_xpos = x; m_ypos = y;
1947
1948 if (lineShape->GetFrom())
1949 {
1950 lineShape->GetFrom()->EraseLinks(dc);
1951
1952 int new_attachment;
1953 double distance;
1954
1955 if (lineShape->GetFrom()->HitTest(x, y, &new_attachment, &distance))
1956 lineShape->SetAttachments(new_attachment, lineShape->GetAttachmentTo());
1957
1958 lineShape->GetFrom()->MoveLinks(dc);
1959 }
1960 }
1961 if (m_type == CONTROL_POINT_ENDPOINT_TO)
1962 {
1963 if (m_oldCursor)
1964 m_canvas->SetCursor(m_oldCursor);
1965 m_shape->Erase(dc);
1966
1967 m_xpos = x; m_ypos = y;
1968
1969 if (lineShape->GetTo())
1970 {
1971 lineShape->GetTo()->EraseLinks(dc);
1972
1973 int new_attachment;
1974 double distance;
1975 if (lineShape->GetTo()->HitTest(x, y, &new_attachment, &distance))
1976 lineShape->SetAttachments(lineShape->GetAttachmentFrom(), new_attachment);
1977
1978 lineShape->GetTo()->MoveLinks(dc);
1979 }
1980 }
1981 int i = 0;
1982 for (i = 0; i < lineShape->GetLineControlPoints()->GetCount(); i++)
1983 if (((wxRealPoint *)(lineShape->GetLineControlPoints()->Item(i)->GetData())) == m_point)
1984 break;
1985 lineShape->OnMoveControlPoint(i+1, x, y);
1986 if (!m_canvas->GetQuickEditMode()) m_canvas->Redraw(dc);
1987}
1988#endif
1989
1990/*
1991 * Get the point on the given line (x1, y1) (x2, y2)
1992 * distance 'length' along from the end,
1993 * returned values in x and y
1994 */
1995
1996void GetPointOnLine(double x1, double y1, double x2, double y2,
1997 double length, double *x, double *y)
1998{
1999 double l = (double)sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1));
2000
2001 if (l < 0.01)
2002 l = (double) 0.01;
2003
2004 double i_bar = (x2 - x1)/l;
2005 double j_bar = (y2 - y1)/l;
2006
2007 *x = (- length*i_bar) + x2;
2008 *y = (- length*j_bar) + y2;
2009}
2010
2011wxArrowHead *wxLineShape::AddArrow(WXTYPE type, int end, double size, double xOffset,
2012 const wxString& name, wxPseudoMetaFile *mf, long arrowId)
2013{
2014 wxArrowHead *arrow = new wxArrowHead(type, end, size, xOffset, name, mf, arrowId);
2015 m_arcArrows.Append(arrow);
2016 return arrow;
2017}
2018
2019/*
2020 * Add arrowhead at a particular position in the arrowhead list.
2021 */
2022bool wxLineShape::AddArrowOrdered(wxArrowHead *arrow, wxList& referenceList, int end)
2023{
2024 wxNode *refNode = referenceList.GetFirst();
2025 wxNode *currNode = m_arcArrows.GetFirst();
2026 wxString targetName(arrow->GetName());
2027 if (!refNode) return FALSE;
2028
2029 // First check whether we need to insert in front of list,
2030 // because this arrowhead is the first in the reference
2031 // list and should therefore be first in the current list.
2032 wxArrowHead *refArrow = (wxArrowHead *)refNode->GetData();
2033 if (refArrow->GetName() == targetName)
2034 {
2035 m_arcArrows.Insert(arrow);
2036 return TRUE;
2037 }
2038
2039 while (refNode && currNode)
2040 {
2041 wxArrowHead *currArrow = (wxArrowHead *)currNode->GetData();
2042 refArrow = (wxArrowHead *)refNode->GetData();
2043
2044 // Matching: advance current arrow pointer
2045 if ((currArrow->GetArrowEnd() == end) &&
2046 (currArrow->GetName() == refArrow->GetName()))
2047 {
2048 currNode = currNode->GetNext(); // Could be NULL now
2049 if (currNode)
2050 currArrow = (wxArrowHead *)currNode->GetData();
2051 }
2052
2053 // Check if we're at the correct position in the
2054 // reference list
2055 if (targetName == refArrow->GetName())
2056 {
2057 if (currNode)
2058 m_arcArrows.Insert(currNode, arrow);
2059 else
2060 m_arcArrows.Append(arrow);
2061 return TRUE;
2062 }
2063 refNode = refNode->GetNext();
2064 }
2065 m_arcArrows.Append(arrow);
2066 return TRUE;
2067}
2068
2069void wxLineShape::ClearArrowsAtPosition(int end)
2070{
2071 wxNode *node = m_arcArrows.GetFirst();
2072 while (node)
2073 {
2074 wxArrowHead *arrow = (wxArrowHead *)node->GetData();
2075 wxNode *next = node->GetNext();
2076 switch (end)
2077 {
2078 case -1:
2079 {
2080 delete arrow;
2081 delete node;
2082 break;
2083 }
2084 case ARROW_POSITION_START:
2085 {
2086 if (arrow->GetArrowEnd() == ARROW_POSITION_START)
2087 {
2088 delete arrow;
2089 delete node;
2090 }
2091 break;
2092 }
2093 case ARROW_POSITION_END:
2094 {
2095 if (arrow->GetArrowEnd() == ARROW_POSITION_END)
2096 {
2097 delete arrow;
2098 delete node;
2099 }
2100 break;
2101 }
2102 case ARROW_POSITION_MIDDLE:
2103 {
2104 if (arrow->GetArrowEnd() == ARROW_POSITION_MIDDLE)
2105 {
2106 delete arrow;
2107 delete node;
2108 }
2109 break;
2110 }
2111 }
2112 node = next;
2113 }
2114}
2115
2116bool wxLineShape::ClearArrow(const wxString& name)
2117{
2118 wxNode *node = m_arcArrows.GetFirst();
2119 while (node)
2120 {
2121 wxArrowHead *arrow = (wxArrowHead *)node->GetData();
2122 if (arrow->GetName() == name)
2123 {
2124 delete arrow;
2125 delete node;
2126 return TRUE;
2127 }
2128 node = node->GetNext();
2129 }
2130 return FALSE;
2131}
2132
2133/*
2134 * Finds an arrowhead at the given position (if -1, any position)
2135 *
2136 */
2137
2138wxArrowHead *wxLineShape::FindArrowHead(int position, const wxString& name)
2139{
2140 wxNode *node = m_arcArrows.GetFirst();
2141 while (node)
2142 {
2143 wxArrowHead *arrow = (wxArrowHead *)node->GetData();
2144 if (((position == -1) || (position == arrow->GetArrowEnd())) &&
2145 (arrow->GetName() == name))
2146 return arrow;
2147 node = node->GetNext();
2148 }
2149 return NULL;
2150}
2151
2152wxArrowHead *wxLineShape::FindArrowHead(long arrowId)
2153{
2154 wxNode *node = m_arcArrows.GetFirst();
2155 while (node)
2156 {
2157 wxArrowHead *arrow = (wxArrowHead *)node->GetData();
2158 if (arrowId == arrow->GetId())
2159 return arrow;
2160 node = node->GetNext();
2161 }
2162 return NULL;
2163}
2164
2165/*
2166 * Deletes an arrowhead at the given position (if -1, any position)
2167 *
2168 */
2169
2170bool wxLineShape::DeleteArrowHead(int position, const wxString& name)
2171{
2172 wxNode *node = m_arcArrows.GetFirst();
2173 while (node)
2174 {
2175 wxArrowHead *arrow = (wxArrowHead *)node->GetData();
2176 if (((position == -1) || (position == arrow->GetArrowEnd())) &&
2177 (arrow->GetName() == name))
2178 {
2179 delete arrow;
2180 delete node;
2181 return TRUE;
2182 }
2183 node = node->GetNext();
2184 }
2185 return FALSE;
2186}
2187
2188// Overloaded DeleteArrowHead: pass arrowhead id.
2189bool wxLineShape::DeleteArrowHead(long id)
2190{
2191 wxNode *node = m_arcArrows.GetFirst();
2192 while (node)
2193 {
2194 wxArrowHead *arrow = (wxArrowHead *)node->GetData();
2195 if (arrow->GetId() == id)
2196 {
2197 delete arrow;
2198 delete node;
2199 return TRUE;
2200 }
2201 node = node->GetNext();
2202 }
2203 return FALSE;
2204}
2205
2206/*
2207 * Calculate the minimum width a line
2208 * occupies, for the purposes of drawing lines in tools.
2209 *
2210 */
2211
2212double wxLineShape::FindMinimumWidth()
2213{
2214 double minWidth = 0.0;
2215 wxNode *node = m_arcArrows.GetFirst();
2216 while (node)
2217 {
2218 wxArrowHead *arrowHead = (wxArrowHead *)node->GetData();
2219 minWidth += arrowHead->GetSize();
2220 if (node->GetNext())
2221 minWidth += arrowHead->GetSpacing();
2222
2223 node = node->GetNext();
2224 }
2225 // We have ABSOLUTE minimum now. So
2226 // scale it to give it reasonable aesthetics
2227 // when drawing with line.
2228 if (minWidth > 0.0)
2229 minWidth = (double)(minWidth * 1.4);
2230 else
2231 minWidth = 20.0;
2232
2233 SetEnds(0.0, 0.0, minWidth, 0.0);
2234 Initialise();
2235
2236 return minWidth;
2237}
2238
2239// Find which position we're talking about at this (x, y).
2240// Returns ARROW_POSITION_START, ARROW_POSITION_MIDDLE, ARROW_POSITION_END
2241int wxLineShape::FindLinePosition(double x, double y)
2242{
2243 double startX, startY, endX, endY;
2244 GetEnds(&startX, &startY, &endX, &endY);
2245
2246 // Find distances from centre, start and end. The smallest wins.
2247 double centreDistance = (double)(sqrt((x - m_xpos)*(x - m_xpos) + (y - m_ypos)*(y - m_ypos)));
2248 double startDistance = (double)(sqrt((x - startX)*(x - startX) + (y - startY)*(y - startY)));
2249 double endDistance = (double)(sqrt((x - endX)*(x - endX) + (y - endY)*(y - endY)));
2250
2251 if (centreDistance < startDistance && centreDistance < endDistance)
2252 return ARROW_POSITION_MIDDLE;
2253 else if (startDistance < endDistance)
2254 return ARROW_POSITION_START;
2255 else
2256 return ARROW_POSITION_END;
2257}
2258
2259// Set alignment flags
2260void wxLineShape::SetAlignmentOrientation(bool isEnd, bool isHoriz)
2261{
2262 if (isEnd)
2263 {
2264 if (isHoriz && ((m_alignmentEnd & LINE_ALIGNMENT_HORIZ) != LINE_ALIGNMENT_HORIZ))
2265 m_alignmentEnd |= LINE_ALIGNMENT_HORIZ;
2266 else if (!isHoriz && ((m_alignmentEnd & LINE_ALIGNMENT_HORIZ) == LINE_ALIGNMENT_HORIZ))
2267 m_alignmentEnd -= LINE_ALIGNMENT_HORIZ;
2268 }
2269 else
2270 {
2271 if (isHoriz && ((m_alignmentStart & LINE_ALIGNMENT_HORIZ) != LINE_ALIGNMENT_HORIZ))
2272 m_alignmentStart |= LINE_ALIGNMENT_HORIZ;
2273 else if (!isHoriz && ((m_alignmentStart & LINE_ALIGNMENT_HORIZ) == LINE_ALIGNMENT_HORIZ))
2274 m_alignmentStart -= LINE_ALIGNMENT_HORIZ;
2275 }
2276}
2277
2278void wxLineShape::SetAlignmentType(bool isEnd, int alignType)
2279{
2280 if (isEnd)
2281 {
2282 if (alignType == LINE_ALIGNMENT_TO_NEXT_HANDLE)
2283 {
2284 if ((m_alignmentEnd & LINE_ALIGNMENT_TO_NEXT_HANDLE) != LINE_ALIGNMENT_TO_NEXT_HANDLE)
2285 m_alignmentEnd |= LINE_ALIGNMENT_TO_NEXT_HANDLE;
2286 }
2287 else if ((m_alignmentEnd & LINE_ALIGNMENT_TO_NEXT_HANDLE) == LINE_ALIGNMENT_TO_NEXT_HANDLE)
2288 m_alignmentEnd -= LINE_ALIGNMENT_TO_NEXT_HANDLE;
2289 }
2290 else
2291 {
2292 if (alignType == LINE_ALIGNMENT_TO_NEXT_HANDLE)
2293 {
2294 if ((m_alignmentStart & LINE_ALIGNMENT_TO_NEXT_HANDLE) != LINE_ALIGNMENT_TO_NEXT_HANDLE)
2295 m_alignmentStart |= LINE_ALIGNMENT_TO_NEXT_HANDLE;
2296 }
2297 else if ((m_alignmentStart & LINE_ALIGNMENT_TO_NEXT_HANDLE) == LINE_ALIGNMENT_TO_NEXT_HANDLE)
2298 m_alignmentStart -= LINE_ALIGNMENT_TO_NEXT_HANDLE;
2299 }
2300}
2301
2302bool wxLineShape::GetAlignmentOrientation(bool isEnd)
2303{
2304 if (isEnd)
2305 return ((m_alignmentEnd & LINE_ALIGNMENT_HORIZ) == LINE_ALIGNMENT_HORIZ);
2306 else
2307 return ((m_alignmentStart & LINE_ALIGNMENT_HORIZ) == LINE_ALIGNMENT_HORIZ);
2308}
2309
2310int wxLineShape::GetAlignmentType(bool isEnd)
2311{
2312 if (isEnd)
2313 return (m_alignmentEnd & LINE_ALIGNMENT_TO_NEXT_HANDLE);
2314 else
2315 return (m_alignmentStart & LINE_ALIGNMENT_TO_NEXT_HANDLE);
2316}
2317
2318wxRealPoint *wxLineShape::GetNextControlPoint(wxShape *nodeObject)
2319{
2320 int n = m_lineControlPoints->GetCount();
2321 int nn = 0;
2322 if (m_to == nodeObject)
2323 {
2324 // Must be END of line, so we want (n - 1)th control point.
2325 // But indexing ends at n-1, so subtract 2.
2326 nn = n - 2;
2327 }
2328 else nn = 1;
2329 wxNode *node = m_lineControlPoints->Item(nn);
2330 if (node)
2331 {
2332 return (wxRealPoint *)node->GetData();
2333 }
2334 else
2335 return FALSE;
2336}
2337
2338/*
2339 * Arrowhead
2340 *
2341 */
2342
2343IMPLEMENT_DYNAMIC_CLASS(wxArrowHead, wxObject)
2344
2345wxArrowHead::wxArrowHead(WXTYPE type, int end, double size, double dist, const wxString& name,
2346 wxPseudoMetaFile *mf, long arrowId)
2347{
2348 m_arrowType = type; m_arrowEnd = end; m_arrowSize = size;
2349 m_xOffset = dist;
2350 m_yOffset = 0.0;
2351 m_spacing = 5.0;
2352
2353 m_arrowName = name;
2354 m_metaFile = mf;
2355 m_id = arrowId;
2356 if (m_id == -1)
2357 m_id = wxNewId();
2358}
2359
2360wxArrowHead::wxArrowHead(wxArrowHead& toCopy)
2361{
2362 m_arrowType = toCopy.m_arrowType; m_arrowEnd = toCopy.GetArrowEnd();
2363 m_arrowSize = toCopy.m_arrowSize;
2364 m_xOffset = toCopy.m_xOffset;
2365 m_yOffset = toCopy.m_yOffset;
2366 m_spacing = toCopy.m_spacing;
2367 m_arrowName = toCopy.m_arrowName ;
2368 if (toCopy.m_metaFile)
2369 m_metaFile = new wxPseudoMetaFile(*(toCopy.m_metaFile));
2370 else
2371 m_metaFile = NULL;
2372 m_id = wxNewId();
2373}
2374
2375wxArrowHead::~wxArrowHead()
2376{
2377 if (m_metaFile) delete m_metaFile;
2378}
2379
2380void wxArrowHead::SetSize(double size)
2381{
2382 m_arrowSize = size;
2383 if ((m_arrowType == ARROW_METAFILE) && m_metaFile)
2384 {
2385 double oldWidth = m_metaFile->m_width;
2386 if (oldWidth == 0.0)
2387 return;
2388
2389 double scale = (double)(size/oldWidth);
2390 if (scale != 1.0)
2391 m_metaFile->Scale(scale, scale);
2392 }
2393}
2394
2395// Can override this to create a different class of label shape
2396wxLabelShape* wxLineShape::OnCreateLabelShape(wxLineShape *parent, wxShapeRegion *region, double w, double h)
2397{
2398 return new wxLabelShape(parent, region, w, h);
2399}
2400
2401/*
2402 * Label object
2403 *
2404 */
2405
2406IMPLEMENT_DYNAMIC_CLASS(wxLabelShape, wxRectangleShape)
2407
2408wxLabelShape::wxLabelShape(wxLineShape *parent, wxShapeRegion *region, double w, double h):wxRectangleShape(w, h)
2409{
2410 m_lineShape = parent;
2411 m_shapeRegion = region;
2412 SetPen(wxThePenList->FindOrCreatePen(wxColour(0, 0, 0), 1, wxDOT));
2413}
2414
2415wxLabelShape::~wxLabelShape()
2416{
2417}
2418
2419void wxLabelShape::OnDraw(wxDC& dc)
2420{
2421 if (m_lineShape && !m_lineShape->GetDrawHandles())
2422 return;
2423
2424 double x1 = (double)(m_xpos - m_width/2.0);
2425 double y1 = (double)(m_ypos - m_height/2.0);
2426
2427 if (m_pen)
2428 {
2429 if (m_pen->GetWidth() == 0)
2430 dc.SetPen(* g_oglTransparentPen);
2431 else
2432 dc.SetPen(* m_pen);
2433 }
2434 dc.SetBrush(* wxTRANSPARENT_BRUSH);
2435
2436 if (m_cornerRadius > 0.0)
2437 dc.DrawRoundedRectangle(WXROUND(x1), WXROUND(y1), WXROUND(m_width), WXROUND(m_height), m_cornerRadius);
2438 else
2439 dc.DrawRectangle(WXROUND(x1), WXROUND(y1), WXROUND(m_width), WXROUND(m_height));
2440}
2441
2442void wxLabelShape::OnDrawContents(wxDC& dc)
2443{
2444}
2445
2446void wxLabelShape::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
2447{
2448 wxRectangleShape::OnDragLeft(draw, x, y, keys, attachment);
2449}
2450
2451void wxLabelShape::OnBeginDragLeft(double x, double y, int keys, int attachment)
2452{
2453 wxRectangleShape::OnBeginDragLeft(x, y, keys, attachment);
2454}
2455
2456void wxLabelShape::OnEndDragLeft(double x, double y, int keys, int attachment)
2457{
2458 wxRectangleShape::OnEndDragLeft(x, y, keys, attachment);
2459}
2460
2461bool wxLabelShape::OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display)
2462{
2463 return m_lineShape->OnLabelMovePre(dc, this, x, y, old_x, old_y, display);
2464}
2465
2466bool wxLineShape::OnLabelMovePre(wxDC& dc, wxLabelShape* labelShape, double x, double y, double old_x, double old_y, bool display)
2467{
2468 labelShape->m_shapeRegion->SetSize(labelShape->GetWidth(), labelShape->GetHeight());
2469
2470 // Find position in line's region list
2471 int i = 0;
2472 wxNode *node = GetRegions().GetFirst();
2473 while (node)
2474 {
2475 if (labelShape->m_shapeRegion == (wxShapeRegion *)node->GetData())
2476 node = NULL;
2477 else
2478 {
2479 node = node->GetNext();
2480 i ++;
2481 }
2482 }
2483 double xx, yy;
2484 GetLabelPosition(i, &xx, &yy);
2485 // Set the region's offset, relative to the default position for
2486 // each region.
2487 labelShape->m_shapeRegion->SetPosition((double)(x - xx), (double)(y - yy));
2488
2489 labelShape->SetX(x);
2490 labelShape->SetY(y);
2491
2492 // Need to reformat to fit region.
2493 if (labelShape->m_shapeRegion->GetText())
2494 {
2495
2496 wxString s(labelShape->m_shapeRegion->GetText());
2497 labelShape->FormatText(dc, s, i);
2498 DrawRegion(dc, labelShape->m_shapeRegion, xx, yy);
2499 }
2500 return TRUE;
2501}
2502
2503// Divert left and right clicks to line object
2504void wxLabelShape::OnLeftClick(double x, double y, int keys, int attachment)
2505{
2506 m_lineShape->GetEventHandler()->OnLeftClick(x, y, keys, attachment);
2507}
2508
2509void wxLabelShape::OnRightClick(double x, double y, int keys, int attachment)
2510{
2511 m_lineShape->GetEventHandler()->OnRightClick(x, y, keys, attachment);
2512}
2513