]> git.saurik.com Git - wxWidgets.git/blob - contrib/src/ogl/oglmisc.cpp
Typos fixed and further clarification of the Python situation on Panther
[wxWidgets.git] / contrib / src / ogl / oglmisc.cpp
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(), &current_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(), &current_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 while (current)
364 {
365 wxShapeTextLine *line = (wxShapeTextLine *)current->GetData();
366 dc.GetTextExtent(line->GetText(), &current_width, &char_height);
367
368 if (current_width > max_width)
369 max_width = current_width;
370 current = current->GetNext();
371 }
372
373 *actual_height = n*char_height;
374 *actual_width = max_width;
375 }
376
377 // Format a string to a list of strings that fit in the given box.
378 // Interpret %n and 10 or 13 as a new line.
379 wxStringList *oglFormatText(wxDC& dc, const wxString& text, double width, double WXUNUSED(height), int formatMode)
380 {
381 // First, parse the string into a list of words
382 wxStringList word_list;
383
384 // Make new lines into NULL strings at this point
385 int i = 0; int j = 0; int len = text.Length();
386 wxChar word[200]; word[0] = 0;
387 bool end_word = FALSE; bool new_line = FALSE;
388 while (i < len)
389 {
390 switch (text[i])
391 {
392 case wxT('%'):
393 {
394 i ++;
395 if (i == len)
396 { word[j] = wxT('%'); j ++; }
397 else
398 {
399 if (text[i] == wxT('n'))
400 { new_line = TRUE; end_word = TRUE; i++; }
401 else
402 { word[j] = wxT('%'); j ++; word[j] = text[i]; j ++; i ++; }
403 }
404 break;
405 }
406 case 10:
407 {
408 new_line = TRUE; end_word = TRUE; i++;
409 break;
410 }
411 case 13:
412 {
413 new_line = TRUE; end_word = TRUE; i++;
414 break;
415 }
416 case wxT(' '):
417 {
418 end_word = TRUE;
419 i ++;
420 break;
421 }
422 default:
423 {
424 word[j] = text[i];
425 j ++; i ++;
426 break;
427 }
428 }
429 if (i == len) end_word = TRUE;
430 if (end_word)
431 {
432 word[j] = 0;
433 j = 0;
434 word_list.Add(word);
435 end_word = FALSE;
436 }
437 if (new_line)
438 {
439 word_list.Append(NULL);
440 new_line = FALSE;
441 }
442 }
443 // Now, make a list of strings which can fit in the box
444 wxStringList *string_list = new wxStringList;
445
446 wxString buffer;
447 wxStringListNode *node = word_list.GetFirst();
448 long x, y;
449
450 while (node)
451 {
452 wxString oldBuffer(buffer);
453
454 wxChar *s = (wxChar *)node->GetData();
455 if (!s)
456 {
457 // FORCE NEW LINE
458 if (buffer.Length() > 0)
459 string_list->Add(buffer);
460
461 buffer.Empty();
462 }
463 else
464 {
465 if (buffer.Length() != 0)
466 buffer += wxT(" ");
467
468 buffer += s;
469 dc.GetTextExtent(buffer, &x, &y);
470
471 // Don't fit within the bounding box if we're fitting shape to contents
472 if ((x > width) && !(formatMode & FORMAT_SIZE_TO_CONTENTS))
473 {
474 // Deal with first word being wider than box
475 if (oldBuffer.Length() > 0)
476 string_list->Add(oldBuffer);
477
478 buffer.Empty();
479 buffer += s;
480 }
481 }
482
483 node = node->GetNext();
484 }
485 if (buffer.Length() != 0)
486 string_list->Add(buffer);
487
488 return string_list;
489 }
490
491 void oglDrawFormattedText(wxDC& dc, wxList *text_list,
492 double m_xpos, double m_ypos, double width, double height,
493 int formatMode)
494 {
495 double xoffset, yoffset;
496 if (formatMode & FORMAT_CENTRE_HORIZ)
497 xoffset = m_xpos;
498 else
499 xoffset = (double)(m_xpos - (width / 2.0));
500
501 if (formatMode & FORMAT_CENTRE_VERT)
502 yoffset = m_ypos;
503 else
504 yoffset = (double)(m_ypos - (height / 2.0));
505
506 dc.SetClippingRegion(
507 (long)(m_xpos - width/2.0), (long)(m_ypos - height/2.0),
508 (long)width, (long)height);
509
510 wxNode *current = text_list->GetFirst();
511 while (current)
512 {
513 wxShapeTextLine *line = (wxShapeTextLine *)current->GetData();
514
515 dc.DrawText(line->GetText(), WXROUND(xoffset + line->GetX()), WXROUND(yoffset + line->GetY()));
516 current = current->GetNext();
517 }
518
519 dc.DestroyClippingRegion();
520 }
521
522 /*
523 * Find centroid given list of points comprising polyline
524 *
525 */
526
527 void oglFindPolylineCentroid(wxList *points, double *x, double *y)
528 {
529 double xcount = 0;
530 double ycount = 0;
531
532 wxNode *node = points->GetFirst();
533 while (node)
534 {
535 wxRealPoint *point = (wxRealPoint *)node->GetData();
536 xcount += point->x;
537 ycount += point->y;
538 node = node->GetNext();
539 }
540
541 *x = (xcount/points->GetCount());
542 *y = (ycount/points->GetCount());
543 }
544
545 /*
546 * Check that (x1, y1) -> (x2, y2) hits (x3, y3) -> (x4, y4).
547 * If so, ratio1 gives the proportion along the first line
548 * that the intersection occurs (or something like that).
549 * Used by functions below.
550 *
551 */
552 void oglCheckLineIntersection(double x1, double y1, double x2, double y2,
553 double x3, double y3, double x4, double y4,
554 double *ratio1, double *ratio2)
555 {
556 double denominator_term = (y4 - y3)*(x2 - x1) - (y2 - y1)*(x4 - x3);
557 double numerator_term = (x3 - x1)*(y4 - y3) + (x4 - x3)*(y1 - y3);
558
559 double line_constant;
560 double length_ratio = 1.0;
561 double k_line = 1.0;
562
563 // Check for parallel lines
564 if ((denominator_term < 0.005) && (denominator_term > -0.005))
565 line_constant = -1.0;
566 else
567 line_constant = numerator_term/denominator_term;
568
569 // Check for intersection
570 if ((line_constant < 1.0) && (line_constant > 0.0))
571 {
572 // Now must check that other line hits
573 if (((y4 - y3) < 0.005) && ((y4 - y3) > -0.005))
574 k_line = ((x1 - x3) + line_constant*(x2 - x1))/(x4 - x3);
575 else
576 k_line = ((y1 - y3) + line_constant*(y2 - y1))/(y4 - y3);
577
578 if ((k_line >= 0.0) && (k_line < 1.0))
579 length_ratio = line_constant;
580 else
581 k_line = 1.0;
582 }
583 *ratio1 = length_ratio;
584 *ratio2 = k_line;
585 }
586
587 /*
588 * Find where (x1, y1) -> (x2, y2) hits one of the lines in xvec, yvec.
589 * (*x3, *y3) is the point where it hits.
590 *
591 */
592 void oglFindEndForPolyline(double n, double xvec[], double yvec[],
593 double x1, double y1, double x2, double y2, double *x3, double *y3)
594 {
595 int i;
596 double lastx = xvec[0];
597 double lasty = yvec[0];
598
599 double min_ratio = 1.0;
600 double line_ratio;
601 double other_ratio;
602
603 for (i = 1; i < n; i++)
604 {
605 oglCheckLineIntersection(x1, y1, x2, y2, lastx, lasty, xvec[i], yvec[i],
606 &line_ratio, &other_ratio);
607 lastx = xvec[i];
608 lasty = yvec[i];
609
610 if (line_ratio < min_ratio)
611 min_ratio = line_ratio;
612 }
613
614 // Do last (implicit) line if last and first doubles are not identical
615 if (!(xvec[0] == lastx && yvec[0] == lasty))
616 {
617 oglCheckLineIntersection(x1, y1, x2, y2, lastx, lasty, xvec[0], yvec[0],
618 &line_ratio, &other_ratio);
619
620 if (line_ratio < min_ratio)
621 min_ratio = line_ratio;
622 }
623
624 *x3 = (x1 + (x2 - x1)*min_ratio);
625 *y3 = (y1 + (y2 - y1)*min_ratio);
626
627 }
628
629 /*
630 * Find where the line hits the box.
631 *
632 */
633
634 void oglFindEndForBox(double width, double height,
635 double x1, double y1, // Centre of box (possibly)
636 double x2, double y2, // other end of line
637 double *x3, double *y3) // End on box edge
638 {
639 double xvec[5];
640 double yvec[5];
641
642 xvec[0] = (double)(x1 - width/2.0);
643 yvec[0] = (double)(y1 - height/2.0);
644 xvec[1] = (double)(x1 - width/2.0);
645 yvec[1] = (double)(y1 + height/2.0);
646 xvec[2] = (double)(x1 + width/2.0);
647 yvec[2] = (double)(y1 + height/2.0);
648 xvec[3] = (double)(x1 + width/2.0);
649 yvec[3] = (double)(y1 - height/2.0);
650 xvec[4] = (double)(x1 - width/2.0);
651 yvec[4] = (double)(y1 - height/2.0);
652
653 oglFindEndForPolyline(5, xvec, yvec, x2, y2, x1, y1, x3, y3);
654 }
655
656 /*
657 * Find where the line hits the circle.
658 *
659 */
660
661 void oglFindEndForCircle(double radius,
662 double x1, double y1, // Centre of circle
663 double x2, double y2, // Other end of line
664 double *x3, double *y3)
665 {
666 double H = (double)sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1));
667
668 if (H == 0.0)
669 {
670 *x3 = x1;
671 *y3 = y1;
672 }
673 else
674 {
675 *y3 = radius * (y2 - y1)/H + y1;
676 *x3 = radius * (x2 - x1)/H + x1;
677 }
678 }
679
680 /*
681 * Given the line (x1, y1) -> (x2, y2), and an arrow size of given length and width,
682 * return the position of the tip of the arrow and the left and right vertices of the arrow.
683 *
684 */
685
686 void oglGetArrowPoints(double x1, double y1, double x2, double y2,
687 double length, double width,
688 double *tip_x, double *tip_y,
689 double *side1_x, double *side1_y,
690 double *side2_x, double *side2_y)
691 {
692 double l = (double)sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1));
693
694 if (l < 0.01)
695 l = (double) 0.01;
696
697 double i_bar = (x2 - x1)/l;
698 double j_bar = (y2 - y1)/l;
699
700 double x3 = (- length*i_bar) + x2;
701 double y3 = (- length*j_bar) + y2;
702
703 *side1_x = width*(-j_bar) + x3;
704 *side1_y = width*i_bar + y3;
705
706 *side2_x = -width*(-j_bar) + x3;
707 *side2_y = -width*i_bar + y3;
708
709 *tip_x = x2; *tip_y = y2;
710 }
711
712 /*
713 * Given an ellipse and endpoints of a line, returns the point at which
714 * the line touches the ellipse in values x4, y4.
715 * This function assumes that the centre of the ellipse is at x1, y1, and the
716 * ellipse has a width of width1 and a height of height1. It also assumes you are
717 * wanting to draw an arc FROM point x2, y2 TOWARDS point x3, y3.
718 * This function calculates the x,y coordinates of the intersection point of
719 * the arc with the ellipse.
720 * Author: Ian Harrison
721 */
722
723 void oglDrawArcToEllipse(double x1, double y1, double width1, double height1, double x2, double y2, double x3, double y3,
724 double *x4, double *y4)
725 {
726 double a1 = (double)(width1/2.0);
727 double b1 = (double)(height1/2.0);
728
729 // These are required to give top left x and y coordinates for DrawEllipse
730 // double top_left_x1 = (double)(x1 - a1);
731 // double top_left_y1 = (double)(y1 - b1);
732 /*
733 // Check for vertical line
734 if (fabs(x2 - x3) < 0.05)
735 {
736 *x4 = x3;
737 if (y2 < y3)
738 *y4 = (double)(y1 - b1);
739 else
740 *y4 = (double)(y1 + b1);
741 return;
742 }
743 */
744 // Check that x2 != x3
745 if (fabs(x2 - x3) < 0.05)
746 {
747 *x4 = x2;
748 if (y3 > y2)
749 *y4 = (double)(y1 - sqrt((b1*b1 - (((x2-x1)*(x2-x1))*(b1*b1)/(a1*a1)))));
750 else
751 *y4 = (double)(y1 + sqrt((b1*b1 - (((x2-x1)*(x2-x1))*(b1*b1)/(a1*a1)))));
752 return;
753 }
754
755 // Calculate the x and y coordinates of the point where arc intersects ellipse
756
757 double A, B, C, D, E, F, G, H, K;
758 double ellipse1_x, ellipse1_y;
759
760 A = (double)(1/(a1 * a1));
761 B = (double)((y3 - y2) * (y3 - y2)) / ((x3 - x2) * (x3 - x2) * b1 * b1);
762 C = (double)(2 * (y3 - y2) * (y2 - y1)) / ((x3 - x2) * b1 * b1);
763 D = (double)((y2 - y1) * (y2 - y1)) / (b1 * b1);
764 E = (double)(A + B);
765 F = (double)(C - (2 * A * x1) - (2 * B * x2));
766 G = (double)((A * x1 * x1) + (B * x2 * x2) - (C * x2) + D - 1);
767 H = (double)((y3 - y2) / (x3 - x2));
768 K = (double)((F * F) - (4 * E * G));
769
770 if (K >= 0)
771 // In this case the line intersects the ellipse, so calculate intersection
772 {
773 if(x2 >= x1)
774 {
775 ellipse1_x = (double)(((F * -1) + sqrt(K)) / (2 * E));
776 ellipse1_y = (double)((H * (ellipse1_x - x2)) + y2);
777 }
778 else
779 {
780 ellipse1_x = (double)(((F * -1) - sqrt(K)) / (2 * E));
781 ellipse1_y = (double)((H * (ellipse1_x - x2)) + y2);
782 }
783 }
784 else
785 // in this case, arc does not intersect ellipse, so just draw arc
786 {
787 ellipse1_x = x3;
788 ellipse1_y = y3;
789 }
790 *x4 = ellipse1_x;
791 *y4 = ellipse1_y;
792
793 /*
794 // Draw a little circle (radius = 2) at the end of the arc where it hits
795 // the ellipse .
796
797 double circle_x = ellipse1_x - 2.0;
798 double circle_y = ellipse1_y - 2.0;
799 m_canvas->DrawEllipse(circle_x, circle_y, 4.0, 4.0);
800 */
801 }
802
803 // Update a list item from a list of strings
804 void UpdateListBox(wxListBox *item, wxList *list)
805 {
806 item->Clear();
807 if (!list)
808 return;
809
810 wxNode *node = list->GetFirst();
811 while (node)
812 {
813 wxChar *s = (wxChar *)node->GetData();
814 item->Append(s);
815 node = node->GetNext();
816 }
817 }
818
819 bool oglRoughlyEqual(double val1, double val2, double tol)
820 {
821 return ( (val1 < (val2 + tol)) && (val1 > (val2 - tol)) &&
822 (val2 < (val1 + tol)) && (val2 > (val1 - tol)));
823 }
824
825 /*
826 * Hex<->Dec conversion
827 */
828
829 // Array used in DecToHex conversion routine.
830 static wxChar sg_HexArray[] = { wxT('0'), wxT('1'), wxT('2'), wxT('3'),
831 wxT('4'), wxT('5'), wxT('6'), wxT('7'),
832 wxT('8'), wxT('9'), wxT('A'), wxT('B'),
833 wxT('C'), wxT('D'), wxT('E'), wxT('F')
834 };
835
836 // Convert 2-digit hex number to decimal
837 unsigned int oglHexToDec(wxChar* buf)
838 {
839 int firstDigit, secondDigit;
840
841 if (buf[0] >= wxT('A'))
842 firstDigit = buf[0] - wxT('A') + 10;
843 else
844 firstDigit = buf[0] - wxT('0');
845
846 if (buf[1] >= wxT('A'))
847 secondDigit = buf[1] - wxT('A') + 10;
848 else
849 secondDigit = buf[1] - wxT('0');
850
851 return firstDigit * 16 + secondDigit;
852 }
853
854 // Convert decimal integer to 2-character hex string
855 void oglDecToHex(unsigned int dec, wxChar *buf)
856 {
857 int firstDigit = (int)(dec/16.0);
858 int secondDigit = (int)(dec - (firstDigit*16.0));
859 buf[0] = sg_HexArray[firstDigit];
860 buf[1] = sg_HexArray[secondDigit];
861 buf[2] = 0;
862 }
863
864 // 3-digit hex to wxColour
865 wxColour oglHexToColour(const wxString& hex)
866 {
867 if (hex.Length() == 6)
868 {
869 long r, g, b;
870 r = g = b = 0;
871 hex.Mid(0,2).ToLong(&r, 16);
872 hex.Mid(2,2).ToLong(&g, 16);
873 hex.Mid(4,2).ToLong(&b, 16);
874 return wxColour(r, g, b);
875 }
876 else
877 return wxColour(0,0,0);
878 }
879
880 // RGB to 3-digit hex
881 wxString oglColourToHex(const wxColour& colour)
882 {
883 wxChar buf[7];
884 unsigned int red = colour.Red();
885 unsigned int green = colour.Green();
886 unsigned int blue = colour.Blue();
887
888 oglDecToHex(red, buf);
889 oglDecToHex(green, buf+2);
890 oglDecToHex(blue, buf+4);
891
892 return wxString(buf);
893 }
894
895