Debian Codegraph @

libctgraphics/sgp.cpp

raw
1 /*****************************************************************************
2 ** FILE IDENTIFICATION
3 **
4 ** Name: sgp.cpp Simple Graphics Package
5 ** Programmer: Kevin Rosenberg
6 **
7 ** This is part of the CTSim program
8 ** Copyright (c) 1983-2009 Kevin Rosenberg
9 **
10 ** This program is free software; you can redistribute it and/or modify
11 ** it under the terms of the GNU General Public License (version 2) as
12 ** published by the Free Software Foundation.
13 **
14 ** This program is distributed in the hope that it will be useful,
15 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 ** GNU General Public License for more details.
18 **
19 ** You should have received a copy of the GNU General Public License
20 ** along with this program; if not, write to the Free Software
21 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 ******************************************************************************/
23
24 #include <stdio.h>
25 #include <math.h>
26 #include "ctsupport.h"
27 #include "sgp.h"
28
29
30 SGP_RGBColor SGP::s_aRGBColor[] =
31 {
32 SGP_RGBColor (0, 0, 0),
33 SGP_RGBColor (0, 0, 128),
34 SGP_RGBColor (0, 128, 0),
35 SGP_RGBColor (0, 128, 128),
36 SGP_RGBColor (128, 0, 0),
37 SGP_RGBColor (128, 0, 128),
38 SGP_RGBColor (128, 128, 0),
39 SGP_RGBColor (80, 80, 80),
40 SGP_RGBColor (160, 160, 160),
41 SGP_RGBColor (0, 0, 255),
42 SGP_RGBColor (0, 255, 0),
43 SGP_RGBColor (0, 255, 255),
44 SGP_RGBColor (255, 0, 0),
45 SGP_RGBColor (255, 0, 255),
46 SGP_RGBColor (255, 255, 0),
47 SGP_RGBColor (255, 255, 255),
48 };
49
50 int SGP::s_iRGBColorCount = sizeof(s_aRGBColor) / sizeof(class SGP_RGBColor);
51
52 #ifdef HAVE_WXWINDOWS
53 SGPDriver::SGPDriver (wxDC* pDC, int xsize, int ysize)
54 : m_iPhysicalXSize(xsize), m_iPhysicalYSize(ysize), m_idDriver(0), m_pDC(pDC)
55 {
56 m_idDriver |= SGPDRIVER_WXWINDOWS;
57 }
58 #endif
59
60 SGPDriver::SGPDriver (const char* szWinTitle, int xsize, int ysize)
61 : m_iPhysicalXSize(xsize), m_iPhysicalYSize(ysize), m_sWindowTitle(szWinTitle), m_idDriver(0)
62 {
63 #ifdef HAVE_G2_H
64 m_idG2 = g2_open_X11X (m_iPhysicalXSize, m_iPhysicalYSize, 10, 10, const_cast<char*>(szWinTitle), const_cast<char*>(szWinTitle), NULL, -1, -1);
65 m_idDriver |= SGPDRIVER_G2;
66 #endif
67 }
68
69 SGPDriver::~SGPDriver ()
70 {
71 #if HAVE_G2_H
72 if (isG2())
73 g2_close (m_idG2);
74 #endif
75 }
76
77
78 // NAME
79 // SGP::SGP Constructor for Simple Graphics Package
80
81 SGP::SGP (const SGPDriver& driver)
82 : m_driver (driver)
83 {
84 m_iPhysicalXSize = m_driver.getPhysicalXSize();
85 m_iPhysicalYSize = m_driver.getPhysicalYSize();
86
87 wc_to_ndc.setIdentity ();
88 mc_to_ndc.setIdentity();
89 ndc_to_mc.setIdentity();
90 m_ctm.setIdentity();
91
92 #ifdef HAVE_WXWINDOWS
93 initFromDC (driver.idWX());
94 #endif
95
96 setWindow (0., 0., 1., 1.);
97 setViewport (0., 0., 1., 1.);
98 moveAbs (0., 0.);
99 stylusNDC (0., 0., false);
100
101 setTextAngle (0.);
102 setTextPointSize (8);
103 setColor (C_BLACK);
104 setLineStyle (LS_SOLID);
105 setMarker (MARKER_POINT);
106 }
107
108
109 #ifdef HAVE_WXWINDOWS
110 void
111 SGP::initFromDC (wxDC* pDC)
112 {
113 m_pen.SetWidth (1);
114
115 if (m_driver.isWX()) {
116 static const double dScreenDPI = 82;
117 static const double dPointsPerInch = 72.;
118 m_dPointsPerPixel = dPointsPerInch / dScreenDPI;
119 const int iTestPointSize = 12;
120 m_pFont = new wxFont (iTestPointSize, wxFONTFAMILY_ROMAN,
121 wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
122 #ifdef MSVC
123 m_pFont->SetFaceName(wxString("times new roman"));
124 #endif
125 m_driver.idWX()->SetFont (*m_pFont);
126 double dTestCharHeight = m_driver.idWX()->GetCharHeight();
127 m_dPointsPerPixel = iTestPointSize / dTestCharHeight;
128 m_driver.idWX()->SetBackground (*wxWHITE_BRUSH);
129 }
130 }
131 #endif
132
133
134 SGP::~SGP()
135 {
136 #if HAVE_WXWINDOWS
137 if (m_driver.isWX()) {
138 // m_driver.idWX()->SetFont (wxNullFont);
139 delete m_pFont;
140 }
141 #endif
142 }
143
144 void
145 SGP::stylusNDC (double x, double y, bool beam)
146 {
147 int xp = static_cast<int>(x * (m_iPhysicalXSize - 1) + 0.5);
148 int yp = static_cast<int>(y * (m_iPhysicalYSize - 1) + 0.5);
149 if (m_driver.isWX())
150 yp = m_iPhysicalYSize - yp;
151
152 if (beam) {
153 #if HAVE_WXWINDOWS
154 if (m_driver.isWX())
155 m_driver.idWX()->DrawLine (m_iCurrentPhysicalX, m_iCurrentPhysicalY, xp, yp);
156 #endif
157 #if HAVE_G2_H
158 if (m_driver.isG2())
159 g2_line (m_driver.idG2(), m_iCurrentPhysicalX, m_iCurrentPhysicalY, xp, yp);
160 #endif
161 }
162 m_iCurrentPhysicalX = xp;
163 m_iCurrentPhysicalY = yp;
164 }
165
166 void
167 SGP::markerNDC (double x, double y)
168 {
169 int xp = static_cast<int>(x * (m_iPhysicalXSize - 1) + 0.5);
170 int yp = static_cast<int>(y * (m_iPhysicalYSize - 1) + 0.5);
171 if (m_driver.isWX())
172 yp = m_iPhysicalYSize - yp;
173
174 #if HAVE_WXWINDOWS
175 if (m_driver.isWX()) {
176 m_driver.idWX()->DrawPoint (xp, yp);
177 m_driver.idWX()->DrawPoint (xp-1, yp-1);
178 m_driver.idWX()->DrawPoint (xp+1, yp+1);
179 m_driver.idWX()->DrawPoint (xp+1, yp-1);
180 m_driver.idWX()->DrawPoint (xp-1, yp+1);
181 }
182 #endif
183 m_iCurrentPhysicalX = xp;
184 m_iCurrentPhysicalY = yp;
185 }
186
187 void
188 SGP::pointNDC (double x, double y)
189 {
190 int xp = static_cast<int>(x * (m_iPhysicalXSize - 1) + 0.5);
191 int yp = static_cast<int>(y * (m_iPhysicalYSize - 1) + 0.5);
192 if (m_driver.isWX())
193 yp = m_iPhysicalYSize - yp;
194
195 #if HAVE_WXWINDOWS
196 if (m_driver.isWX())
197 m_driver.idWX()->DrawPoint (xp, yp);
198 #endif
199 m_iCurrentPhysicalX = xp;
200 m_iCurrentPhysicalY = yp;
201 }
202
203
204 // NAME
205 // clear Clear Window
206
207 void
208 SGP::eraseWindow ()
209 {
210 #if HAVE_G2_H
211 if (m_driver.isG2())
212 g2_clear (m_driver.idG2());
213 #endif
214 #if HAVE_WXWINDOWS
215 if (m_driver.isWX()) {
216 wxBrush brushWhite;
217 brushWhite.SetColour(255,255,255);
218 m_driver.idWX()->SetBackground(brushWhite);
219 m_driver.idWX()->Clear();
220 m_driver.idWX()->SetBackground(wxNullBrush);
221 #if 1
222 wxPen pen;
223 pen.SetColour(255,255,255);
224 m_driver.idWX()->SetBrush (brushWhite);
225 m_driver.idWX()->DrawRectangle (0, 0, m_iPhysicalXSize, m_iPhysicalYSize);
226 m_driver.idWX()->SetBrush (wxNullBrush);
227 #endif
228 }
229 #endif
230 }
231
232 // NAME
233 // sgp2_window Set window in world coordinates
234
235
236 void
237 SGP::setWindow (double xmin, double ymin, double xmax, double ymax)
238 {
239 if (xmin >= xmax || ymin >= ymax) {
240 sys_error (ERR_WARNING, "Minimum > Maximum [sgp2_window]");
241 return;
242 }
243
244 xw_min = xmin;
245 yw_min = ymin;
246 xw_max = xmax;
247 yw_max = ymax;
248 m_bRecalcTransform = true;
249 }
250
251
252 // NAME
253 // sgp2_viewport Set viewport in NDC
254
255 void
256 SGP::setViewport (double xmin, double ymin, double xmax, double ymax)
257 {
258 if (xmin >= xmax || ymin >= ymax) {
259 sys_error (ERR_WARNING, "Minimum > Maximum [sgp2_viewport]");
260 return;
261 }
262
263 xv_min = xmin;
264 yv_min = ymin;
265 xv_max = xmax;
266 yv_max = ymax;
267 m_bRecalcTransform = true;
268
269 viewNDC[0] = xmin; // Array for clip_rect()
270 viewNDC[1] = ymin;
271 viewNDC[2] = xmax;
272 viewNDC[3] = ymax;
273 }
274
275 void
276 SGP::getViewport (double& xmin, double& ymin, double& xmax, double& ymax)
277 {
278 xmin = xv_min;
279 ymin = yv_min;
280 xmax = xv_max;
281 ymax = yv_max;
282 }
283
284 void
285 SGP::getWindow (double& xmin, double& ymin, double& xmax, double& ymax)
286 {
287 xmin = xw_min;
288 ymin = yw_min;
289 xmax = xw_max;
290 ymax = yw_max;
291 }
292
293
294 // NAME
295 // frameViewport draw box around viewport
296
297 void
298 SGP::frameViewport (void)
299 {
300 stylusNDC (xv_min, yv_min, false);
301 stylusNDC (xv_max, yv_min, true);
302 stylusNDC (xv_max, yv_max, true);
303 stylusNDC (xv_min, yv_max, true);
304 stylusNDC (xv_min, yv_min, true);
305 }
306
307 void
308 SGP::setTextColor (int iFGcolor, int iBGcolor)
309 {
310 #if HAVE_WXWINDOWS
311 if (m_driver.isWX()) {
312 if (iFGcolor >= 0) {
313 wxColor colour (s_aRGBColor[iFGcolor].getRed(), s_aRGBColor[iFGcolor].getGreen(), s_aRGBColor[iFGcolor].getBlue());
314 m_driver.idWX()->SetTextForeground (colour);
315 }
316 if (iBGcolor >= 0) {
317 wxColor colour (s_aRGBColor[iBGcolor].getRed(), s_aRGBColor[iBGcolor].getGreen(), s_aRGBColor[iBGcolor].getBlue());
318 m_driver.idWX()->SetTextBackground (colour);
319 }
320 }
321 #endif
322 }
323
324 void
325 SGP::setColor (int icol)
326 {
327 if (icol >= 0 && icol < s_iRGBColorCount) {
328 #if HAVE_G2_H
329 if (m_driver.isG2()) {
330 int iInk = g2_ink (m_driver.idG2(), s_aRGBColor[icol].getRed() / 255., s_aRGBColor[icol].getGreen() / 255., s_aRGBColor[icol].getBlue() / 255.);
331 g2_pen (m_driver.idG2(), iInk);
332 }
333 #endif
334 #if HAVE_WXWINDOWS
335 if (m_driver.isWX()) {
336 wxColor colour (s_aRGBColor[icol].getRed(), s_aRGBColor[icol].getGreen(), s_aRGBColor[icol].getBlue());
337 m_pen.SetColour (colour);
338 m_driver.idWX()->SetPen (m_pen);
339 }
340 #endif
341 }
342 }
343
344 void
345 SGP::setPenWidth (int iWidth)
346 {
347 if (iWidth >= 0) {
348 #if HAVE_WXWINDOWS
349 if (m_driver.isWX()) {
350 m_pen.SetWidth (iWidth);
351 m_driver.idWX()->SetPen (m_pen);
352 }
353 #endif
354 }
355 }
356
357 void
358 SGP::setRasterOp (int ro)
359 {
360 #if HAVE_WXWINDOWS
361 if (m_driver.isWX()) {
362 wxRasterOperationMode wxFxn;
363 switch (ro) {
364 case RO_AND:
365 wxFxn = wxAND;
366 break;
367 case RO_AND_INVERT:
368 wxFxn = wxAND_INVERT;
369 break;
370 case RO_AND_REVERSE:
371 wxFxn = wxAND_REVERSE;
372 break;
373 case RO_CLEAR:
374 wxFxn = wxCLEAR;
375 break;
376 case RO_COPY:
377 wxFxn = wxCOPY;
378 break;
379 case RO_EQUIV:
380 wxFxn = wxEQUIV;
381 break;
382 case RO_INVERT:
383 wxFxn = wxINVERT;
384 break;
385 case RO_NAND:
386 wxFxn = wxNAND;
387 break;
388 case RO_NOR:
389 wxFxn = wxNOR;
390 break;
391 case RO_NO_OP:
392 wxFxn = wxNO_OP;
393 break;
394 case RO_OR:
395 wxFxn = wxOR;
396 break;
397 case RO_OR_INVERT:
398 wxFxn = wxOR_INVERT;
399 break;
400 case RO_OR_REVERSE:
401 wxFxn = wxOR_REVERSE;
402 break;
403 case RO_SET:
404 wxFxn = wxSET;
405 break;
406 case RO_SRC_INVERT:
407 wxFxn = wxSRC_INVERT;
408 break;
409 case RO_XOR:
410 wxFxn = wxXOR;
411 break;
412 default:
413 return;
414 }
415 m_driver.idWX()->SetLogicalFunction (wxFxn);
416 }
417 #endif
418 }
419
420
421 void
422 SGP::setMarker (int idMarker)
423 {
424 m_iMarker = idMarker;
425 }
426
427 //==============================================================
428 // set line style. Pass 16 bit repeating pattern
429 //==============================================================
430 void
431 SGP::setLineStyle (int style)
432 {
433 m_iLinestyle = style;
434
435 #if HAVE_WXWINDOWS
436 if (m_driver.isWX()) {
437 switch (m_iLinestyle) {
438 case LS_SOLID:
439 m_pen.SetStyle (wxSOLID);
440 break;
441 case LS_DASH1:
442 m_pen.SetStyle (wxLONG_DASH);
443 break;
444 case LS_DASH2:
445 m_pen.SetStyle (wxSHORT_DASH);
446 break;
447 case LS_DASH3:
448 m_pen.SetStyle (wxDOT_DASH);
449 break;
450 case LS_DASH4:
451 m_pen.SetStyle (wxCROSS_HATCH);
452 break;
453 case LS_DOTTED:
454 m_pen.SetStyle (wxDOT);
455 break;
456 default:
457 m_pen.SetStyle (wxSOLID);
458 break;
459 }
460 m_driver.idWX()->SetPen (m_pen);
461 }
462 #endif
463 }
464
465 //==============================================================
466 // absolute draw to
467 //*==============================================================
468
469 void
470 SGP::lineAbs (double x, double y)
471 {
472 if (m_bRecalcTransform)
473 calc_transform();
474
475 double x1 = m_dCurrentWorldX;
476 double y1 = m_dCurrentWorldY;
477 mc_to_ndc.transformPoint (&x1, &y1);
478
479 double x2 = x;
480 double y2 = y;
481 mc_to_ndc.transformPoint (&x2, &y2);
482
483 if (clip_rect (x1, y1, x2, y2, viewNDC) == true) { // clip to viewport
484 stylusNDC (x1, y1, false); // move to first point
485 stylusNDC (x2, y2, true); // draw to second point
486 }
487
488 m_dCurrentWorldX = x;
489 m_dCurrentWorldY = y;
490 }
491
492 void
493 SGP::moveAbs (double x, double y)
494 {
495 m_dCurrentWorldX = x;
496 m_dCurrentWorldY = y; /* moves are not clipped */
497 }
498
499 void
500 SGP::lineRel (double x, double y)
501 {
502 lineAbs (x + m_dCurrentWorldX, y + m_dCurrentWorldY);
503 }
504
505 void
506 SGP::moveRel (double x, double y)
507 {
508 moveAbs (x + m_dCurrentWorldX, y + m_dCurrentWorldY);
509 }
510
511
512 // Height is in master coordinates
513 void
514 SGP::setTextSize (double height)
515 {
516 height /= (yw_max - yw_min); // convert to NDC
517 #if HAVE_G2_H
518 if (m_driver.isG2())
519 g2_set_font_size(m_driver.idG2(), (height * m_iPhysicalYSize));
520 #endif
521 #if HAVE_WXWINDOWS
522 if (m_driver.isWX()) {
523 double dHeightPixels = height * m_iPhysicalYSize;
524 double dHeightPoints = dHeightPixels * m_dPointsPerPixel;
525 m_pFont->SetPointSize (nearest<int>(dHeightPoints));
526 #if DEBUG
527 sys_error (ERR_TRACE, "Setting text size to %d points",
528 nearest<int>(dHeightPoints));
529 #endif
530
531 m_driver.idWX()->SetFont (*m_pFont);
532 }
533 #endif
534 }
535
536 void
537 SGP::setTextNDCSize (double height)
538 {
539 double dHeightPixels = height * m_iPhysicalYSize;
540 #if HAVE_G2_H
541 if (m_driver.isG2())
542 g2_set_font_size(m_driver.idG2(), nearest<int>(dHeightPixels));
543 #endif
544 #if HAVE_WXWINDOWS
545 if (m_driver.isWX()) {
546 double dHeightPoints = dHeightPixels * m_dPointsPerPixel;
547 m_pFont->SetPointSize (nearest<int>(dHeightPoints));
548 m_driver.idWX()->SetFont (*m_pFont);
549 }
550 #endif
551 }
552
553 void
554 SGP::setTextPointSize (double height)
555 {
556 #if HAVE_G2_H
557 // if (m_driver.isG2())
558 // g2_set_font_size(m_driver.idG2(), (height * m_iPhysicalYSize));
559 #endif
560 #if HAVE_WXWINDOWS
561 if (m_driver.isWX()) {
562 m_iTextPointSize = static_cast<int>(height+0.5);
563 m_pFont->SetPointSize (m_iTextPointSize);
564 #if DEBUG
565 sys_error (ERR_TRACE, "Setting point size to %d", m_iTextPointSize);
566 #endif
567 m_driver.idWX()->SetFont (*m_pFont);
568 }
569 #endif
570 }
571
572 void
573 SGP::getTextExtent (const char* szText, double* worldW, double* worldH)
574 {
575 #if HAVE_WXWINDOWS
576 if (m_driver.isWX()) {
577 wxCoord deviceW, deviceH;
578 wxString str (wxConvCurrent->cMB2WC(szText));
579 m_driver.idWX()->GetTextExtent (str, &deviceW, &deviceH);
580 if (m_dTextAngle == 90 || m_dTextAngle == -90) {
581 wxCoord temp = deviceW;
582 deviceW = deviceH;
583 deviceH = temp;
584 }
585 *worldW = (xw_max - xw_min) * deviceW / static_cast<double>(m_iPhysicalXSize);;
586 *worldH = (yw_max - yw_min) * deviceH / static_cast<double>(m_iPhysicalYSize);
587 }
588 #endif
589 }
590
591 double
592 SGP::getCharHeight ()
593 {
594 double dHeight = (1. / 50.);
595
596 #if HAVE_WXWINDOWS
597 if (m_driver.isWX()) {
598 dHeight = m_driver.idWX()->GetCharHeight();
599 dHeight /= static_cast<double>(m_iPhysicalYSize);
600 dHeight /= (yv_max - yv_min); // scale to viewport;
601 }
602 #endif
603 dHeight *= (yw_max - yw_min); // scale to world coordinates
604 return dHeight;
605 }
606
607 double
608 SGP::getCharWidth ()
609 {
610 double dWidth = (1. / 80.);
611
612 #if HAVE_WXWINDOWS
613 if (m_driver.isWX()) {
614 dWidth = m_driver.idWX()->GetCharWidth();
615 dWidth /= static_cast<double>(m_iPhysicalXSize);
616 dWidth /= (xv_max - xv_min); // scale to viewport
617 }
618 #endif
619 dWidth *= (xw_max - xw_min); //scale to world coordinates
620 return dWidth;
621 }
622
623 void
624 SGP::setTextAngle (double angle)
625 {
626 m_dTextAngle = convertRadiansToDegrees(angle);
627 }
628
629 void
630 SGP::polylineAbs (double x[], double y[], int n)
631 {
632 if (m_bRecalcTransform)
633 calc_transform();
634
635 double x1 = x[0], y1 = y[0];
636 mc_to_ndc.transformPoint (&x1, &y1);
637 double x2 = x[1], y2 = y[1];
638 mc_to_ndc.transformPoint (&x2, &y2);
639
640 double xt = x2; // don't pass (x2,y2) to clip, we need them
641 double yt = y2; // as the beginning point of the next line
642
643 if (clip_rect (x1, y1, xt, yt, viewNDC)) {
644 stylusNDC (x1, y1, false);
645 stylusNDC (xt, yt, true);
646 }
647
648 for (int i = 2; i < n; i++) {
649 x1 = x2; y1 = y2; // NDC endpoint of last line
650 x2 = x[i]; y2 = y[i];
651 mc_to_ndc.transformPoint (&x2, &y2);
652 xt = x2;
653 yt = y2;
654 if (clip_rect (x1, y1, xt, yt, viewNDC)) {
655 stylusNDC (x1, y1, false);
656 stylusNDC (xt, yt, true);
657 }
658 }
659 }
660
661
662 void
663 SGP::markerAbs (double x, double y)
664 {
665 if (m_bRecalcTransform)
666 calc_transform();
667
668 double xndc = x;
669 double yndc = y;
670 mc_to_ndc.transformPoint (&xndc, &yndc);
671 markerNDC (xndc, yndc);
672 m_dCurrentWorldX = x;
673 m_dCurrentWorldY = y;
674 }
675
676
677 void
678 SGP::markerRel (double x, double y)
679 {
680 markerAbs (x + m_dCurrentWorldX, y + m_dCurrentWorldY);
681 }
682
683
684 void
685 SGP::pointAbs (double x, double y)
686 {
687 if (m_bRecalcTransform)
688 calc_transform();
689 double xndc = x, yndc = y;
690 mc_to_ndc.transformPoint (&xndc, &yndc);
691 pointNDC (xndc, yndc);
692 m_dCurrentWorldX = x;
693 m_dCurrentWorldY = y;
694 }
695
696
697 void
698 SGP::pointRel (double x, double y)
699 {
700 pointAbs (x + m_dCurrentWorldX, y + m_dCurrentWorldY);
701 }
702
703
704 void
705 SGP::drawText (const std::string& rsMessage)
706 {
707 drawText (rsMessage.c_str());
708 }
709
710 void
711 SGP::drawText (const char *pszMessage)
712 {
713 if (m_bRecalcTransform)
714 calc_transform();
715
716 double xndc = m_dCurrentWorldX;
717 double yndc = m_dCurrentWorldY;
718 mc_to_ndc.transformPoint (&xndc, &yndc);
719
720 stylusNDC (xndc, yndc, false); // move to location
721
722 #if HAVE_G2_H
723 if (m_driver.isG2()) {
724 g2_string (m_driver.idG2(), m_iCurrentPhysicalX, m_iCurrentPhysicalY, const_cast<char*>(pszMessage));
725 }
726 #endif
727 #if HAVE_WXWINDOWS
728 if (m_driver.isWX()) {
729 wxString str(wxConvCurrent->cMB2WC(pszMessage));
730 m_driver.idWX()->DrawRotatedText (str, m_iCurrentPhysicalX, m_iCurrentPhysicalY, m_dTextAngle);
731 }
732 #endif
733 }
734
735
736 // NAME
737 // drawRect Draw box in graphics mode
738 //
739 // SYNOPSIS
740 // drawbox (xmin, ymin, xmax, ymax)
741 // double xmin, ymin Lower left corner of box
742 // double xmax, ymax Upper left corner of box
743 //
744 // NOTES
745 // This routine leaves the current position of graphic cursor at lower
746 // left corner of box.
747
748 void
749 SGP::drawRect (double xmin, double ymin, double xmax, double ymax)
750 {
751 moveAbs (xmin, ymin);
752 lineAbs (xmax, ymin);
753 lineAbs (xmax, ymax);
754 lineAbs (xmin, ymax);
755 lineAbs (xmin, ymin);
756 }
757
758 // FUNCTION
759 // sgp2_circle - draw circle of radius r at current center
760
761 void
762 SGP::drawCircle (const double r)
763 {
764 drawArc (r, 0.0, TWOPI);
765 }
766
767 //==============================================================
768 // draw arc around current center. angles in radius
769 //==============================================================
770
771 void
772 SGP::drawArc (const double r, double start, double stop)
773 {
774 if (start > stop) {
775 double temp = start;
776 start = stop;
777 stop = temp;
778 }
779
780 double xCent = m_dCurrentWorldX;
781 double yCent = m_dCurrentWorldY;
782
783 double x = r * cos (start);
784 double y = r * sin (start);
785 moveAbs (xCent + x, yCent + y); // move from center to start of arc
786
787 const double thetaIncrement = (5 * (TWOPI / 360)); // 5 degree increments
788 double cosTheta = cos (thetaIncrement);
789 double sinTheta = sin (thetaIncrement);
790
791 double angle;
792 for (angle = start; angle < stop; angle += thetaIncrement) {
793 double xp = cosTheta * x - sinTheta * y; // translate point by thetaIncrement
794 double yp = sinTheta * x + cosTheta * y;
795 lineAbs (xCent + xp, yCent + yp);
796 x = xp; y = yp;
797 }
798
799 double c = cos (stop - angle);
800 double s = sin (stop - angle);
801 double xp = c * x - s * y;
802 double yp = s * x + c * y;
803 lineAbs (xCent + xp, yCent + yp);
804
805 moveAbs (xCent, yCent); // move back to center of circle
806 }
807
808
809
810 ///////////////////////////////////////////////////////////////////////
811 // Coordinate Transformations
812 ///////////////////////////////////////////////////////////////////////
813
814
815 void
816 SGP::transformNDCtoMC (double* x, double* y)
817 {
818 if (m_bRecalcTransform)
819 calc_transform();
820 ndc_to_mc.transformPoint (x, y);
821 }
822
823
824 void
825 SGP::transformMCtoNDC (double* x, double* y)
826 {
827 if (m_bRecalcTransform)
828 calc_transform();
829 mc_to_ndc.transformPoint (x, y);
830 }
831
832
833 void
834 SGP::transformMCtoNDC (double xIn, double yIn, double* x, double* y)
835 {
836 if (m_bRecalcTransform)
837 calc_transform();
838 *x = xIn;
839 *y = yIn;
840 mc_to_ndc.transformPoint (x, y);
841 }
842
843
844 // NAME
845 // calc_transform Calculate transform matrices
846
847 void
848 SGP::calc_transform ()
849 {
850 double scaleX = (xv_max - xv_min) / (xw_max - xw_min);
851 double scaleY = (yv_max - yv_min) / (yw_max - yw_min);
852
853 wc_to_ndc.setIdentity();
854 wc_to_ndc.mtx[0][0] = scaleX;
855 wc_to_ndc.mtx[2][0] = xv_min - scaleX * xw_min;
856 wc_to_ndc.mtx[1][1] = scaleY;
857 wc_to_ndc.mtx[2][1] = yv_min - scaleY * yw_min;
858
859 mc_to_ndc = m_ctm * wc_to_ndc;
860 ndc_to_mc = mc_to_ndc.invert();
861
862 m_bRecalcTransform = false;
863 }
864
865 void
866 SGP::ctmClear ()
867 {
868 m_ctm.setIdentity();
869 calc_transform();
870 }
871
872 void
873 SGP::ctmSet (const TransformationMatrix2D& m)
874 {
875 m_ctm = m;
876 calc_transform();
877 }
878
879
880 void
881 SGP::preTranslate (double x, double y)
882 {
883 TransformationMatrix2D m;
884
885 m.setTranslate (x, y);
886 ctmSet (m * m_ctm);
887 }
888
889
890 void
891 SGP::postTranslate (double x, double y)
892 {
893 TransformationMatrix2D m;
894
895 m.setTranslate (x, y);
896 ctmSet (m_ctm * m);
897 }
898
899
900 void
901 SGP::preScale (double sx, double sy)
902 {
903 TransformationMatrix2D m;
904
905 m.setScale (sx, sy);
906 ctmSet (m * m_ctm);
907 }
908
909
910 void
911 SGP::postScale (double sx, double sy)
912 {
913 TransformationMatrix2D m;
914
915 m.setScale (sx, sy);
916 m_ctm = m_ctm * m;
917 ctmSet (m_ctm * m);
918 }
919
920
921 void
922 SGP::preRotate (double theta)
923 {
924 TransformationMatrix2D m;
925
926 m.setRotate (theta);
927 m_ctm = m * m_ctm;
928 ctmSet (m * m_ctm);
929 }
930
931
932 void
933 SGP::postRotate (double theta)
934 {
935 TransformationMatrix2D m;
936
937 m.setRotate (theta);
938 ctmSet (m_ctm * m);
939 }
940
941
942 void
943 SGP::preShear (double shrx, double shry)
944 {
945 TransformationMatrix2D m;
946
947 m.setShear (shrx, shry);
948 ctmSet (m * m_ctm);
949 }
950
951
952 void
953 SGP::postShear (double shrx, double shry)
954 {
955 TransformationMatrix2D m;
956
957 m.setShear (shrx, shry);
958 ctmSet (m_ctm * m);
959 }
960
961
962 ////////////////////////////////////////////////////////////////////////
963 // Bitmap Markers
964 ////////////////////////////////////////////////////////////////////////
965
966 // Pixel patterns of marker symbols (1x1 to 5x5 matrix)
967 const unsigned char SGP::MARKER_BITMAP[MARK_COUNT][5] =
968 {
969 {'\000', '\000', '\010', '\000', '\000'}, // small dot
970 {'\000', '\034', '\024', '\034', '\000'}, // empty square
971 {'\000', '\034', '\034', '\034', '\000'}, // filled square
972 {'\000', '\010', '\024', '\010', '\000'}, // empty diamond
973 {'\000', '\010', '\034', '\010', '\000'}, // filled diamond
974 {'\010', '\010', '\076', '\010', '\010'}, // cross
975 {'\000', '\024', '\010', '\024', '\000'}, // X
976 {'\034', '\042', '\042', '\042', '\034'}, // open circle
977 {'\034', '\076', '\076', '\076', '\034'}, // filled circle
978 {'\076', '\042', '\042', '\042', '\076'}, // big open square
979 {'\010', '\024', '\042', '\024', '\010'}, // big open diamond
980 };
981
982
983 #if HAVE_WXWINDOWS
984 void
985 SGP::setDC (wxDC* pDC)
986 {
987 if (m_driver.isWX()) {
988 m_driver.setDC(pDC);
989 initFromDC (pDC);
990 setTextPointSize (m_iTextPointSize);
991 }
992 }
993 #endif