]>
Commit | Line | Data |
---|---|---|
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 | |
43 | IMPLEMENT_DYNAMIC_CLASS(wxLineShape, wxShape) | |
44 | ||
45 | wxLineShape::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 | ||
89 | wxLineShape::~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 | ||
109 | void 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 | ||
126 | wxNode *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 | ||
145 | bool 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 | ||
160 | void 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 | |
201 | void 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 | ||
264 | void 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 | ||
301 | void 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 | |
328 | void 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 | */ | |
374 | void 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 | ||
388 | void 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 | ||
420 | void 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 | ||
430 | void 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 | |
448 | void 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 | ||
459 | void wxLineShape::SetAttachments(int from_attach, int to_attach) | |
460 | { | |
461 | m_attachmentFrom = from_attach; | |
462 | m_attachmentTo = to_attach; | |
463 | } | |
464 | ||
465 | bool 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 | ||
532 | void 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 | ||
585 | void 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 | ||
844 | void 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 | ||
893 | void 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 | */ | |
921 | void 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 | ||
965 | void 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 | ||
982 | bool 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 | ||
1025 | void 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. | |
1087 | void 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 | ||
1173 | void 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 | ||
1218 | void 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 | ||
1232 | void 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 | ||
1243 | void wxLineShape::OnDragLeft(bool draw, double x, double y, int keys, int attachment) | |
1244 | { | |
1245 | } | |
1246 | ||
1247 | void wxLineShape::OnBeginDragLeft(double x, double y, int keys, int attachment) | |
1248 | { | |
1249 | } | |
1250 | ||
1251 | void wxLineShape::OnEndDragLeft(double x, double y, int keys, int attachment) | |
1252 | { | |
1253 | } | |
1254 | ||
1255 | /* | |
1256 | void wxLineShape::SetArrowSize(double length, double width) | |
1257 | { | |
1258 | arrow_length = length; | |
1259 | arrow_width = width; | |
1260 | } | |
1261 | ||
1262 | void wxLineShape::SetStartArrow(int style) | |
1263 | { | |
1264 | start_style = style; | |
1265 | } | |
1266 | ||
1267 | void wxLineShape::SetMiddleArrow(int style) | |
1268 | { | |
1269 | middle_style = style; | |
1270 | } | |
1271 | ||
1272 | void wxLineShape::SetEndArrow(int style) | |
1273 | { | |
1274 | end_style = style; | |
1275 | } | |
1276 | */ | |
1277 | ||
1278 | void 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 | ||
1296 | void wxLineShape::SetTo(wxShape *object) | |
1297 | { | |
1298 | m_to = object; | |
1299 | } | |
1300 | ||
1301 | void wxLineShape::SetFrom(wxShape *object) | |
1302 | { | |
1303 | m_from = object; | |
1304 | } | |
1305 | ||
1306 | void 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 | ||
1349 | void 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 | |
1369 | void 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 | ||
1439 | void 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 | ||
1583 | void 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 | |
1637 | void 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 | ||
1691 | IMPLEMENT_DYNAMIC_CLASS(wxLineControlPoint, wxControlPoint) | |
1692 | ||
1693 | wxLineControlPoint::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 | ||
1702 | wxLineControlPoint::~wxLineControlPoint() | |
1703 | { | |
1704 | } | |
1705 | ||
1706 | void wxLineControlPoint::OnDraw(wxDC& dc) | |
1707 | { | |
1708 | wxRectangleShape::OnDraw(dc); | |
1709 | } | |
1710 | ||
1711 | // Implement movement of Line point | |
1712 | void 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 | ||
1717 | void wxLineControlPoint::OnBeginDragLeft(double x, double y, int keys, int attachment) | |
1718 | { | |
1719 | m_shape->GetEventHandler()->OnSizingBeginDragLeft(this, x, y, keys, attachment); | |
1720 | } | |
1721 | ||
1722 | void 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. | |
1729 | void 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 | ||
1771 | void 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 | ||
1819 | void 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. | |
1888 | bool 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 | |
1902 | void 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 | ||
1910 | void 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 | ||
1935 | void 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 | ||
1996 | void 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 | ||
2011 | wxArrowHead *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 | */ | |
2022 | bool 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 | ||
2069 | void 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 | ||
2116 | bool 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 | ||
2138 | wxArrowHead *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 | ||
2152 | wxArrowHead *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 | ||
2170 | bool 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. | |
2189 | bool 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 | ||
2212 | double 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 | |
2241 | int 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 | |
2260 | void 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 | ||
2278 | void 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 | ||
2302 | bool 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 | ||
2310 | int 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 | ||
2318 | wxRealPoint *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 | ||
2343 | IMPLEMENT_DYNAMIC_CLASS(wxArrowHead, wxObject) | |
2344 | ||
2345 | wxArrowHead::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 | ||
2360 | wxArrowHead::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 | ||
2375 | wxArrowHead::~wxArrowHead() | |
2376 | { | |
2377 | if (m_metaFile) delete m_metaFile; | |
2378 | } | |
2379 | ||
2380 | void 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 | |
2396 | wxLabelShape* 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 | ||
2406 | IMPLEMENT_DYNAMIC_CLASS(wxLabelShape, wxRectangleShape) | |
2407 | ||
2408 | wxLabelShape::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 | ||
2415 | wxLabelShape::~wxLabelShape() | |
2416 | { | |
2417 | } | |
2418 | ||
2419 | void 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 | ||
2442 | void wxLabelShape::OnDrawContents(wxDC& dc) | |
2443 | { | |
2444 | } | |
2445 | ||
2446 | void wxLabelShape::OnDragLeft(bool draw, double x, double y, int keys, int attachment) | |
2447 | { | |
2448 | wxRectangleShape::OnDragLeft(draw, x, y, keys, attachment); | |
2449 | } | |
2450 | ||
2451 | void wxLabelShape::OnBeginDragLeft(double x, double y, int keys, int attachment) | |
2452 | { | |
2453 | wxRectangleShape::OnBeginDragLeft(x, y, keys, attachment); | |
2454 | } | |
2455 | ||
2456 | void wxLabelShape::OnEndDragLeft(double x, double y, int keys, int attachment) | |
2457 | { | |
2458 | wxRectangleShape::OnEndDragLeft(x, y, keys, attachment); | |
2459 | } | |
2460 | ||
2461 | bool 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 | ||
2466 | bool 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 | |
2504 | void wxLabelShape::OnLeftClick(double x, double y, int keys, int attachment) | |
2505 | { | |
2506 | m_lineShape->GetEventHandler()->OnLeftClick(x, y, keys, attachment); | |
2507 | } | |
2508 | ||
2509 | void wxLabelShape::OnRightClick(double x, double y, int keys, int attachment) | |
2510 | { | |
2511 | m_lineShape->GetEventHandler()->OnRightClick(x, y, keys, attachment); | |
2512 | } | |
2513 |