]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: misc.cpp | |
3 | // Purpose: Miscellaneous OGL support functions | |
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 "misc.h" | |
14 | #endif | |
15 | ||
16 | // For compilers that support precompilation, includes "wx.h". | |
17 | #include "wx/wxprec.h" | |
18 | ||
19 | #ifdef __BORLANDC__ | |
20 | #pragma hdrstop | |
21 | #endif | |
22 | ||
23 | #ifndef WX_PRECOMP | |
24 | #include <wx/wx.h> | |
25 | #endif | |
26 | ||
27 | #if wxUSE_PROLOGIO | |
28 | #include <wx/deprecated/wxexpr.h> | |
29 | #endif | |
30 | ||
31 | #include <wx/types.h> | |
32 | ||
33 | #ifdef new | |
34 | #undef new | |
35 | #endif | |
36 | ||
37 | #include <ctype.h> | |
38 | #include <math.h> | |
39 | #include <stdlib.h> | |
40 | ||
41 | #include "wx/ogl/ogl.h" | |
42 | ||
43 | ||
44 | wxFont* g_oglNormalFont; | |
45 | wxPen* g_oglBlackPen; | |
46 | wxPen* g_oglWhiteBackgroundPen; | |
47 | wxPen* g_oglTransparentPen; | |
48 | wxBrush* g_oglWhiteBackgroundBrush; | |
49 | wxPen* g_oglBlackForegroundPen; | |
50 | wxCursor* g_oglBullseyeCursor = NULL; | |
51 | ||
52 | wxChar* oglBuffer = NULL; | |
53 | ||
54 | wxList oglObjectCopyMapping(wxKEY_INTEGER); | |
55 | ||
56 | ||
57 | ||
58 | void wxOGLInitialize() | |
59 | { | |
60 | g_oglBullseyeCursor = new wxCursor(wxCURSOR_BULLSEYE); | |
61 | ||
62 | g_oglNormalFont = new wxFont(10, wxSWISS, wxNORMAL, wxNORMAL); | |
63 | ||
64 | g_oglBlackPen = new wxPen(wxT("BLACK"), 1, wxSOLID); | |
65 | ||
66 | g_oglWhiteBackgroundPen = new wxPen(wxT("WHITE"), 1, wxSOLID); | |
67 | g_oglTransparentPen = new wxPen(wxT("WHITE"), 1, wxTRANSPARENT); | |
68 | g_oglWhiteBackgroundBrush = new wxBrush(wxT("WHITE"), wxSOLID); | |
69 | g_oglBlackForegroundPen = new wxPen(wxT("BLACK"), 1, wxSOLID); | |
70 | ||
71 | OGLInitializeConstraintTypes(); | |
72 | ||
73 | // Initialize big buffer used when writing images | |
74 | oglBuffer = new wxChar[3000]; | |
75 | ||
76 | } | |
77 | ||
78 | void wxOGLCleanUp() | |
79 | { | |
80 | if (oglBuffer) | |
81 | { | |
82 | delete[] oglBuffer; | |
83 | oglBuffer = NULL; | |
84 | } | |
85 | oglBuffer = NULL; | |
86 | ||
87 | if (g_oglBullseyeCursor) | |
88 | { | |
89 | delete g_oglBullseyeCursor; | |
90 | g_oglBullseyeCursor = NULL; | |
91 | } | |
92 | ||
93 | if (g_oglNormalFont) | |
94 | { | |
95 | delete g_oglNormalFont; | |
96 | g_oglNormalFont = NULL; | |
97 | } | |
98 | if (g_oglBlackPen) | |
99 | { | |
100 | delete g_oglBlackPen; | |
101 | g_oglBlackPen = NULL; | |
102 | } | |
103 | if (g_oglWhiteBackgroundPen) | |
104 | { | |
105 | delete g_oglWhiteBackgroundPen; | |
106 | g_oglWhiteBackgroundPen = NULL; | |
107 | } | |
108 | if (g_oglTransparentPen) | |
109 | { | |
110 | delete g_oglTransparentPen; | |
111 | g_oglTransparentPen = NULL; | |
112 | } | |
113 | if (g_oglWhiteBackgroundBrush) | |
114 | { | |
115 | delete g_oglWhiteBackgroundBrush; | |
116 | g_oglWhiteBackgroundBrush = NULL; | |
117 | } | |
118 | if (g_oglBlackForegroundPen) | |
119 | { | |
120 | delete g_oglBlackForegroundPen; | |
121 | g_oglBlackForegroundPen = NULL; | |
122 | } | |
123 | ||
124 | OGLCleanUpConstraintTypes(); | |
125 | } | |
126 | ||
127 | wxFont *oglMatchFont(int point_size) | |
128 | { | |
129 | wxFont *font = wxTheFontList->FindOrCreateFont(point_size, wxSWISS, wxNORMAL, wxNORMAL); | |
130 | #if 0 | |
131 | switch (point_size) | |
132 | { | |
133 | case 4: | |
134 | font = swiss_font_4; | |
135 | break; | |
136 | case 6: | |
137 | font = swiss_font_6; | |
138 | break; | |
139 | case 8: | |
140 | font = swiss_font_8; | |
141 | break; | |
142 | case 12: | |
143 | font = swiss_font_12; | |
144 | break; | |
145 | case 14: | |
146 | font = swiss_font_14; | |
147 | break; | |
148 | case 18: | |
149 | font = swiss_font_18; | |
150 | break; | |
151 | case 24: | |
152 | font = swiss_font_24; | |
153 | break; | |
154 | default: | |
155 | case 10: | |
156 | font = swiss_font_10; | |
157 | break; | |
158 | } | |
159 | #endif | |
160 | return font; | |
161 | } | |
162 | ||
163 | int FontSizeDialog(wxFrame *parent, int old_size) | |
164 | { | |
165 | if (old_size <= 0) | |
166 | old_size = 10; | |
167 | wxString buf; | |
168 | buf << old_size; | |
169 | wxString ans = wxGetTextFromUser(wxT("Enter point size"), wxT("Font size"), buf, parent); | |
170 | if (ans.Length() == 0) | |
171 | return 0; | |
172 | ||
173 | long new_size = 0; | |
174 | ans.ToLong(&new_size); | |
175 | if ((new_size <= 0) || (new_size > 40)) | |
176 | { | |
177 | wxMessageBox(wxT("Invalid point size!"), wxT("Error"), wxOK); | |
178 | return 0; | |
179 | } | |
180 | return new_size; | |
181 | /* | |
182 | char *strings[8]; | |
183 | strings[0] = "4"; | |
184 | strings[1] = "6"; | |
185 | strings[2] = "8"; | |
186 | strings[3] = "10"; | |
187 | strings[4] = "12"; | |
188 | strings[5] = "14"; | |
189 | strings[6] = "18"; | |
190 | strings[7] = "24"; | |
191 | char *ans = wxGetSingleChoice("Choose", "Choose a font size", 8, strings, parent); | |
192 | if (ans) | |
193 | { | |
194 | int size; | |
195 | sscanf(ans, "%d", &size); | |
196 | return oglMatchFont(size); | |
197 | } | |
198 | else return NULL; | |
199 | */ | |
200 | } | |
201 | ||
202 | // Centre a list of strings in the given box. xOffset and yOffset are the | |
203 | // the positions that these lines should be relative to, and this might be | |
204 | // the same as m_xpos, m_ypos, but might be zero if formatting from left-justifying. | |
205 | void oglCentreText(wxDC& dc, wxList *text_list, | |
206 | double m_xpos, double m_ypos, double width, double height, | |
207 | int formatMode) | |
208 | { | |
209 | int n = text_list->GetCount(); | |
210 | ||
211 | if (!text_list || (n == 0)) | |
212 | return; | |
213 | ||
214 | // First, get maximum dimensions of box enclosing text | |
215 | ||
216 | long char_height = 0; | |
217 | long max_width = 0; | |
218 | long current_width = 0; | |
219 | ||
220 | // Store text extents for speed | |
221 | double *widths = new double[n]; | |
222 | ||
223 | wxNode *current = text_list->GetFirst(); | |
224 | int i = 0; | |
225 | while (current) | |
226 | { | |
227 | wxShapeTextLine *line = (wxShapeTextLine *)current->GetData(); | |
228 | dc.GetTextExtent(line->GetText(), ¤t_width, &char_height); | |
229 | widths[i] = current_width; | |
230 | ||
231 | if (current_width > max_width) | |
232 | max_width = current_width; | |
233 | current = current->GetNext(); | |
234 | i ++; | |
235 | } | |
236 | ||
237 | double max_height = n*char_height; | |
238 | ||
239 | double xoffset, yoffset, xOffset, yOffset; | |
240 | ||
241 | if (formatMode & FORMAT_CENTRE_VERT) | |
242 | { | |
243 | if (max_height < height) | |
244 | yoffset = (double)(m_ypos - (height/2.0) + (height - max_height)/2.0); | |
245 | else | |
246 | yoffset = (double)(m_ypos - (height/2.0)); | |
247 | yOffset = m_ypos; | |
248 | } | |
249 | else | |
250 | { | |
251 | yoffset = 0.0; | |
252 | yOffset = 0.0; | |
253 | } | |
254 | ||
255 | if (formatMode & FORMAT_CENTRE_HORIZ) | |
256 | { | |
257 | xoffset = (double)(m_xpos - width/2.0); | |
258 | xOffset = m_xpos; | |
259 | } | |
260 | else | |
261 | { | |
262 | xoffset = 0.0; | |
263 | xOffset = 0.0; | |
264 | } | |
265 | ||
266 | current = text_list->GetFirst(); | |
267 | i = 0; | |
268 | ||
269 | while (current) | |
270 | { | |
271 | wxShapeTextLine *line = (wxShapeTextLine *)current->GetData(); | |
272 | ||
273 | double x; | |
274 | if ((formatMode & FORMAT_CENTRE_HORIZ) && (widths[i] < width)) | |
275 | x = (double)((width - widths[i])/2.0 + xoffset); | |
276 | else | |
277 | x = xoffset; | |
278 | double y = (double)(i*char_height + yoffset); | |
279 | ||
280 | line->SetX( x - xOffset ); line->SetY( y - yOffset ); | |
281 | current = current->GetNext(); | |
282 | i ++; | |
283 | } | |
284 | ||
285 | delete widths; | |
286 | } | |
287 | ||
288 | // Centre a list of strings in the given box | |
289 | void oglCentreTextNoClipping(wxDC& dc, wxList *text_list, | |
290 | double m_xpos, double m_ypos, double width, double height) | |
291 | { | |
292 | int n = text_list->GetCount(); | |
293 | ||
294 | if (!text_list || (n == 0)) | |
295 | return; | |
296 | ||
297 | // First, get maximum dimensions of box enclosing text | |
298 | ||
299 | long char_height = 0; | |
300 | long max_width = 0; | |
301 | long current_width = 0; | |
302 | ||
303 | // Store text extents for speed | |
304 | double *widths = new double[n]; | |
305 | ||
306 | wxNode *current = text_list->GetFirst(); | |
307 | int i = 0; | |
308 | while (current) | |
309 | { | |
310 | wxShapeTextLine *line = (wxShapeTextLine *)current->GetData(); | |
311 | dc.GetTextExtent(line->GetText(), ¤t_width, &char_height); | |
312 | widths[i] = current_width; | |
313 | ||
314 | if (current_width > max_width) | |
315 | max_width = current_width; | |
316 | current = current->GetNext(); | |
317 | i ++; | |
318 | } | |
319 | ||
320 | double max_height = n*char_height; | |
321 | ||
322 | double yoffset = (double)(m_ypos - (height/2.0) + (height - max_height)/2.0); | |
323 | ||
324 | double xoffset = (double)(m_xpos - width/2.0); | |
325 | ||
326 | current = text_list->GetFirst(); | |
327 | i = 0; | |
328 | ||
329 | while (current) | |
330 | { | |
331 | wxShapeTextLine *line = (wxShapeTextLine *)current->GetData(); | |
332 | ||
333 | double x = (double)((width - widths[i])/2.0 + xoffset); | |
334 | double y = (double)(i*char_height + yoffset); | |
335 | ||
336 | line->SetX( x - m_xpos ); line->SetY( y - m_ypos ); | |
337 | current = current->GetNext(); | |
338 | i ++; | |
339 | } | |
340 | delete widths; | |
341 | } | |
342 | ||
343 | void oglGetCentredTextExtent(wxDC& dc, wxList *text_list, | |
344 | double WXUNUSED(m_xpos), double WXUNUSED(m_ypos), double WXUNUSED(width), double WXUNUSED(height), | |
345 | double *actual_width, double *actual_height) | |
346 | { | |
347 | int n = text_list->GetCount(); | |
348 | ||
349 | if (!text_list || (n == 0)) | |
350 | { | |
351 | *actual_width = 0; | |
352 | *actual_height = 0; | |
353 | return; | |
354 | } | |
355 | ||
356 | // First, get maximum dimensions of box enclosing text | |
357 | ||
358 | long char_height = 0; | |
359 | long max_width = 0; | |
360 | long current_width = 0; | |
361 | ||
362 | wxNode *current = text_list->GetFirst(); | |
363 | int i = 0; | |
364 | while (current) | |
365 | { | |
366 | wxShapeTextLine *line = (wxShapeTextLine *)current->GetData(); | |
367 | dc.GetTextExtent(line->GetText(), ¤t_width, &char_height); | |
368 | ||
369 | if (current_width > max_width) | |
370 | max_width = current_width; | |
371 | current = current->GetNext(); | |
372 | i ++; | |
373 | } | |
374 | ||
375 | *actual_height = n*char_height; | |
376 | *actual_width = max_width; | |
377 | } | |
378 | ||
379 | // Format a string to a list of strings that fit in the given box. | |
380 | // Interpret %n and 10 or 13 as a new line. | |
381 | wxStringList *oglFormatText(wxDC& dc, const wxString& text, double width, double WXUNUSED(height), int formatMode) | |
382 | { | |
383 | // First, parse the string into a list of words | |
384 | wxStringList word_list; | |
385 | ||
386 | // Make new lines into NULL strings at this point | |
387 | int i = 0; int j = 0; int len = text.Length(); | |
388 | wxChar word[200]; word[0] = 0; | |
389 | bool end_word = FALSE; bool new_line = FALSE; | |
390 | while (i < len) | |
391 | { | |
392 | switch (text[i]) | |
393 | { | |
394 | case wxT('%'): | |
395 | { | |
396 | i ++; | |
397 | if (i == len) | |
398 | { word[j] = wxT('%'); j ++; } | |
399 | else | |
400 | { | |
401 | if (text[i] == wxT('n')) | |
402 | { new_line = TRUE; end_word = TRUE; i++; } | |
403 | else | |
404 | { word[j] = wxT('%'); j ++; word[j] = text[i]; j ++; i ++; } | |
405 | } | |
406 | break; | |
407 | } | |
408 | case 10: | |
409 | { | |
410 | new_line = TRUE; end_word = TRUE; i++; | |
411 | break; | |
412 | } | |
413 | case 13: | |
414 | { | |
415 | new_line = TRUE; end_word = TRUE; i++; | |
416 | } | |
417 | case wxT(' '): | |
418 | { | |
419 | end_word = TRUE; | |
420 | i ++; | |
421 | break; | |
422 | } | |
423 | default: | |
424 | { | |
425 | word[j] = text[i]; | |
426 | j ++; i ++; | |
427 | break; | |
428 | } | |
429 | } | |
430 | if (i == len) end_word = TRUE; | |
431 | if (end_word) | |
432 | { | |
433 | word[j] = 0; | |
434 | j = 0; | |
435 | word_list.Add(word); | |
436 | end_word = FALSE; | |
437 | } | |
438 | if (new_line) | |
439 | { | |
440 | word_list.Append(NULL); | |
441 | new_line = FALSE; | |
442 | } | |
443 | } | |
444 | // Now, make a list of strings which can fit in the box | |
445 | wxStringList *string_list = new wxStringList; | |
446 | ||
447 | wxString buffer; | |
448 | wxStringListNode *node = word_list.GetFirst(); | |
449 | long x, y; | |
450 | ||
451 | while (node) | |
452 | { | |
453 | wxString oldBuffer(buffer); | |
454 | ||
455 | wxChar *s = (wxChar *)node->GetData(); | |
456 | if (!s) | |
457 | { | |
458 | // FORCE NEW LINE | |
459 | if (buffer.Length() > 0) | |
460 | string_list->Add(buffer); | |
461 | ||
462 | buffer.Empty(); | |
463 | } | |
464 | else | |
465 | { | |
466 | if (buffer.Length() != 0) | |
467 | buffer += wxT(" "); | |
468 | ||
469 | buffer += s; | |
470 | dc.GetTextExtent(buffer, &x, &y); | |
471 | ||
472 | // Don't fit within the bounding box if we're fitting shape to contents | |
473 | if ((x > width) && !(formatMode & FORMAT_SIZE_TO_CONTENTS)) | |
474 | { | |
475 | // Deal with first word being wider than box | |
476 | if (oldBuffer.Length() > 0) | |
477 | string_list->Add(oldBuffer); | |
478 | ||
479 | buffer.Empty(); | |
480 | buffer += s; | |
481 | } | |
482 | } | |
483 | ||
484 | node = node->GetNext(); | |
485 | } | |
486 | if (buffer.Length() != 0) | |
487 | string_list->Add(buffer); | |
488 | ||
489 | return string_list; | |
490 | } | |
491 | ||
492 | void oglDrawFormattedText(wxDC& dc, wxList *text_list, | |
493 | double m_xpos, double m_ypos, double width, double height, | |
494 | int formatMode) | |
495 | { | |
496 | double xoffset, yoffset; | |
497 | if (formatMode & FORMAT_CENTRE_HORIZ) | |
498 | xoffset = m_xpos; | |
499 | else | |
500 | xoffset = (double)(m_xpos - (width / 2.0)); | |
501 | ||
502 | if (formatMode & FORMAT_CENTRE_VERT) | |
503 | yoffset = m_ypos; | |
504 | else | |
505 | yoffset = (double)(m_ypos - (height / 2.0)); | |
506 | ||
507 | dc.SetClippingRegion( | |
508 | (long)(m_xpos - width/2.0), (long)(m_ypos - height/2.0), | |
509 | (long)width, (long)height); | |
510 | ||
511 | wxNode *current = text_list->GetFirst(); | |
512 | while (current) | |
513 | { | |
514 | wxShapeTextLine *line = (wxShapeTextLine *)current->GetData(); | |
515 | ||
516 | dc.DrawText(line->GetText(), WXROUND(xoffset + line->GetX()), WXROUND(yoffset + line->GetY())); | |
517 | current = current->GetNext(); | |
518 | } | |
519 | ||
520 | dc.DestroyClippingRegion(); | |
521 | } | |
522 | ||
523 | /* | |
524 | * Find centroid given list of points comprising polyline | |
525 | * | |
526 | */ | |
527 | ||
528 | void oglFindPolylineCentroid(wxList *points, double *x, double *y) | |
529 | { | |
530 | double xcount = 0; | |
531 | double ycount = 0; | |
532 | ||
533 | wxNode *node = points->GetFirst(); | |
534 | while (node) | |
535 | { | |
536 | wxRealPoint *point = (wxRealPoint *)node->GetData(); | |
537 | xcount += point->x; | |
538 | ycount += point->y; | |
539 | node = node->GetNext(); | |
540 | } | |
541 | ||
542 | *x = (xcount/points->GetCount()); | |
543 | *y = (ycount/points->GetCount()); | |
544 | } | |
545 | ||
546 | /* | |
547 | * Check that (x1, y1) -> (x2, y2) hits (x3, y3) -> (x4, y4). | |
548 | * If so, ratio1 gives the proportion along the first line | |
549 | * that the intersection occurs (or something like that). | |
550 | * Used by functions below. | |
551 | * | |
552 | */ | |
553 | void oglCheckLineIntersection(double x1, double y1, double x2, double y2, | |
554 | double x3, double y3, double x4, double y4, | |
555 | double *ratio1, double *ratio2) | |
556 | { | |
557 | double denominator_term = (y4 - y3)*(x2 - x1) - (y2 - y1)*(x4 - x3); | |
558 | double numerator_term = (x3 - x1)*(y4 - y3) + (x4 - x3)*(y1 - y3); | |
559 | ||
560 | double line_constant; | |
561 | double length_ratio = 1.0; | |
562 | double k_line = 1.0; | |
563 | ||
564 | // Check for parallel lines | |
565 | if ((denominator_term < 0.005) && (denominator_term > -0.005)) | |
566 | line_constant = -1.0; | |
567 | else | |
568 | line_constant = numerator_term/denominator_term; | |
569 | ||
570 | // Check for intersection | |
571 | if ((line_constant < 1.0) && (line_constant > 0.0)) | |
572 | { | |
573 | // Now must check that other line hits | |
574 | if (((y4 - y3) < 0.005) && ((y4 - y3) > -0.005)) | |
575 | k_line = ((x1 - x3) + line_constant*(x2 - x1))/(x4 - x3); | |
576 | else | |
577 | k_line = ((y1 - y3) + line_constant*(y2 - y1))/(y4 - y3); | |
578 | ||
579 | if ((k_line >= 0.0) && (k_line < 1.0)) | |
580 | length_ratio = line_constant; | |
581 | else | |
582 | k_line = 1.0; | |
583 | } | |
584 | *ratio1 = length_ratio; | |
585 | *ratio2 = k_line; | |
586 | } | |
587 | ||
588 | /* | |
589 | * Find where (x1, y1) -> (x2, y2) hits one of the lines in xvec, yvec. | |
590 | * (*x3, *y3) is the point where it hits. | |
591 | * | |
592 | */ | |
593 | void oglFindEndForPolyline(double n, double xvec[], double yvec[], | |
594 | double x1, double y1, double x2, double y2, double *x3, double *y3) | |
595 | { | |
596 | int i; | |
597 | double lastx = xvec[0]; | |
598 | double lasty = yvec[0]; | |
599 | ||
600 | double min_ratio = 1.0; | |
601 | double line_ratio; | |
602 | double other_ratio; | |
603 | ||
604 | for (i = 1; i < n; i++) | |
605 | { | |
606 | oglCheckLineIntersection(x1, y1, x2, y2, lastx, lasty, xvec[i], yvec[i], | |
607 | &line_ratio, &other_ratio); | |
608 | lastx = xvec[i]; | |
609 | lasty = yvec[i]; | |
610 | ||
611 | if (line_ratio < min_ratio) | |
612 | min_ratio = line_ratio; | |
613 | } | |
614 | ||
615 | // Do last (implicit) line if last and first doubles are not identical | |
616 | if (!(xvec[0] == lastx && yvec[0] == lasty)) | |
617 | { | |
618 | oglCheckLineIntersection(x1, y1, x2, y2, lastx, lasty, xvec[0], yvec[0], | |
619 | &line_ratio, &other_ratio); | |
620 | ||
621 | if (line_ratio < min_ratio) | |
622 | min_ratio = line_ratio; | |
623 | } | |
624 | ||
625 | *x3 = (x1 + (x2 - x1)*min_ratio); | |
626 | *y3 = (y1 + (y2 - y1)*min_ratio); | |
627 | ||
628 | } | |
629 | ||
630 | /* | |
631 | * Find where the line hits the box. | |
632 | * | |
633 | */ | |
634 | ||
635 | void oglFindEndForBox(double width, double height, | |
636 | double x1, double y1, // Centre of box (possibly) | |
637 | double x2, double y2, // other end of line | |
638 | double *x3, double *y3) // End on box edge | |
639 | { | |
640 | double xvec[5]; | |
641 | double yvec[5]; | |
642 | ||
643 | xvec[0] = (double)(x1 - width/2.0); | |
644 | yvec[0] = (double)(y1 - height/2.0); | |
645 | xvec[1] = (double)(x1 - width/2.0); | |
646 | yvec[1] = (double)(y1 + height/2.0); | |
647 | xvec[2] = (double)(x1 + width/2.0); | |
648 | yvec[2] = (double)(y1 + height/2.0); | |
649 | xvec[3] = (double)(x1 + width/2.0); | |
650 | yvec[3] = (double)(y1 - height/2.0); | |
651 | xvec[4] = (double)(x1 - width/2.0); | |
652 | yvec[4] = (double)(y1 - height/2.0); | |
653 | ||
654 | oglFindEndForPolyline(5, xvec, yvec, x2, y2, x1, y1, x3, y3); | |
655 | } | |
656 | ||
657 | /* | |
658 | * Find where the line hits the circle. | |
659 | * | |
660 | */ | |
661 | ||
662 | void oglFindEndForCircle(double radius, | |
663 | double x1, double y1, // Centre of circle | |
664 | double x2, double y2, // Other end of line | |
665 | double *x3, double *y3) | |
666 | { | |
667 | double H = (double)sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1)); | |
668 | ||
669 | if (H == 0.0) | |
670 | { | |
671 | *x3 = x1; | |
672 | *y3 = y1; | |
673 | } | |
674 | else | |
675 | { | |
676 | *y3 = radius * (y2 - y1)/H + y1; | |
677 | *x3 = radius * (x2 - x1)/H + x1; | |
678 | } | |
679 | } | |
680 | ||
681 | /* | |
682 | * Given the line (x1, y1) -> (x2, y2), and an arrow size of given length and width, | |
683 | * return the position of the tip of the arrow and the left and right vertices of the arrow. | |
684 | * | |
685 | */ | |
686 | ||
687 | void oglGetArrowPoints(double x1, double y1, double x2, double y2, | |
688 | double length, double width, | |
689 | double *tip_x, double *tip_y, | |
690 | double *side1_x, double *side1_y, | |
691 | double *side2_x, double *side2_y) | |
692 | { | |
693 | double l = (double)sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1)); | |
694 | ||
695 | if (l < 0.01) | |
696 | l = (double) 0.01; | |
697 | ||
698 | double i_bar = (x2 - x1)/l; | |
699 | double j_bar = (y2 - y1)/l; | |
700 | ||
701 | double x3 = (- length*i_bar) + x2; | |
702 | double y3 = (- length*j_bar) + y2; | |
703 | ||
704 | *side1_x = width*(-j_bar) + x3; | |
705 | *side1_y = width*i_bar + y3; | |
706 | ||
707 | *side2_x = -width*(-j_bar) + x3; | |
708 | *side2_y = -width*i_bar + y3; | |
709 | ||
710 | *tip_x = x2; *tip_y = y2; | |
711 | } | |
712 | ||
713 | /* | |
714 | * Given an ellipse and endpoints of a line, returns the point at which | |
715 | * the line touches the ellipse in values x4, y4. | |
716 | * This function assumes that the centre of the ellipse is at x1, y1, and the | |
717 | * ellipse has a width of width1 and a height of height1. It also assumes you are | |
718 | * wanting to draw an arc FROM point x2, y2 TOWARDS point x3, y3. | |
719 | * This function calculates the x,y coordinates of the intersection point of | |
720 | * the arc with the ellipse. | |
721 | * Author: Ian Harrison | |
722 | */ | |
723 | ||
724 | void oglDrawArcToEllipse(double x1, double y1, double width1, double height1, double x2, double y2, double x3, double y3, | |
725 | double *x4, double *y4) | |
726 | { | |
727 | double a1 = (double)(width1/2.0); | |
728 | double b1 = (double)(height1/2.0); | |
729 | ||
730 | // These are required to give top left x and y coordinates for DrawEllipse | |
731 | // double top_left_x1 = (double)(x1 - a1); | |
732 | // double top_left_y1 = (double)(y1 - b1); | |
733 | /* | |
734 | // Check for vertical line | |
735 | if (fabs(x2 - x3) < 0.05) | |
736 | { | |
737 | *x4 = x3; | |
738 | if (y2 < y3) | |
739 | *y4 = (double)(y1 - b1); | |
740 | else | |
741 | *y4 = (double)(y1 + b1); | |
742 | return; | |
743 | } | |
744 | */ | |
745 | // Check that x2 != x3 | |
746 | if (fabs(x2 - x3) < 0.05) | |
747 | { | |
748 | *x4 = x2; | |
749 | if (y3 > y2) | |
750 | *y4 = (double)(y1 - sqrt((b1*b1 - (((x2-x1)*(x2-x1))*(b1*b1)/(a1*a1))))); | |
751 | else | |
752 | *y4 = (double)(y1 + sqrt((b1*b1 - (((x2-x1)*(x2-x1))*(b1*b1)/(a1*a1))))); | |
753 | return; | |
754 | } | |
755 | ||
756 | // Calculate the x and y coordinates of the point where arc intersects ellipse | |
757 | ||
758 | double A, B, C, D, E, F, G, H, K; | |
759 | double ellipse1_x, ellipse1_y; | |
760 | ||
761 | A = (double)(1/(a1 * a1)); | |
762 | B = (double)((y3 - y2) * (y3 - y2)) / ((x3 - x2) * (x3 - x2) * b1 * b1); | |
763 | C = (double)(2 * (y3 - y2) * (y2 - y1)) / ((x3 - x2) * b1 * b1); | |
764 | D = (double)((y2 - y1) * (y2 - y1)) / (b1 * b1); | |
765 | E = (double)(A + B); | |
766 | F = (double)(C - (2 * A * x1) - (2 * B * x2)); | |
767 | G = (double)((A * x1 * x1) + (B * x2 * x2) - (C * x2) + D - 1); | |
768 | H = (double)((y3 - y2) / (x3 - x2)); | |
769 | K = (double)((F * F) - (4 * E * G)); | |
770 | ||
771 | if (K >= 0) | |
772 | // In this case the line intersects the ellipse, so calculate intersection | |
773 | { | |
774 | if(x2 >= x1) | |
775 | { | |
776 | ellipse1_x = (double)(((F * -1) + sqrt(K)) / (2 * E)); | |
777 | ellipse1_y = (double)((H * (ellipse1_x - x2)) + y2); | |
778 | } | |
779 | else | |
780 | { | |
781 | ellipse1_x = (double)(((F * -1) - sqrt(K)) / (2 * E)); | |
782 | ellipse1_y = (double)((H * (ellipse1_x - x2)) + y2); | |
783 | } | |
784 | } | |
785 | else | |
786 | // in this case, arc does not intersect ellipse, so just draw arc | |
787 | { | |
788 | ellipse1_x = x3; | |
789 | ellipse1_y = y3; | |
790 | } | |
791 | *x4 = ellipse1_x; | |
792 | *y4 = ellipse1_y; | |
793 | ||
794 | /* | |
795 | // Draw a little circle (radius = 2) at the end of the arc where it hits | |
796 | // the ellipse . | |
797 | ||
798 | double circle_x = ellipse1_x - 2.0; | |
799 | double circle_y = ellipse1_y - 2.0; | |
800 | m_canvas->DrawEllipse(circle_x, circle_y, 4.0, 4.0); | |
801 | */ | |
802 | } | |
803 | ||
804 | // Update a list item from a list of strings | |
805 | void UpdateListBox(wxListBox *item, wxList *list) | |
806 | { | |
807 | item->Clear(); | |
808 | if (!list) | |
809 | return; | |
810 | ||
811 | wxNode *node = list->GetFirst(); | |
812 | while (node) | |
813 | { | |
814 | wxChar *s = (wxChar *)node->GetData(); | |
815 | item->Append(s); | |
816 | node = node->GetNext(); | |
817 | } | |
818 | } | |
819 | ||
820 | bool oglRoughlyEqual(double val1, double val2, double tol) | |
821 | { | |
822 | return ( (val1 < (val2 + tol)) && (val1 > (val2 - tol)) && | |
823 | (val2 < (val1 + tol)) && (val2 > (val1 - tol))); | |
824 | } | |
825 | ||
826 | /* | |
827 | * Hex<->Dec conversion | |
828 | */ | |
829 | ||
830 | // Array used in DecToHex conversion routine. | |
831 | static wxChar sg_HexArray[] = { wxT('0'), wxT('1'), wxT('2'), wxT('3'), | |
832 | wxT('4'), wxT('5'), wxT('6'), wxT('7'), | |
833 | wxT('8'), wxT('9'), wxT('A'), wxT('B'), | |
834 | wxT('C'), wxT('D'), wxT('E'), wxT('F') | |
835 | }; | |
836 | ||
837 | // Convert 2-digit hex number to decimal | |
838 | unsigned int oglHexToDec(wxChar* buf) | |
839 | { | |
840 | int firstDigit, secondDigit; | |
841 | ||
842 | if (buf[0] >= wxT('A')) | |
843 | firstDigit = buf[0] - wxT('A') + 10; | |
844 | else | |
845 | firstDigit = buf[0] - wxT('0'); | |
846 | ||
847 | if (buf[1] >= wxT('A')) | |
848 | secondDigit = buf[1] - wxT('A') + 10; | |
849 | else | |
850 | secondDigit = buf[1] - wxT('0'); | |
851 | ||
852 | return firstDigit * 16 + secondDigit; | |
853 | } | |
854 | ||
855 | // Convert decimal integer to 2-character hex string | |
856 | void oglDecToHex(unsigned int dec, wxChar *buf) | |
857 | { | |
858 | int firstDigit = (int)(dec/16.0); | |
859 | int secondDigit = (int)(dec - (firstDigit*16.0)); | |
860 | buf[0] = sg_HexArray[firstDigit]; | |
861 | buf[1] = sg_HexArray[secondDigit]; | |
862 | buf[2] = 0; | |
863 | } | |
864 | ||
865 | // 3-digit hex to wxColour | |
866 | wxColour oglHexToColour(const wxString& hex) | |
867 | { | |
868 | if (hex.Length() == 6) | |
869 | { | |
870 | long r, g, b; | |
871 | r = g = b = 0; | |
872 | hex.Mid(0,2).ToLong(&r, 16); | |
873 | hex.Mid(2,2).ToLong(&g, 16); | |
874 | hex.Mid(4,2).ToLong(&b, 16); | |
875 | return wxColour(r, g, b); | |
876 | } | |
877 | else | |
878 | return wxColour(0,0,0); | |
879 | } | |
880 | ||
881 | // RGB to 3-digit hex | |
882 | wxString oglColourToHex(const wxColour& colour) | |
883 | { | |
884 | wxChar buf[7]; | |
885 | unsigned int red = colour.Red(); | |
886 | unsigned int green = colour.Green(); | |
887 | unsigned int blue = colour.Blue(); | |
888 | ||
889 | oglDecToHex(red, buf); | |
890 | oglDecToHex(green, buf+2); | |
891 | oglDecToHex(blue, buf+4); | |
892 | ||
893 | return wxString(buf); | |
894 | } | |
895 | ||
896 |