]> git.saurik.com Git - wxWidgets.git/blame - contrib/src/ogl/drawn.cpp
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
fix in fontspec parsing
[wxWidgets.git] / contrib / src / ogl / drawn.cpp
CommitLineData
1fc25a89
JS		 1/////////////////////////////////////////////////////////////////////////////
2// Name: drawn.cpp
3// Purpose: wxDrawnShape
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 "drawn.h"
14#pragma implementation "drawnp.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#include <wx/wxexpr.h>
29
30#include <wx/ogl/basic.h>
31#include <wx/ogl/basicp.h>
32#include <wx/ogl/canvas.h>
33#include <wx/ogl/mfutils.h>
34#include <wx/ogl/drawn.h>
35#include <wx/ogl/drawnp.h>
36#include <wx/ogl/misc.h>
37
38static void IntToHex(unsigned int dec, char *buf);
39static unsigned long HexToInt(char *buf);
40extern char *oglBuffer;
41
42#define gyTYPE_PEN 40
43#define gyTYPE_BRUSH 41
44#define gyTYPE_FONT 42
45
46/*
47 * Drawn object
48 *
49 */
50
51IMPLEMENT_DYNAMIC_CLASS(wxDrawnShape, wxRectangleShape)
52
53wxDrawnShape::wxDrawnShape():wxRectangleShape(100.0, 50.0)
54{
55 m_saveToFile = TRUE;
56 m_currentAngle = oglDRAWN_ANGLE_0;
57}
58
59wxDrawnShape::~wxDrawnShape()
60{
61}
62
63void wxDrawnShape::OnDraw(wxDC& dc)
64{
65 // Pass pen and brush in case we have force outline
66 // and fill colours
67 if (m_shadowMode != SHADOW_NONE)
68 {
69 if (m_shadowBrush)
70 m_metafiles[m_currentAngle].m_fillBrush = m_shadowBrush;
71 m_metafiles[m_currentAngle].m_outlinePen = g_oglTransparentPen;
72 m_metafiles[m_currentAngle].Draw(dc, m_xpos + m_shadowOffsetX, m_ypos + m_shadowOffsetY);
73 }
74
75 m_metafiles[m_currentAngle].m_outlinePen = m_pen;
76 m_metafiles[m_currentAngle].m_fillBrush = m_brush;
77 m_metafiles[m_currentAngle].Draw(dc, m_xpos, m_ypos);
78}
79
80void wxDrawnShape::SetSize(double w, double h, bool recursive)
81{
82 SetAttachmentSize(w, h);
83
84 double scaleX;
85 double scaleY;
86 if (GetWidth() == 0.0)
87 scaleX = 1.0;
88 else scaleX = w/GetWidth();
89 if (GetHeight() == 0.0)
90 scaleY = 1.0;
91 else scaleY = h/GetHeight();
92
93 int i = 0;
94 for (i = 0; i < 4; i++)
95 {
96 if (m_metafiles[i].IsValid())
97 m_metafiles[i].Scale(scaleX, scaleY);
98 }
99 m_width = w;
100 m_height = h;
101 SetDefaultRegionSize();
102}
103
104void wxDrawnShape::Scale(double sx, double sy)
105{
106 int i;
107 for (i = 0; i < 4; i++)
108 {
109 if (m_metafiles[i].IsValid())
110 {
111 m_metafiles[i].Scale(sx, sy);
112 m_metafiles[i].CalculateSize(this);
113 }
114 }
115}
116
117void wxDrawnShape::Translate(double x, double y)
118{
119 int i;
120 for (i = 0; i < 4; i++)
121 {
122 if (m_metafiles[i].IsValid())
123 {
124 m_metafiles[i].Translate(x, y);
125 m_metafiles[i].CalculateSize(this);
126 }
127 }
128}
129
130// theta is absolute rotation from the zero position
131void wxDrawnShape::Rotate(double x, double y, double theta)
132{
133 m_currentAngle = DetermineMetaFile(theta);
134
135 if (m_currentAngle == 0)
136 {
137 // Rotate metafile
138 if (!m_metafiles[0].GetRotateable())
139 return;
140
141 m_metafiles[0].Rotate(x, y, theta);
142 }
143
144 double actualTheta = theta-m_rotation;
145
146 // Rotate attachment points
147 double sinTheta = (double)sin(actualTheta);
148 double cosTheta = (double)cos(actualTheta);
149 wxNode *node = m_attachmentPoints.First();
150 while (node)
151 {
152 wxAttachmentPoint *point = (wxAttachmentPoint *)node->Data();
153 double x1 = point->m_x;
154 double y1 = point->m_y;
155 point->m_x = x1*cosTheta - y1*sinTheta + x*(1.0 - cosTheta) + y*sinTheta;
156 point->m_y = x1*sinTheta + y1*cosTheta + y*(1.0 - cosTheta) + x*sinTheta;
157 node = node->Next();
158 }
159 m_rotation = theta;
160
161 m_metafiles[m_currentAngle].CalculateSize(this);
162}
163
164// Which metafile do we use now? Based on current rotation and validity
165// of metafiles.
166
167int wxDrawnShape::DetermineMetaFile(double rotation)
168{
169 double tolerance = 0.0001;
170 const double pi = 3.1415926535897932384626433832795 ;
171 double angle1 = 0.0;
172 double angle2 = pi/2.0;
173 double angle3 = pi;
174 double angle4 = 3.0*pi/2.0;
175
176 int whichMetafile = 0;
177
178 if (oglRoughlyEqual(rotation, angle1, tolerance))
179 {
180 whichMetafile = 0;
181 }
182 else if (oglRoughlyEqual(rotation, angle2, tolerance))
183 {
184 whichMetafile = 1;
185 }
186 else if (oglRoughlyEqual(rotation, angle3, tolerance))
187 {
188 whichMetafile = 2;
189 }
190 else if (oglRoughlyEqual(rotation, angle4, tolerance))
191 {
192 whichMetafile = 3;
193 }
194
195 if ((whichMetafile > 0) && !m_metafiles[whichMetafile].IsValid())
196 whichMetafile = 0;
197
198 return whichMetafile;
199}
200
201void wxDrawnShape::OnDrawOutline(wxDC& dc, double x, double y, double w, double h)
202{
203 if (m_metafiles[m_currentAngle].GetOutlineOp() != -1)
204 {
205 wxNode* node = m_metafiles[m_currentAngle].GetOps().Nth(m_metafiles[m_currentAngle].GetOutlineOp());
206 wxASSERT (node != NULL);
207 wxDrawOp* op = (wxDrawOp*) node->Data();
208
209 if (op->OnDrawOutline(dc, x, y, w, h, m_width, m_height))
210 return;
211 }
212
213 // Default... just use a rectangle
214 wxRectangleShape::OnDrawOutline(dc, x, y, w, h);
215}
216
217// Get the perimeter point using the special outline op, if there is one,
218// otherwise use default wxRectangleShape scheme
219bool wxDrawnShape::GetPerimeterPoint(double x1, double y1,
220 double x2, double y2,
221 double *x3, double *y3)
222{
223 if (m_metafiles[m_currentAngle].GetOutlineOp() != -1)
224 {
225 wxNode* node = m_metafiles[m_currentAngle].GetOps().Nth(m_metafiles[m_currentAngle].GetOutlineOp());
226 wxASSERT (node != NULL);
227 wxDrawOp* op = (wxDrawOp*) node->Data();
228
229 if (op->GetPerimeterPoint(x1, y1, x2, y2, x3, y3, GetX(), GetY(), GetAttachmentMode()))
230 return TRUE;
231 }
232
233 // Default... just use a rectangle
234 return wxRectangleShape::GetPerimeterPoint(x1, y1, x2, y2, x3, y3);
235}
236
237#ifdef PROLOGIO
238void wxDrawnShape::WriteAttributes(wxExpr *clause)
239{
240 wxRectangleShape::WriteAttributes(clause);
241
242 clause->AddAttributeValue("current_angle", (long)m_currentAngle);
243 clause->AddAttributeValue("save_metafile", (long)m_saveToFile);
244 if (m_saveToFile)
245 {
246 int i = 0;
247 for (i = 0; i < 4; i++)
248 {
249 if (m_metafiles[i].IsValid())
250 m_metafiles[i].WriteAttributes(clause, i);
251 }
252 }
253}
254
255void wxDrawnShape::ReadAttributes(wxExpr *clause)
256{
257 wxRectangleShape::ReadAttributes(clause);
258
259 int iVal = (int) m_saveToFile;
260 clause->GetAttributeValue("save_metafile", iVal);
261 clause->GetAttributeValue("current_angle", m_currentAngle);
262 m_saveToFile = (iVal != 0);
263
264 if (m_saveToFile)
265 {
266 int i = 0;
267 for (i = 0; i < 4; i++)
268 {
269 m_metafiles[i].ReadAttributes(clause, i);
270 }
271 }
272}
273#endif
274
275// Does the copying for this object
276void wxDrawnShape::Copy(wxShape& copy)
277{
278 wxRectangleShape::Copy(copy);
279
280 wxASSERT( copy.IsKindOf(CLASSINFO(wxDrawnShape)) ) ;
281
282 wxDrawnShape& drawnCopy = (wxDrawnShape&) copy;
283
284 int i = 0;
285 for (i = 0; i < 4; i++)
286 {
287 m_metafiles[i].Copy(drawnCopy.m_metafiles[i]);
288 }
289 drawnCopy.m_saveToFile = m_saveToFile;
290 drawnCopy.m_currentAngle = m_currentAngle;
291}
292
293bool wxDrawnShape::LoadFromMetaFile(char *filename)
294{
295 return m_metafiles[0].LoadFromMetaFile(filename, &m_width, &m_height);
296}
297
298// Set of functions for drawing into a pseudo metafile.
299// They use integers, but doubles are used internally for accuracy
300// when scaling.
301
302void wxDrawnShape::DrawLine(const wxPoint& pt1, const wxPoint& pt2)
303{
304 m_metafiles[m_currentAngle].DrawLine(pt1, pt2);
305}
306
307void wxDrawnShape::DrawRectangle(const wxRect& rect)
308{
309 m_metafiles[m_currentAngle].DrawRectangle(rect);
310}
311
312void wxDrawnShape::DrawRoundedRectangle(const wxRect& rect, double radius)
313{
314 m_metafiles[m_currentAngle].DrawRoundedRectangle(rect, radius);
315}
316
317void wxDrawnShape::DrawEllipse(const wxRect& rect)
318{
319 m_metafiles[m_currentAngle].DrawEllipse(rect);
320}
321
322void wxDrawnShape::DrawArc(const wxPoint& centrePt, const wxPoint& startPt, const wxPoint& endPt)
323{
324 m_metafiles[m_currentAngle].DrawArc(centrePt, startPt, endPt);
325}
326
327void wxDrawnShape::DrawEllipticArc(const wxRect& rect, double startAngle, double endAngle)
328{
329 m_metafiles[m_currentAngle].DrawEllipticArc(rect, startAngle, endAngle);
330}
331
332void wxDrawnShape::DrawPoint(const wxPoint& pt)
333{
334 m_metafiles[m_currentAngle].DrawPoint(pt);
335}
336
337void wxDrawnShape::DrawText(const wxString& text, const wxPoint& pt)
338{
339 m_metafiles[m_currentAngle].DrawText(text, pt);
340}
341
342void wxDrawnShape::DrawLines(int n, wxPoint pts[])
343{
344 m_metafiles[m_currentAngle].DrawLines(n, pts);
345}
346
347void wxDrawnShape::DrawPolygon(int n, wxPoint pts[], int flags)
348{
349 if (flags & oglMETAFLAGS_ATTACHMENTS)
350 {
351 ClearAttachments();
352 int i;
353 for (i = 0; i < n; i++)
354 m_attachmentPoints.Append(new wxAttachmentPoint(i, pts[i].x, pts[i].y));
355 }
356 m_metafiles[m_currentAngle].DrawPolygon(n, pts, flags);
357}
358
359void wxDrawnShape::DrawSpline(int n, wxPoint pts[])
360{
361 m_metafiles[m_currentAngle].DrawSpline(n, pts);
362}
363
364void wxDrawnShape::SetClippingRect(const wxRect& rect)
365{
366 m_metafiles[m_currentAngle].SetClippingRect(rect);
367}
368
369void wxDrawnShape::DestroyClippingRect()
370{
371 m_metafiles[m_currentAngle].DestroyClippingRect();
372}
373
374void wxDrawnShape::SetDrawnPen(wxPen* pen, bool isOutline)
375{
376 m_metafiles[m_currentAngle].SetPen(pen, isOutline);
377}
378
379void wxDrawnShape::SetDrawnBrush(wxBrush* brush, bool isFill)
380{
381 m_metafiles[m_currentAngle].SetBrush(brush, isFill);
382}
383
384void wxDrawnShape::SetDrawnFont(wxFont* font)
385{
386 m_metafiles[m_currentAngle].SetFont(font);
387}
388
389void wxDrawnShape::SetDrawnTextColour(const wxColour& colour)
390{
391 m_metafiles[m_currentAngle].SetTextColour(colour);
392}
393
394void wxDrawnShape::SetDrawnBackgroundColour(const wxColour& colour)
395{
396 m_metafiles[m_currentAngle].SetBackgroundColour(colour);
397}
398
399void wxDrawnShape::SetDrawnBackgroundMode(int mode)
400{
401 m_metafiles[m_currentAngle].SetBackgroundMode(mode);
402}
403
404
405/*
406 * Individual operations
407 *
408 */
409
410/*
411 * Set font, brush, text colour
412 *
413 */
414
415wxOpSetGDI::wxOpSetGDI(int theOp, wxPseudoMetaFile *theImage, int theGdiIndex, int theMode):
416 wxDrawOp(theOp)
417{
418 m_gdiIndex = theGdiIndex;
419 m_image = theImage;
420 m_mode = theMode;
421}
422
423void wxOpSetGDI::Do(wxDC& dc, double xoffset, double yoffset)
424{
425 switch (m_op)
426 {
427 case DRAWOP_SET_PEN:
428 {
429 // Check for overriding this operation for outline
430 // colour
431 if (m_image->m_outlineColours.Member((wxObject *)m_gdiIndex))
432 {
433 if (m_image->m_outlinePen)
434 dc.SetPen(* m_image->m_outlinePen);
435 }
436 else
437 {
438 wxNode *node = m_image->m_gdiObjects.Nth(m_gdiIndex);
439 if (node)
440 {
441 wxPen *pen = (wxPen *)node->Data();
442 if (pen)
443 dc.SetPen(* pen);
444 }
445 }
446 break;
447 }
448 case DRAWOP_SET_BRUSH:
449 {
450 // Check for overriding this operation for outline or fill
451 // colour
452 if (m_image->m_outlineColours.Member((wxObject *)m_gdiIndex))
453 {
454 // Need to construct a brush to match the outline pen's colour
455 if (m_image->m_outlinePen)
456 {
457 wxBrush *br = wxTheBrushList->FindOrCreateBrush(m_image->m_outlinePen->GetColour(), wxSOLID);
458 if (br)
459 dc.SetBrush(* br);
460 }
461 }
462 else if (m_image->m_fillColours.Member((wxObject *)m_gdiIndex))
463 {
464 if (m_image->m_fillBrush)
465 {
466 dc.SetBrush(* m_image->m_fillBrush);
467 }
468 }
469 else
470 {
471 wxNode *node = m_image->m_gdiObjects.Nth(m_gdiIndex);
472 if (node)
473 {
474 wxBrush *brush = (wxBrush *)node->Data();
475 if (brush)
476 dc.SetBrush(* brush);
477 }
478 }
479 break;
480 }
481 case DRAWOP_SET_FONT:
482 {
483 wxNode *node = m_image->m_gdiObjects.Nth(m_gdiIndex);
484 if (node)
485 {
486 wxFont *font = (wxFont *)node->Data();
487 if (font)
488 dc.SetFont(* font);
489 }
490 break;
491 }
492 case DRAWOP_SET_TEXT_COLOUR:
493 {
494 wxColour col(m_r,m_g,m_b);
495 dc.SetTextForeground(col);
496 break;
497 }
498 case DRAWOP_SET_BK_COLOUR:
499 {
500 wxColour col(m_r,m_g,m_b);
501 dc.SetTextBackground(col);
502 break;
503 }
504 case DRAWOP_SET_BK_MODE:
505 {
506 dc.SetBackgroundMode(m_mode);
507 break;
508 }
509 default:
510 break;
511 }
512}
513
514wxDrawOp *wxOpSetGDI::Copy(wxPseudoMetaFile *newImage)
515{
516 wxOpSetGDI *newOp = new wxOpSetGDI(m_op, newImage, m_gdiIndex, m_mode);
517 newOp->m_r = m_r;
518 newOp->m_g = m_g;
519 newOp->m_b = m_b;
520 return newOp;
521}
522
523wxExpr *wxOpSetGDI::WriteExpr(wxPseudoMetaFile *image)
524{
525 wxExpr *expr = new wxExpr(wxExprList);
526 expr->Append(new wxExpr((long)m_op));
527 switch (m_op)
528 {
529 case DRAWOP_SET_PEN:
530 case DRAWOP_SET_BRUSH:
531 case DRAWOP_SET_FONT:
532 {
533 expr->Append(new wxExpr((long)m_gdiIndex));
534 break;
535 }
536 case DRAWOP_SET_TEXT_COLOUR:
537 case DRAWOP_SET_BK_COLOUR:
538 {
539 expr->Append(new wxExpr((long)m_r));
540 expr->Append(new wxExpr((long)m_g));
541 expr->Append(new wxExpr((long)m_b));
542 break;
543 }
544 case DRAWOP_SET_BK_MODE:
545 {
546 expr->Append(new wxExpr((long)m_mode));
547 break;
548 }
549 default:
550 break;
551 }
552 return expr;
553}
554
555void wxOpSetGDI::ReadExpr(wxPseudoMetaFile *image, wxExpr *expr)
556{
557 switch (m_op)
558 {
559 case DRAWOP_SET_PEN:
560 case DRAWOP_SET_BRUSH:
561 case DRAWOP_SET_FONT:
562 {
563 m_gdiIndex = (int)expr->Nth(1)->IntegerValue();
564 break;
565 }
566 case DRAWOP_SET_TEXT_COLOUR:
567 case DRAWOP_SET_BK_COLOUR:
568 {
569 m_r = (unsigned char)expr->Nth(1)->IntegerValue();
570 m_g = (unsigned char)expr->Nth(2)->IntegerValue();
571 m_b = (unsigned char)expr->Nth(3)->IntegerValue();
572 break;
573 }
574 case DRAWOP_SET_BK_MODE:
575 {
576 m_mode = (int)expr->Nth(1)->IntegerValue();
577 break;
578 }
579 default:
580 break;
581 }
582}
583
584/*
585 * Set/destroy clipping
586 *
587 */
588
589wxOpSetClipping::wxOpSetClipping(int theOp, double theX1, double theY1,
590 double theX2, double theY2):wxDrawOp(theOp)
591{
592 m_x1 = theX1;
593 m_y1 = theY1;
594 m_x2 = theX2;
595 m_y2 = theY2;
596}
597
598wxDrawOp *wxOpSetClipping::Copy(wxPseudoMetaFile *newImage)
599{
600 wxOpSetClipping *newOp = new wxOpSetClipping(m_op, m_x1, m_y1, m_x2, m_y2);
601 return newOp;
602}
603
604void wxOpSetClipping::Do(wxDC& dc, double xoffset, double yoffset)
605{
606 switch (m_op)
607 {
608 case DRAWOP_SET_CLIPPING_RECT:
609 {
610 dc.SetClippingRegion((long)(m_x1 + xoffset), (long)(m_y1 + yoffset), (long)(m_x2 + xoffset), (long)(m_y2 + yoffset));
611 break;
612 }
613 case DRAWOP_DESTROY_CLIPPING_RECT:
614 {
615 dc.DestroyClippingRegion();
616 break;
617 }
618 default:
619 break;
620 }
621}
622
623void wxOpSetClipping::Scale(double xScale, double yScale)
624{
625 m_x1 *= xScale;
626 m_y1 *= yScale;
627 m_x2 *= xScale;
628 m_y2 *= yScale;
629}
630
631void wxOpSetClipping::Translate(double x, double y)
632{
633 m_x1 += x;
634 m_y1 += y;
635}
636
637wxExpr *wxOpSetClipping::WriteExpr(wxPseudoMetaFile *image)
638{
639 wxExpr *expr = new wxExpr(wxExprList);
640 expr->Append(new wxExpr((long)m_op));
641 switch (m_op)
642 {
643 case DRAWOP_SET_CLIPPING_RECT:
644 {
645 expr->Append(new wxExpr(m_x1));
646 expr->Append(new wxExpr(m_y1));
647 expr->Append(new wxExpr(m_x2));
648 expr->Append(new wxExpr(m_y2));
649 break;
650 }
651 default:
652 break;
653 }
654 return expr;
655}
656
657void wxOpSetClipping::ReadExpr(wxPseudoMetaFile *image, wxExpr *expr)
658{
659 switch (m_op)
660 {
661 case DRAWOP_SET_CLIPPING_RECT:
662 {
663 m_x1 = expr->Nth(1)->RealValue();
664 m_y1 = expr->Nth(2)->RealValue();
665 m_x2 = expr->Nth(3)->RealValue();
666 m_y2 = expr->Nth(4)->RealValue();
667 break;
668 }
669 default:
670 break;
671 }
672}
673
674/*
675 * Draw line, rectangle, rounded rectangle, ellipse, point, arc, text
676 *
677 */
678
679wxOpDraw::wxOpDraw(int theOp, double theX1, double theY1, double theX2, double theY2,
680 double theRadius, char *s):wxDrawOp(theOp)
681{
682 m_x1 = theX1;
683 m_y1 = theY1;
684 m_x2 = theX2;
685 m_y2 = theY2;
686 m_x3 = 0.0;
687 m_y3 = 0.0;
688 m_radius = theRadius;
689 if (s) m_textString = copystring(s);
690 else m_textString = NULL;
691}
692
693wxOpDraw::~wxOpDraw()
694{
695 if (m_textString) delete[] m_textString;
696}
697
698wxDrawOp *wxOpDraw::Copy(wxPseudoMetaFile *newImage)
699{
700 wxOpDraw *newOp = new wxOpDraw(m_op, m_x1, m_y1, m_x2, m_y2, m_radius, m_textString);
701 newOp->m_x3 = m_x3;
702 newOp->m_y3 = m_y3;
703 return newOp;
704}
705
706void wxOpDraw::Do(wxDC& dc, double xoffset, double yoffset)
707{
708 switch (m_op)
709 {
710 case DRAWOP_DRAW_LINE:
711 {
712 dc.DrawLine(WXROUND(m_x1+xoffset), WXROUND(m_y1+yoffset), WXROUND(m_x2+xoffset), WXROUND(m_y2+yoffset));
713 break;
714 }
715 case DRAWOP_DRAW_RECT:
716 {
717 dc.DrawRectangle(WXROUND(m_x1+xoffset), WXROUND(m_y1+yoffset), WXROUND(m_x2), WXROUND(m_y2));
718 break;
719 }
720 case DRAWOP_DRAW_ROUNDED_RECT:
721 {
722 dc.DrawRoundedRectangle(WXROUND(m_x1+xoffset), WXROUND(m_y1+yoffset), WXROUND(m_x2), WXROUND(m_y2), m_radius);
723 break;
724 }
725 case DRAWOP_DRAW_ELLIPSE:
726 {
727 dc.DrawEllipse(WXROUND(m_x1+xoffset), WXROUND(m_y1+yoffset), WXROUND(m_x2), WXROUND(m_y2));
728 break;
729 }
730 case DRAWOP_DRAW_ARC:
731 {
732 dc.DrawArc(WXROUND(m_x2+xoffset), WXROUND(m_y2+yoffset),
733 WXROUND(m_x3+xoffset), WXROUND(m_y3+yoffset),
734 WXROUND(m_x1+xoffset), WXROUND(m_y1+yoffset));
735 break;
736 }
737 case DRAWOP_DRAW_ELLIPTIC_ARC:
738 {
739 const double pi = 3.1415926535897932384626433832795 ;
740
741 // Convert back to degrees
742 dc.DrawEllipticArc(
743 WXROUND(m_x1+xoffset), WXROUND(m_y1+yoffset),
744 WXROUND(m_x2), WXROUND(m_y2),
745 WXROUND(m_x3*(360.0/(2.0*pi))), WXROUND(m_y3*(360.0/(2.0*pi))));
746 break;
747 }
748 case DRAWOP_DRAW_POINT:
749 {
750 dc.DrawPoint(WXROUND(m_x1+xoffset), WXROUND(m_y1+yoffset));
751 break;
752 }
753 case DRAWOP_DRAW_TEXT:
754 {
755 dc.DrawText(m_textString, WXROUND(m_x1+xoffset), WXROUND(m_y1+yoffset));
756 break;
757 }
758 default:
759 break;
760 }
761}
762
763void wxOpDraw::Scale(double scaleX, double scaleY)
764{
765 m_x1 *= scaleX;
766 m_y1 *= scaleY;
767 m_x2 *= scaleX;
768 m_y2 *= scaleY;
769
770 if (m_op != DRAWOP_DRAW_ELLIPTIC_ARC)
771 {
772 m_x3 *= scaleX;
773 m_y3 *= scaleY;
774 }
775
776 m_radius *= scaleX;
777}
778
779void wxOpDraw::Translate(double x, double y)
780{
781 m_x1 += x;
782 m_y1 += y;
783
784 switch (m_op)
785 {
786 case DRAWOP_DRAW_LINE:
787 {
788 m_x2 += x;
789 m_y2 += y;
790 break;
791 }
792 case DRAWOP_DRAW_ARC:
793 {
794 m_x2 += x;
795 m_y2 += y;
796 m_x3 += x;
797 m_y3 += y;
798 break;
799 }
800 case DRAWOP_DRAW_ELLIPTIC_ARC:
801 {
802 break;
803 }
804 default:
805 break;
806 }
807}
808
809void wxOpDraw::Rotate(double x, double y, double theta, double sinTheta, double cosTheta)
810{
811 double newX1 = m_x1*cosTheta - m_y1*sinTheta + x*(1.0 - cosTheta) + y*sinTheta;
812 double newY1 = m_x1*sinTheta + m_y1*cosTheta + y*(1.0 - cosTheta) + x*sinTheta;
813
814 switch (m_op)
815 {
816 case DRAWOP_DRAW_LINE:
817 {
818 double newX2 = m_x2*cosTheta - m_y2*sinTheta + x*(1.0 - cosTheta) + y*sinTheta;
819 double newY2 = m_x2*sinTheta + m_y2*cosTheta + y*(1.0 - cosTheta) + x*sinTheta;
820
821 m_x1 = newX1;
822 m_y1 = newY1;
823 m_x2 = newX2;
824 m_y2 = newY2;
825 break;
826 }
827 case DRAWOP_DRAW_RECT:
828 case DRAWOP_DRAW_ROUNDED_RECT:
829 case DRAWOP_DRAW_ELLIPTIC_ARC:
830 {
831 // Assume only 0, 90, 180, 270 degree rotations.
832 // oldX1, oldY1 represents the top left corner. Find the
833 // bottom right, and rotate that. Then the width/height is the difference
834 // between x/y values.
835 double oldBottomRightX = m_x1 + m_x2;
836 double oldBottomRightY = m_y1 + m_y2;
837 double newBottomRightX = oldBottomRightX*cosTheta - oldBottomRightY*sinTheta + x*(1.0 - cosTheta) + y*sinTheta;
838 double newBottomRightY = oldBottomRightX*sinTheta + oldBottomRightY*cosTheta + y*(1.0 - cosTheta) + x*sinTheta;
839
840 // Now find the new top-left, bottom-right coordinates.
841 double minX = wxMin(newX1, newBottomRightX);
842 double minY = wxMin(newY1, newBottomRightY);
843 double maxX = wxMax(newX1, newBottomRightX);
844 double maxY = wxMax(newY1, newBottomRightY);
845
846 m_x1 = minX;
847 m_y1 = minY;
848 m_x2 = maxX - minX; // width
849 m_y2 = maxY - minY; // height
850
851 if (m_op == DRAWOP_DRAW_ELLIPTIC_ARC)
852 {
853 // Add rotation to angles
854 m_x3 += theta;
855 m_y3 += theta;
856 }
857
858 break;
859 }
860 case DRAWOP_DRAW_ARC:
861 {
862 double newX2 = m_x2*cosTheta - m_y2*sinTheta + x*(1.0 - cosTheta) + y*sinTheta;
863 double newY2 = m_x2*sinTheta + m_y2*cosTheta + y*(1.0 - cosTheta) + x*sinTheta;
864 double newX3 = m_x3*cosTheta - m_y3*sinTheta + x*(1.0 - cosTheta) + y*sinTheta;
865 double newY3 = m_x3*sinTheta + m_y3*cosTheta + y*(1.0 - cosTheta) + x*sinTheta;
866
867 m_x1 = newX1;
868 m_y1 = newY1;
869 m_x2 = newX2;
870 m_y2 = newY2;
871 m_x3 = newX3;
872 m_y3 = newY3;
873
874 break;
875 }
876 default:
877 break;
878 }
879}
880
881wxExpr *wxOpDraw::WriteExpr(wxPseudoMetaFile *image)
882{
883 wxExpr *expr = new wxExpr(wxExprList);
884 expr->Append(new wxExpr((long)m_op));
885 switch (m_op)
886 {
887 case DRAWOP_DRAW_LINE:
888 case DRAWOP_DRAW_RECT:
889 case DRAWOP_DRAW_ELLIPSE:
890 {
891 expr->Append(new wxExpr(m_x1));
892 expr->Append(new wxExpr(m_y1));
893 expr->Append(new wxExpr(m_x2));
894 expr->Append(new wxExpr(m_y2));
895 break;
896 }
897 case DRAWOP_DRAW_ROUNDED_RECT:
898 {
899 expr->Append(new wxExpr(m_x1));
900 expr->Append(new wxExpr(m_y1));
901 expr->Append(new wxExpr(m_x2));
902 expr->Append(new wxExpr(m_y2));
903 expr->Append(new wxExpr(m_radius));
904 break;
905 }
906 case DRAWOP_DRAW_POINT:
907 {
908 expr->Append(new wxExpr(m_x1));
909 expr->Append(new wxExpr(m_y1));
910 break;
911 }
912 case DRAWOP_DRAW_TEXT:
913 {
914 expr->Append(new wxExpr(m_x1));
915 expr->Append(new wxExpr(m_y1));
916 expr->Append(new wxExpr(wxExprString, m_textString));
917 break;
918 }
919 case DRAWOP_DRAW_ARC:
920 case DRAWOP_DRAW_ELLIPTIC_ARC:
921 {
922 expr->Append(new wxExpr(m_x1));
923 expr->Append(new wxExpr(m_y1));
924 expr->Append(new wxExpr(m_x2));
925 expr->Append(new wxExpr(m_y2));
926 expr->Append(new wxExpr(m_x3));
927 expr->Append(new wxExpr(m_y3));
928 break;
929 }
930 default:
931 {
932 break;
933 }
934 }
935 return expr;
936}
937
938void wxOpDraw::ReadExpr(wxPseudoMetaFile *image, wxExpr *expr)
939{
940 switch (m_op)
941 {
942 case DRAWOP_DRAW_LINE:
943 case DRAWOP_DRAW_RECT:
944 case DRAWOP_DRAW_ELLIPSE:
945 {
946 m_x1 = expr->Nth(1)->RealValue();
947 m_y1 = expr->Nth(2)->RealValue();
948 m_x2 = expr->Nth(3)->RealValue();
949 m_y2 = expr->Nth(4)->RealValue();
950 break;
951 }
952 case DRAWOP_DRAW_ROUNDED_RECT:
953 {
954 m_x1 = expr->Nth(1)->RealValue();
955 m_y1 = expr->Nth(2)->RealValue();
956 m_x2 = expr->Nth(3)->RealValue();
957 m_y2 = expr->Nth(4)->RealValue();
958 m_radius = expr->Nth(5)->RealValue();
959 break;
960 }
961 case DRAWOP_DRAW_POINT:
962 {
963 m_x1 = expr->Nth(1)->RealValue();
964 m_y1 = expr->Nth(2)->RealValue();
965 break;
966 }
967 case DRAWOP_DRAW_TEXT:
968 {
969 m_x1 = expr->Nth(1)->RealValue();
970 m_y1 = expr->Nth(2)->RealValue();
971 wxString str(expr->Nth(3)->StringValue());
972 m_textString = copystring((const char*) str);
973 break;
974 }
975 case DRAWOP_DRAW_ARC:
976 case DRAWOP_DRAW_ELLIPTIC_ARC:
977 {
978 m_x1 = expr->Nth(1)->RealValue();
979 m_y1 = expr->Nth(2)->RealValue();
980 m_x2 = expr->Nth(3)->RealValue();
981 m_y2 = expr->Nth(4)->RealValue();
982 m_x3 = expr->Nth(5)->RealValue();
983 m_y3 = expr->Nth(6)->RealValue();
984 break;
985 }
986 default:
987 {
988 break;
989 }
990 }
991}
992
993/*
994 * Draw polygon, polyline, spline
995 *
996 */
997
998wxOpPolyDraw::wxOpPolyDraw(int theOp, int n, wxRealPoint *thePoints):wxDrawOp(theOp)
999{
1000 m_noPoints = n;
1001 m_points = thePoints;
1002}
1003
1004wxOpPolyDraw::~wxOpPolyDraw()
1005{
1006 delete[] m_points;
1007}
1008
1009wxDrawOp *wxOpPolyDraw::Copy(wxPseudoMetaFile *newImage)
1010{
1011 wxRealPoint *newPoints = new wxRealPoint[m_noPoints];
1012 for (int i = 0; i < m_noPoints; i++)
1013 {
1014 newPoints[i].x = m_points[i].x;
1015 newPoints[i].y = m_points[i].y;
1016 }
1017 wxOpPolyDraw *newOp = new wxOpPolyDraw(m_op, m_noPoints, newPoints);
1018 return newOp;
1019}
1020
1021void wxOpPolyDraw::Do(wxDC& dc, double xoffset, double yoffset)
1022{
1023 switch (m_op)
1024 {
1025 case DRAWOP_DRAW_POLYLINE:
1026 {
1027 wxPoint *actualPoints = new wxPoint[m_noPoints];
1028 int i;
1029 for (i = 0; i < m_noPoints; i++)
1030 {
1031 actualPoints[i].x = WXROUND(m_points[i].x);
1032 actualPoints[i].y = WXROUND(m_points[i].y);
1033 }
1034
1035 dc.DrawLines(m_noPoints, actualPoints, WXROUND(xoffset), WXROUND(yoffset));
1036
1037 delete[] actualPoints;
1038 break;
1039 }
1040 case DRAWOP_DRAW_POLYGON:
1041 {
1042 wxPoint *actualPoints = new wxPoint[m_noPoints];
1043 int i;
1044 for (i = 0; i < m_noPoints; i++)
1045 {
1046 actualPoints[i].x = WXROUND(m_points[i].x);
1047 actualPoints[i].y = WXROUND(m_points[i].y);
1048 }
1049
1050 dc.DrawPolygon(m_noPoints, actualPoints, WXROUND(xoffset), WXROUND(yoffset));
1051
1052 delete[] actualPoints;
1053 break;
1054 }
1055 case DRAWOP_DRAW_SPLINE:
1056 {
1057 wxPoint *actualPoints = new wxPoint[m_noPoints];
1058 int i;
1059 for (i = 0; i < m_noPoints; i++)
1060 {
1061 actualPoints[i].x = WXROUND(m_points[i].x);
1062 actualPoints[i].y = WXROUND(m_points[i].y);
1063 }
1064
1065 dc.DrawSpline(m_noPoints, actualPoints); // no offsets in DrawSpline // , xoffset, yoffset);
1066
1067 delete[] actualPoints;
1068 break;
1069 break;
1070 }
1071 default:
1072 break;
1073 }
1074}
1075
1076void wxOpPolyDraw::Scale(double scaleX, double scaleY)
1077{
1078 for (int i = 0; i < m_noPoints; i++)
1079 {
1080 m_points[i].x *= scaleX;
1081 m_points[i].y *= scaleY;
1082 }
1083}
1084
1085void wxOpPolyDraw::Translate(double x, double y)
1086{
1087 for (int i = 0; i < m_noPoints; i++)
1088 {
1089 m_points[i].x += x;
1090 m_points[i].y += y;
1091 }
1092}
1093
1094void wxOpPolyDraw::Rotate(double x, double y, double theta, double sinTheta, double cosTheta)
1095{
1096 for (int i = 0; i < m_noPoints; i++)
1097 {
1098 double x1 = m_points[i].x;
1099 double y1 = m_points[i].y;
1100 m_points[i].x = x1*cosTheta - y1*sinTheta + x*(1.0 - cosTheta) + y*sinTheta;
1101 m_points[i].y = x1*sinTheta + y1*cosTheta + y*(1.0 - cosTheta) + x*sinTheta;
1102 }
1103}
1104
1105wxExpr *wxOpPolyDraw::WriteExpr(wxPseudoMetaFile *image)
1106{
1107 wxExpr *expr = new wxExpr(wxExprList);
1108 expr->Append(new wxExpr((long)m_op));
1109 expr->Append(new wxExpr((long)m_noPoints));
1110
1111// char buf1[9];
1112 char buf2[5];
1113 char buf3[5];
1114
1115 oglBuffer[0] = 0;
1116
1117 /*
1118 * Store each coordinate pair in a hex string to save space.
1119 * E.g. "1B9080CD". 4 hex digits per coordinate pair.
1120 *
1121 */
1122
1123 for (int i = 0; i < m_noPoints; i++)
1124 {
1125 long signedX = (long)(m_points[i].x*100.0);
1126 long signedY = (long)(m_points[i].y*100.0);
1127
1128 // Scale to 0 -> 64K
1129 long unSignedX = (long)(signedX + 32767.0);
1130 long unSignedY = (long)(signedY + 32767.0);
1131
1132// IntToHex((unsigned int)signedX, buf2);
1133// IntToHex((unsigned int)signedY, buf3);
1134 IntToHex((int)unSignedX, buf2);
1135 IntToHex((int)unSignedY, buf3);
1136
1137 // Don't overrun the buffer
1138 if ((i*8) < 3000)
1139 {
1140 strcat(oglBuffer, buf2);
1141 strcat(oglBuffer, buf3);
1142 }
1143 }
1144 expr->Append(new wxExpr(wxExprString, oglBuffer));
1145 return expr;
1146}
1147
1148void wxOpPolyDraw::ReadExpr(wxPseudoMetaFile *image, wxExpr *expr)
1149{
1150 m_noPoints = (int)expr->Nth(1)->IntegerValue();
1151
1152 char buf1[5];
1153 char buf2[5];
1154
1155 m_points = new wxRealPoint[m_noPoints];
1156 int i = 0;
1157 int bufPtr = 0;
1158 wxString hexString = expr->Nth(2)->StringValue();
1159 while (i < m_noPoints)
1160 {
1161 buf1[0] = hexString[(size_t)bufPtr];
1162 buf1[1] = hexString[(size_t)(bufPtr + 1)];
1163 buf1[2] = hexString[(size_t)(bufPtr + 2)];
1164 buf1[3] = hexString[(size_t)(bufPtr + 3)];
1165 buf1[4] = 0;
1166
1167 buf2[0] = hexString[(size_t)(bufPtr + 4)];
1168 buf2[1] = hexString[(size_t)(bufPtr + 5)];
1169 buf2[2] = hexString[(size_t)(bufPtr + 6)];
1170 buf2[3] = hexString[(size_t)(bufPtr + 7)];
1171 buf2[4] = 0;
1172
1173 bufPtr += 8;
1174
1175// int signedX = (signed int)HexToInt(buf1);
1176// int signedY = (signed int)HexToInt(buf2);
1177 long unSignedX = HexToInt(buf1);
1178 long unSignedY = HexToInt(buf2);
1179 // Scale -32K -> +32K
1180 long signedX = unSignedX - 32767;
1181 long signedY = unSignedY - 32767;
1182#ifdef __WXMSW__
1183 int testX = (signed int)unSignedX;
1184 int testY = (signed int)unSignedY;
1185#endif
1186
1187 m_points[i].x = (double)(signedX / 100.0);
1188 m_points[i].y = (double)(signedY / 100.0);
1189
1190 i ++;
1191 }
1192}
1193
1194// Draw an outline using the current operation.
1195bool wxOpPolyDraw::OnDrawOutline(wxDC& dc, double x, double y, double w, double h, double oldW, double oldH)
1196{
1197 dc.SetBrush(* wxTRANSPARENT_BRUSH);
1198
1199 // Multiply all points by proportion of new size to old size
1200 double x_proportion = (double)(fabs(w/oldW));
1201 double y_proportion = (double)(fabs(h/oldH));
1202
1203 int n = m_noPoints;
1204 wxPoint *intPoints = new wxPoint[n];
1205 int i;
1206 for (i = 0; i < n; i++)
1207 {
1208 intPoints[i].x = WXROUND (x_proportion * m_points[i].x);
1209 intPoints[i].y = WXROUND (y_proportion * m_points[i].y);
1210 }
1211 dc.DrawPolygon(n, intPoints, (long) x, (long) y);
1212 delete[] intPoints;
1213 return TRUE;
1214}
1215
1216// Assume (x1, y1) is centre of box (most generally, line end at box)
1217bool wxOpPolyDraw::GetPerimeterPoint(double x1, double y1,
1218 double x2, double y2,
1219 double *x3, double *y3,
1220 double xOffset, double yOffset,
1221 int attachmentMode)
1222{
1223 int n = m_noPoints;
1224
1225 // First check for situation where the line is vertical,
1226 // and we would want to connect to a point on that vertical --
1227 // oglFindEndForPolyline can't cope with this (the arrow
1228 // gets drawn to the wrong place).
1229 if ((attachmentMode == ATTACHMENT_MODE_NONE) && (x1 == x2))
1230 {
1231 // Look for the point we'd be connecting to. This is
1232 // a heuristic...
1233 int i;
1234 for (i = 0; i < n; i++)
1235 {
1236 wxRealPoint *point = & (m_points[i]);
1237 if (point->x == 0.0)
1238 {
1239 if ((y2 > y1) && (point->y > 0.0))
1240 {
1241 *x3 = point->x + xOffset;
1242 *y3 = point->y + yOffset;
1243 return TRUE;
1244 }
1245 else if ((y2 < y1) && (point->y < 0.0))
1246 {
1247 *x3 = point->x + xOffset;
1248 *y3 = point->y + yOffset;
1249 return TRUE;
1250 }
1251 }
1252 }
1253 }
1254
1255 double *xpoints = new double[n];
1256 double *ypoints = new double[n];
1257
1258 int i = 0;
1259 for (i = 0; i < n; i++)
1260 {
1261 wxRealPoint *point = & (m_points[i]);
1262 xpoints[i] = point->x + xOffset;
1263 ypoints[i] = point->y + yOffset;
1264 }
1265
1266 oglFindEndForPolyline(n, xpoints, ypoints,
1267 x1, y1, x2, y2, x3, y3);
1268
1269 delete[] xpoints;
1270 delete[] ypoints;
1271
1272 return TRUE;
1273}
1274
1275
1276/*
1277 * Utilities
1278 *
1279 */
1280
1281static char hexArray[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
1282 'C', 'D', 'E', 'F' };
1283
1284// Convert unsigned 16-bit integer to 4-character hex string
1285static void IntToHex(unsigned int dec, char *buf)
1286{
1287 int digit1 = (int)(dec/4096);
1288 int digit2 = (int)((dec - (digit1*4096))/256);
1289 int digit3 = (int)((dec - (digit1*4096) - (digit2*256))/16);
1290 int digit4 = dec - (digit1*4096 + digit2*256 + digit3*16);
1291
1292 buf[0] = hexArray[digit1];
1293 buf[1] = hexArray[digit2];
1294 buf[2] = hexArray[digit3];
1295 buf[3] = hexArray[digit4];
1296 buf[4] = 0;
1297}
1298
1299// One hex digit to decimal number
1300static int HexToInt1(char hex)
1301{
1302 switch (hex)
1303 {
1304 case '0':
1305 return 0;
1306 case '1':
1307 return 1;
1308 case '2':
1309 return 2;
1310 case '3':
1311 return 3;
1312 case '4':
1313 return 4;
1314 case '5':
1315 return 5;
1316 case '6':
1317 return 6;
1318 case '7':
1319 return 7;
1320 case '8':
1321 return 8;
1322 case '9':
1323 return 9;
1324 case 'A':
1325 return 10;
1326 case 'B':
1327 return 11;
1328 case 'C':
1329 return 12;
1330 case 'D':
1331 return 13;
1332 case 'E':
1333 return 14;
1334 case 'F':
1335 return 15;
1336 default:
1337 return 0;
1338 }
1339 return 0;
1340}
1341
1342// 4-digit hex string to unsigned integer
1343static unsigned long HexToInt(char *buf)
1344{
1345 long d1 = (long)(HexToInt1(buf[0])*4096.0) ;
1346 long d2 = (long)(HexToInt1(buf[1])*256.0) ;
1347 long d3 = (long)(HexToInt1(buf[2])*16.0) ;
1348 long d4 = (long)(HexToInt1(buf[3])) ;
1349 unsigned long n = (long)(d1 + d2 + d3 + d4) ;
1350 return n;
1351}
1352
1353/*
1354 * wxPseudo meta-file
1355 *
1356 */
1357
1358IMPLEMENT_DYNAMIC_CLASS(wxPseudoMetaFile, wxObject)
1359
1360wxPseudoMetaFile::wxPseudoMetaFile()
1361{
1362 m_currentRotation = 0;
1363 m_rotateable = TRUE;
1364 m_width = 0.0;
1365 m_height = 0.0;
1366 m_outlinePen = NULL;
1367 m_fillBrush = NULL;
1368 m_outlineOp = -1;
1369}
1370
1371wxPseudoMetaFile::wxPseudoMetaFile(wxPseudoMetaFile& mf)
1372{
1373 mf.Copy(*this);
1374}
1375
1376wxPseudoMetaFile::~wxPseudoMetaFile()
1377{
1378 Clear();
1379}
1380
1381void wxPseudoMetaFile::Clear()
1382{
1383 wxNode *node = m_ops.First();
1384 while (node)
1385 {
1386 wxDrawOp *op = (wxDrawOp *)node->Data();
1387 delete op;
1388 node = node->Next();
1389 }
1390 m_ops.Clear();
1391 m_gdiObjects.Clear();
1392 m_outlineColours.Clear();
1393 m_fillColours.Clear();
1394 m_outlineOp = -1;
1395}
1396
1397void wxPseudoMetaFile::Draw(wxDC& dc, double xoffset, double yoffset)
1398{
1399 wxNode *node = m_ops.First();
1400 while (node)
1401 {
1402 wxDrawOp *op = (wxDrawOp *)node->Data();
1403 op->Do(dc, xoffset, yoffset);
1404 node = node->Next();
1405 }
1406}
1407
1408void wxPseudoMetaFile::Scale(double sx, double sy)
1409{
1410 wxNode *node = m_ops.First();
1411 while (node)
1412 {
1413 wxDrawOp *op = (wxDrawOp *)node->Data();
1414 op->Scale(sx, sy);
1415 node = node->Next();
1416 }
1417 m_width *= sx;
1418 m_height *= sy;
1419}
1420
1421void wxPseudoMetaFile::Translate(double x, double y)
1422{
1423 wxNode *node = m_ops.First();
1424 while (node)
1425 {
1426 wxDrawOp *op = (wxDrawOp *)node->Data();
1427 op->Translate(x, y);
1428 node = node->Next();
1429 }
1430}
1431
1432void wxPseudoMetaFile::Rotate(double x, double y, double theta)
1433{
1434 double theta1 = theta-m_currentRotation;
1435 if (theta1 == 0.0) return;
1436 double cosTheta = (double)cos(theta1);
1437 double sinTheta = (double)sin(theta1);
1438
1439 wxNode *node = m_ops.First();
1440 while (node)
1441 {
1442 wxDrawOp *op = (wxDrawOp *)node->Data();
1443 op->Rotate(x, y, theta, sinTheta, cosTheta);
1444 node = node->Next();
1445 }
1446 m_currentRotation = theta;
1447}
1448
1449#ifdef PROLOGIO
1450void wxPseudoMetaFile::WriteAttributes(wxExpr *clause, int whichAngle)
1451{
1452 wxString widthStr;
1453 widthStr.Printf("meta_width%d", whichAngle);
1454
1455 wxString heightStr;
1456 heightStr.Printf("meta_height%d", whichAngle);
1457
1458 wxString outlineStr;
1459 outlineStr.Printf("outline_op%d", whichAngle);
1460
1461 wxString rotateableStr;
1462 rotateableStr.Printf("meta_rotateable%d", whichAngle);
1463
1464 // Write width and height
1465 clause->AddAttributeValue(widthStr, m_width);
1466 clause->AddAttributeValue(heightStr, m_height);
1467 clause->AddAttributeValue(rotateableStr, (long)m_rotateable);
1468 clause->AddAttributeValue(outlineStr, (long)m_outlineOp);
1469
1470 // Write GDI objects
1471 char buf[50];
1472 int i = 1;
1473 wxNode *node = m_gdiObjects.First();
1474 while (node)
1475 {
1476 sprintf(buf, "gdi%d_%d", whichAngle, i);
1477 wxObject *obj = (wxObject *)node->Data();
1478 wxExpr *expr = NULL;
1479 if (obj)
1480 {
1481 if (obj->IsKindOf(CLASSINFO(wxPen)))
1482 {
1483 wxPen *thePen = (wxPen *)obj;
1484 expr = new wxExpr(wxExprList);
1485 expr->Append(new wxExpr((long)gyTYPE_PEN));
1486 expr->Append(new wxExpr((long)thePen->GetWidth()));
1487 expr->Append(new wxExpr((long)thePen->GetStyle()));
1488 expr->Append(new wxExpr((long)thePen->GetColour().Red()));
1489 expr->Append(new wxExpr((long)thePen->GetColour().Green()));
1490 expr->Append(new wxExpr((long)thePen->GetColour().Blue()));
1491 }
1492 else if (obj->IsKindOf(CLASSINFO(wxBrush)))
1493 {
1494 wxBrush *theBrush = (wxBrush *)obj;
1495 expr = new wxExpr(wxExprList);
1496 expr->Append(new wxExpr((long)gyTYPE_BRUSH));
1497 expr->Append(new wxExpr((long)theBrush->GetStyle()));
1498 expr->Append(new wxExpr((long)theBrush->GetColour().Red()));
1499 expr->Append(new wxExpr((long)theBrush->GetColour().Green()));
1500 expr->Append(new wxExpr((long)theBrush->GetColour().Blue()));
1501 }
1502 else if (obj->IsKindOf(CLASSINFO(wxFont)))
1503 {
1504 wxFont *theFont = (wxFont *)obj;
1505 expr = new wxExpr(wxExprList);
1506 expr->Append(new wxExpr((long)gyTYPE_FONT));
1507 expr->Append(new wxExpr((long)theFont->GetPointSize()));
1508 expr->Append(new wxExpr((long)theFont->GetFamily()));
1509 expr->Append(new wxExpr((long)theFont->GetStyle()));
1510 expr->Append(new wxExpr((long)theFont->GetWeight()));
1511 expr->Append(new wxExpr((long)theFont->GetUnderlined()));
1512 }
1513 }
1514 else
1515 {
1516 // If no recognised GDI object, append a place holder anyway.
1517 expr = new wxExpr(wxExprList);
1518 expr->Append(new wxExpr((long)0));
1519 }
1520
1521 if (expr)
1522 {
1523 clause->AddAttributeValue(buf, expr);
1524 i ++;
1525 }
1526 node = node->Next();
1527 }
1528
1529 // Write drawing operations
1530 i = 1;
1531 node = m_ops.First();
1532 while (node)
1533 {
1534 sprintf(buf, "op%d_%d", whichAngle, i);
1535 wxDrawOp *op = (wxDrawOp *)node->Data();
1536 wxExpr *expr = op->WriteExpr(this);
1537 if (expr)
1538 {
1539 clause->AddAttributeValue(buf, expr);
1540 i ++;
1541 }
1542 node = node->Next();
1543 }
1544
1545 // Write outline and fill GDI op lists (if any)
1546 if (m_outlineColours.Number() > 0)
1547 {
1548 wxExpr *outlineExpr = new wxExpr(wxExprList);
1549 node = m_outlineColours.First();
1550 while (node)
1551 {
1552 outlineExpr->Append(new wxExpr((long)node->Data()));
1553 node = node->Next();
1554 }
1555 wxString outlineObjectsStr;
1556 outlineObjectsStr.Printf("outline_objects%d", whichAngle);
1557
1558 clause->AddAttributeValue(outlineObjectsStr, outlineExpr);
1559 }
1560 if (m_fillColours.Number() > 0)
1561 {
1562 wxExpr *fillExpr = new wxExpr(wxExprList);
1563 node = m_fillColours.First();
1564 while (node)
1565 {
1566 fillExpr->Append(new wxExpr((long)node->Data()));
1567 node = node->Next();
1568 }
1569 wxString fillObjectsStr;
1570 fillObjectsStr.Printf("fill_objects%d", whichAngle);
1571
1572 clause->AddAttributeValue(fillObjectsStr, fillExpr);
1573 }
1574
1575}
1576
1577void wxPseudoMetaFile::ReadAttributes(wxExpr *clause, int whichAngle)
1578{
1579 wxString widthStr;
1580 widthStr.Printf("meta_width%d", whichAngle);
1581
1582 wxString heightStr;
1583 heightStr.Printf("meta_height%d", whichAngle);
1584
1585 wxString outlineStr;
1586 outlineStr.Printf("outline_op%d", whichAngle);
1587
1588 wxString rotateableStr;
1589 rotateableStr.Printf("meta_rotateable%d", whichAngle);
1590
1591 clause->GetAttributeValue(widthStr, m_width);
1592 clause->GetAttributeValue(heightStr, m_height);
1593 clause->GetAttributeValue(outlineStr, m_outlineOp);
1594
1595 int iVal = (int) m_rotateable;
1596 clause->GetAttributeValue(rotateableStr, iVal);
1597 m_rotateable = (iVal != 0);
1598
1599 // Read GDI objects
1600 char buf[50];
1601 int i = 1;
1602 bool keepGoing = TRUE;
1603 while (keepGoing)
1604 {
1605 sprintf(buf, "gdi%d_%d", whichAngle, i);
1606 wxExpr *expr = NULL;
1607 clause->GetAttributeValue(buf, &expr);
1608 if (!expr)
1609 {
1610 keepGoing = FALSE;
1611 }
1612 else
1613 {
1614 wxExpr *idExpr = expr->Nth(0);
1615 switch (idExpr->IntegerValue())
1616 {
1617 case gyTYPE_PEN:
1618 {
1619 int penWidth = (int)expr->Nth(1)->IntegerValue();
1620 int penStyle = (int)expr->Nth(2)->IntegerValue();
1621 int penRed = (int)expr->Nth(3)->IntegerValue();
1622 int penGreen = (int)expr->Nth(4)->IntegerValue();
1623 int penBlue = (int)expr->Nth(5)->IntegerValue();
1624 wxColour col(penRed, penGreen, penBlue);
1625 wxPen *p = wxThePenList->FindOrCreatePen(col, penWidth, penStyle);
1626 if (!p)
1627 p = wxBLACK_PEN;
1628 m_gdiObjects.Append(p);
1629 break;
1630 }
1631 case gyTYPE_BRUSH:
1632 {
1633 int brushStyle = (int)expr->Nth(1)->IntegerValue();
1634 int brushRed = (int)expr->Nth(2)->IntegerValue();
1635 int brushGreen = (int)expr->Nth(3)->IntegerValue();
1636 int brushBlue = (int)expr->Nth(4)->IntegerValue();
1637 wxColour col(brushRed, brushGreen, brushBlue);
1638 wxBrush *b = wxTheBrushList->FindOrCreateBrush(col, brushStyle);
1639 if (!b)
1640 b = wxWHITE_BRUSH;
1641 m_gdiObjects.Append(b);
1642 break;
1643 }
1644 case gyTYPE_FONT:
1645 {
1646 int fontPointSize = (int)expr->Nth(1)->IntegerValue();
1647 int fontFamily = (int)expr->Nth(2)->IntegerValue();
1648 int fontStyle = (int)expr->Nth(3)->IntegerValue();
1649 int fontWeight = (int)expr->Nth(4)->IntegerValue();
1650 int fontUnderlined = (int)expr->Nth(5)->IntegerValue();
1651 m_gdiObjects.Append(wxTheFontList->FindOrCreateFont(fontPointSize,
1652 fontFamily, fontStyle, fontWeight, (fontUnderlined != 0)));
1653 break;
1654 }
1655 default:
1656 {
1657 // Place holder
1658 m_gdiObjects.Append(NULL);
1659 break;
1660 }
1661 }
1662 i ++;
1663 }
1664 }
1665
1666 // Now read in the operations
1667 keepGoing = TRUE;
1668 i = 1;
1669 while (keepGoing)
1670 {
1671 sprintf(buf, "op%d_%d", whichAngle, i);
1672 wxExpr *expr = NULL;
1673 clause->GetAttributeValue(buf, &expr);
1674 if (!expr)
1675 {
1676 keepGoing = FALSE;
1677 }
1678 else
1679 {
1680 wxExpr *idExpr = expr->Nth(0);
1681 int opId = (int)idExpr->IntegerValue();
1682 switch (opId)
1683 {
1684 case DRAWOP_SET_PEN:
1685 case DRAWOP_SET_BRUSH:
1686 case DRAWOP_SET_FONT:
1687 case DRAWOP_SET_TEXT_COLOUR:
1688 case DRAWOP_SET_BK_COLOUR:
1689 case DRAWOP_SET_BK_MODE:
1690 {
1691 wxOpSetGDI *theOp = new wxOpSetGDI(opId, this, 0);
1692 theOp->ReadExpr(this, expr);
1693 m_ops.Append(theOp);
1694 break;
1695 }
1696
1697 case DRAWOP_SET_CLIPPING_RECT:
1698 case DRAWOP_DESTROY_CLIPPING_RECT:
1699 {
1700 wxOpSetClipping *theOp = new wxOpSetClipping(opId, 0.0, 0.0, 0.0, 0.0);
1701 theOp->ReadExpr(this, expr);
1702 m_ops.Append(theOp);
1703 break;
1704 }
1705
1706 case DRAWOP_DRAW_LINE:
1707 case DRAWOP_DRAW_RECT:
1708 case DRAWOP_DRAW_ROUNDED_RECT:
1709 case DRAWOP_DRAW_ELLIPSE:
1710 case DRAWOP_DRAW_POINT:
1711 case DRAWOP_DRAW_ARC:
1712 case DRAWOP_DRAW_TEXT:
1713 {
1714 wxOpDraw *theOp = new wxOpDraw(opId, 0.0, 0.0, 0.0, 0.0);
1715 theOp->ReadExpr(this, expr);
1716 m_ops.Append(theOp);
1717 break;
1718 }
1719 case DRAWOP_DRAW_SPLINE:
1720 case DRAWOP_DRAW_POLYLINE:
1721 case DRAWOP_DRAW_POLYGON:
1722 {
1723 wxOpPolyDraw *theOp = new wxOpPolyDraw(opId, 0, NULL);
1724 theOp->ReadExpr(this, expr);
1725 m_ops.Append(theOp);
1726 break;
1727 }
1728 default:
1729 break;
1730 }
1731 }
1732 i ++;
1733 }
1734
1735 wxString outlineObjectsStr;
1736 outlineObjectsStr.Printf("outline_objects%d", whichAngle);
1737
1738 // Now read in the list of outline and fill operations, if any
1739 wxExpr *expr1 = clause->AttributeValue(outlineObjectsStr);
1740 if (expr1)
1741 {
1742 wxExpr *eachExpr = expr1->GetFirst();
1743 while (eachExpr)
1744 {
1745 m_outlineColours.Append((wxObject *)eachExpr->IntegerValue());
1746 eachExpr = eachExpr->GetNext();
1747 }
1748 }
1749
1750 wxString fillObjectsStr;
1751 fillObjectsStr.Printf("fill_objects%d", whichAngle);
1752
1753 expr1 = clause->AttributeValue(fillObjectsStr);
1754 if (expr1)
1755 {
1756 wxExpr *eachExpr = expr1->GetFirst();
1757 while (eachExpr)
1758 {
1759 m_fillColours.Append((wxObject *)eachExpr->IntegerValue());
1760 eachExpr = eachExpr->GetNext();
1761 }
1762 }
1763}
1764#endif
1765
1766// Does the copying for this object
1767void wxPseudoMetaFile::Copy(wxPseudoMetaFile& copy)
1768{
1769 copy.Clear();
1770
1771 copy.m_currentRotation = m_currentRotation;
1772 copy.m_width = m_width;
1773 copy.m_height = m_height;
1774 copy.m_rotateable = m_rotateable;
1775 copy.m_fillBrush = m_fillBrush;
1776 copy.m_outlinePen = m_outlinePen;
1777 copy.m_outlineOp = m_outlineOp;
1778
1779 // Copy the GDI objects
1780 wxNode *node = m_gdiObjects.First();
1781 while (node)
1782 {
1783 wxObject *obj = (wxObject *)node->Data();
1784 copy.m_gdiObjects.Append(obj);
1785 node = node->Next();
1786 }
1787
1788 // Copy the operations
1789 node = m_ops.First();
1790 while (node)
1791 {
1792 wxDrawOp *op = (wxDrawOp *)node->Data();
1793 copy.m_ops.Append(op->Copy(&copy));
1794 node = node->Next();
1795 }
1796
1797 // Copy the outline/fill operations
1798 node = m_outlineColours.First();
1799 while (node)
1800 {
1801 copy.m_outlineColours.Append((wxObject *)node->Data());
1802 node = node->Next();
1803 }
1804 node = m_fillColours.First();
1805 while (node)
1806 {
1807 copy.m_fillColours.Append((wxObject *)node->Data());
1808 node = node->Next();
1809 }
1810}
1811
1812/*
1813 * Pass size of existing image; scale height to
1814 * fit width and return new width and height.
1815 *
1816 */
1817
1818bool wxPseudoMetaFile::LoadFromMetaFile(char *filename, double *rwidth, double *rheight)
1819{
1820 if (!FileExists(filename))
1821 return NULL;
1822
1823 wxXMetaFile *metaFile = new wxXMetaFile;
1824
1825 if (!metaFile->ReadFile(filename))
1826 {
1827 delete metaFile;
1828 return FALSE;
1829 }
1830
1831 double lastX = 0.0;
1832 double lastY = 0.0;
1833
1834 // Convert from metafile records to wxDrawnShape records
1835 wxNode *node = metaFile->metaRecords.First();
1836 while (node)
1837 {
1838 wxMetaRecord *record = (wxMetaRecord *)node->Data();
1839 switch (record->metaFunction)
1840 {
1841 case META_SETBKCOLOR:
1842 {
1843 wxOpSetGDI *op = new wxOpSetGDI(DRAWOP_SET_BK_COLOUR, this, 0);
1844 op->m_r = (unsigned char)record->param1;
1845 op->m_g = (unsigned char)record->param2;
1846 op->m_b = (unsigned char)record->param3;
1847 m_ops.Append(op);
1848 break;
1849 }
1850 case META_SETBKMODE:
1851 {
1852 wxOpSetGDI *op = new wxOpSetGDI(DRAWOP_SET_BK_MODE, this, 0, (int)record->param1);
1853 m_ops.Append(op);
1854 break;
1855 }
1856 case META_SETMAPMODE:
1857 {
1858 break;
1859 }
1860// case META_SETROP2:
1861// case META_SETRELABS:
1862// case META_SETPOLYFILLMODE:
1863// case META_SETSTRETCHBLTMODE:
1864// case META_SETTEXTCHAREXTRA:
1865 case META_SETTEXTCOLOR:
1866 {
1867 wxOpSetGDI *op = new wxOpSetGDI(DRAWOP_SET_TEXT_COLOUR, this, 0);
1868 op->m_r = (unsigned char)record->param1;
1869 op->m_g = (unsigned char)record->param2;
1870 op->m_b = (unsigned char)record->param3;
1871 m_ops.Append(op);
1872 break;
1873 }
1874// case META_SETTEXTJUSTIFICATION:
1875// case META_SETWINDOWORG:
1876// case META_SETWINDOWEXT:
1877// case META_SETVIEWPORTORG:
1878// case META_SETVIEWPORTEXT:
1879// case META_OFFSETWINDOWORG:
1880// case META_SCALEWINDOWEXT:
1881// case META_OFFSETVIEWPORTORG:
1882// case META_SCALEVIEWPORTEXT:
1883 case META_LINETO:
1884 {
1885 wxOpDraw *op = new wxOpDraw(DRAWOP_DRAW_LINE, (double)lastX, (double)lastY,
1886 (double)record->param1, (double)record->param2);
1887 m_ops.Append(op);
1888 break;
1889 }
1890 case META_MOVETO:
1891 {
1892 lastX = (double)record->param1;
1893 lastY = (double)record->param2;
1894 break;
1895 }
1896 case META_EXCLUDECLIPRECT:
1897 {
1898/*
1899 wxMetaRecord *rec = new wxMetaRecord(META_EXCLUDECLIPRECT);
1900 rec->param4 = getshort(handle); // m_y2
1901 rec->param3 = getshort(handle); // x2
1902 rec->param2 = getshort(handle); // y1
1903 rec->param1 = getshort(handle); // x1
1904*/
1905 break;
1906 }
1907 case META_INTERSECTCLIPRECT:
1908 {
1909/*
1910 rec->param4 = getshort(handle); // m_y2
1911 rec->param3 = getshort(handle); // x2
1912 rec->param2 = getshort(handle); // y1
1913 rec->param1 = getshort(handle); // x1
1914*/
1915 break;
1916 }
1917// case META_ARC: // DO!!!
1918 case META_ELLIPSE:
1919 {
1920 wxOpDraw *op = new wxOpDraw(DRAWOP_DRAW_ELLIPSE,
1921 (double)record->param1, (double)record->param2,
1922 (double)(record->param3 - record->param1),
1923 (double)(record->param4 - record->param2));
1924 m_ops.Append(op);
1925 break;
1926 }
1927// case META_FLOODFILL:
1928// case META_PIE: // DO!!!
1929 case META_RECTANGLE:
1930 {
1931 wxOpDraw *op = new wxOpDraw(DRAWOP_DRAW_RECT,
1932 (double)record->param1, (double)record->param2,
1933 (double)(record->param3 - record->param1),
1934 (double)(record->param4 - record->param2));
1935 m_ops.Append(op);
1936 break;
1937 }
1938 case META_ROUNDRECT:
1939 {
1940 wxOpDraw *op = new wxOpDraw(DRAWOP_DRAW_ROUNDED_RECT,
1941 (double)record->param1, (double)record->param2,
1942 (double)(record->param3 - record->param1),
1943 (double)(record->param4 - record->param2), (double)record->param5);
1944 m_ops.Append(op);
1945 break;
1946 }
1947// case META_PATBLT:
1948// case META_SAVEDC:
1949 case META_SETPIXEL:
1950 {
1951 wxOpDraw *op = new wxOpDraw(DRAWOP_DRAW_POINT,
1952 (double)record->param1, (double)record->param2,
1953 0.0, 0.0);
1954
1955// SHOULD SET THE COLOUR - SET PEN?
1956// rec->param3 = getint(handle); // COLORREF
1957 m_ops.Append(op);
1958 break;
1959 }
1960// case META_OFFSETCLIPRGN:
1961 case META_TEXTOUT:
1962 {
1963 wxOpDraw *op = new wxOpDraw(DRAWOP_DRAW_TEXT,
1964 (double)record->param1, (double)record->param2,
1965 0.0, 0.0, 0.0, record->stringParam);
1966 m_ops.Append(op);
1967 break;
1968 }
1969// case META_BITBLT:
1970// case META_STRETCHBLT:
1971 case META_POLYGON:
1972 {
1973 int n = (int)record->param1;
1974 wxRealPoint *newPoints = new wxRealPoint[n];
1975 for (int i = 0; i < n; i++)
1976 {
1977 newPoints[i].x = record->points[i].x;
1978 newPoints[i].y = record->points[i].y;
1979 }
1980
1981 wxOpPolyDraw *op = new wxOpPolyDraw(DRAWOP_DRAW_POLYGON, n, newPoints);
1982 m_ops.Append(op);
1983 break;
1984 }
1985 case META_POLYLINE:
1986 {
1987 int n = (int)record->param1;
1988 wxRealPoint *newPoints = new wxRealPoint[n];
1989 for (int i = 0; i < n; i++)
1990 {
1991 newPoints[i].x = record->points[i].x;
1992 newPoints[i].y = record->points[i].y;
1993 }
1994
1995 wxOpPolyDraw *op = new wxOpPolyDraw(DRAWOP_DRAW_POLYLINE, n, newPoints);
1996 m_ops.Append(op);
1997 break;
1998 }
1999// case META_ESCAPE:
2000// case META_RESTOREDC:
2001// case META_FILLREGION:
2002// case META_FRAMEREGION:
2003// case META_INVERTREGION:
2004// case META_PAINTREGION:
2005// case META_SELECTCLIPREGION: // DO THIS!
2006 case META_SELECTOBJECT:
2007 {
2008 // The pen, brush etc. has already been created when the metafile
2009 // was read in, so we don't create it - we set it.
2010 wxNode *recNode = metaFile->gdiObjects.Nth((int)record->param2);
2011 if (recNode)
2012 {
2013 wxMetaRecord *gdiRec = (wxMetaRecord *)recNode->Data();
2014 if (gdiRec && (gdiRec->param1 != 0))
2015 {
2016 wxObject *obj = (wxObject *)gdiRec->param1;
2017 if (obj->IsKindOf(CLASSINFO(wxPen)))
2018 {
2019 wxOpSetGDI *op = new wxOpSetGDI(DRAWOP_SET_PEN, this, (int)record->param2);
2020 m_ops.Append(op);
2021 }
2022 else if (obj->IsKindOf(CLASSINFO(wxBrush)))
2023 {
2024 wxOpSetGDI *op = new wxOpSetGDI(DRAWOP_SET_BRUSH, this, (int)record->param2);
2025 m_ops.Append(op);
2026 }
2027 else if (obj->IsKindOf(CLASSINFO(wxFont)))
2028 {
2029 wxOpSetGDI *op = new wxOpSetGDI(DRAWOP_SET_FONT, this, (int)record->param2);
2030 m_ops.Append(op);
2031 }
2032 }
2033 }
2034 break;
2035 }
2036// case META_SETTEXTALIGN:
2037// case META_DRAWTEXT:
2038// case META_CHORD:
2039// case META_SETMAPPERFLAGS:
2040// case META_EXTTEXTOUT:
2041// case META_SETDIBTODEV:
2042// case META_SELECTPALETTE:
2043// case META_REALIZEPALETTE:
2044// case META_ANIMATEPALETTE:
2045// case META_SETPALENTRIES:
2046// case META_POLYPOLYGON:
2047// case META_RESIZEPALETTE:
2048// case META_DIBBITBLT:
2049// case META_DIBSTRETCHBLT:
2050 case META_DIBCREATEPATTERNBRUSH:
2051 {
2052 // Place holder
2053 m_gdiObjects.Append(NULL);
2054 break;
2055 }
2056// case META_STRETCHDIB:
2057// case META_EXTFLOODFILL:
2058// case META_RESETDC:
2059// case META_STARTDOC:
2060// case META_STARTPAGE:
2061// case META_ENDPAGE:
2062// case META_ABORTDOC:
2063// case META_ENDDOC:
2064// case META_DELETEOBJECT: // DO!!
2065 case META_CREATEPALETTE:
2066 {
2067 // Place holder
2068 m_gdiObjects.Append(NULL);
2069 break;
2070 }
2071 case META_CREATEBRUSH:
2072 {
2073 // Place holder
2074 m_gdiObjects.Append(NULL);
2075 break;
2076 }
2077 case META_CREATEPATTERNBRUSH:
2078 {
2079 // Place holder
2080 m_gdiObjects.Append(NULL);
2081 break;
2082 }
2083 case META_CREATEPENINDIRECT:
2084 {
2085 // The pen is created when the metafile is read in.
2086 // We keep track of all the GDI objects needed for this
2087 // image so when reading the wxDrawnShape from file,
2088 // we can read in all the GDI objects, then refer
2089 // to them by an index starting from zero thereafter.
2090 m_gdiObjects.Append((wxObject *)record->param1);
2091 break;
2092 }
2093 case META_CREATEFONTINDIRECT:
2094 {
2095 m_gdiObjects.Append((wxObject *)record->param1);
2096 break;
2097 }
2098 case META_CREATEBRUSHINDIRECT:
2099 {
2100 // Don't have to do anything here: the pen is created
2101 // when the metafile is read in.
2102 m_gdiObjects.Append((wxObject *)record->param1);
2103 break;
2104 }
2105 case META_CREATEBITMAPINDIRECT:
2106 {
2107 // Place holder
2108 m_gdiObjects.Append(NULL);
2109 break;
2110 }
2111 case META_CREATEBITMAP:
2112 {
2113 // Place holder
2114 m_gdiObjects.Append(NULL);
2115 break;
2116 }
2117 case META_CREATEREGION:
2118 {
2119 // Place holder
2120 m_gdiObjects.Append(NULL);
2121 break;
2122 }
2123 default:
2124 {
2125 break;
2126 }
2127 }
2128 node = node->Next();
2129 }
2130 double actualWidth = (double)fabs(metaFile->right - metaFile->left);
2131 double actualHeight = (double)fabs(metaFile->bottom - metaFile->top);
2132
2133 double initialScaleX = 1.0;
2134 double initialScaleY = 1.0;
2135
2136 double xoffset, yoffset;
2137
2138 // Translate so origin is at centre of rectangle
2139 if (metaFile->bottom > metaFile->top)
2140 yoffset = - (double)((metaFile->bottom - metaFile->top)/2.0);
2141 else
2142 yoffset = - (double)((metaFile->top - metaFile->bottom)/2.0);
2143
2144 if (metaFile->right > metaFile->left)
2145 xoffset = - (double)((metaFile->right - metaFile->left)/2.0);
2146 else
2147 xoffset = - (double)((metaFile->left - metaFile->right)/2.0);
2148
2149 Translate(xoffset, yoffset);
2150
2151 // Scale to a reasonable size (take the width of this wxDrawnShape
2152 // as a guide)
2153 if (actualWidth != 0.0)
2154 {
2155 initialScaleX = (double)((*rwidth) / actualWidth);
2156 initialScaleY = initialScaleX;
2157 (*rheight) = initialScaleY*actualHeight;
2158 }
2159 Scale(initialScaleX, initialScaleY);
2160
2161 m_width = (actualWidth*initialScaleX);
2162 m_height = *rheight;
2163
2164 delete metaFile;
2165 return TRUE;
2166}
2167
2168// Scale to fit size
2169void wxPseudoMetaFile::ScaleTo(double w, double h)
2170{
2171 double scaleX = (double)(w/m_width);
2172 double scaleY = (double)(h/m_height);
2173
2174 // Do the scaling
2175 Scale(scaleX, scaleY);
2176}
2177
2178void wxPseudoMetaFile::GetBounds(double *boundMinX, double *boundMinY, double *boundMaxX, double *boundMaxY)
2179{
2180 double maxX = (double) -99999.9;
2181 double maxY = (double) -99999.9;
2182 double minX = (double) 99999.9;
2183 double minY = (double) 99999.9;
2184
2185 wxNode *node = m_ops.First();
2186 while (node)
2187 {
2188 wxDrawOp *op = (wxDrawOp *)node->Data();
2189 switch (op->GetOp())
2190 {
2191 case DRAWOP_DRAW_LINE:
2192 case DRAWOP_DRAW_RECT:
2193 case DRAWOP_DRAW_ROUNDED_RECT:
2194 case DRAWOP_DRAW_ELLIPSE:
2195 case DRAWOP_DRAW_POINT:
2196 case DRAWOP_DRAW_TEXT:
2197 {
2198 wxOpDraw *opDraw = (wxOpDraw *)op;
2199 if (opDraw->m_x1 < minX) minX = opDraw->m_x1;
2200 if (opDraw->m_x1 > maxX) maxX = opDraw->m_x1;
2201 if (opDraw->m_y1 < minY) minY = opDraw->m_y1;
2202 if (opDraw->m_y1 > maxY) maxY = opDraw->m_y1;
2203 if (op->GetOp() == DRAWOP_DRAW_LINE)
2204 {
2205 if (opDraw->m_x2 < minX) minX = opDraw->m_x2;
2206 if (opDraw->m_x2 > maxX) maxX = opDraw->m_x2;
2207 if (opDraw->m_y2 < minY) minY = opDraw->m_y2;
2208 if (opDraw->m_y2 > maxY) maxY = opDraw->m_y2;
2209 }
2210 else if (op->GetOp() == DRAWOP_DRAW_RECT ||
2211 op->GetOp() == DRAWOP_DRAW_ROUNDED_RECT ||
2212 op->GetOp() == DRAWOP_DRAW_ELLIPSE)
2213 {
2214 if ((opDraw->m_x1 + opDraw->m_x2) < minX) minX = (opDraw->m_x1 + opDraw->m_x2);
2215 if ((opDraw->m_x1 + opDraw->m_x2) > maxX) maxX = (opDraw->m_x1 + opDraw->m_x2);
2216 if ((opDraw->m_y1 + opDraw->m_y2) < minY) minY = (opDraw->m_y1 + opDraw->m_y2);
2217 if ((opDraw->m_y1 + opDraw->m_y2) > maxY) maxY = (opDraw->m_y1 + opDraw->m_y2);
2218 }
2219 break;
2220 }
2221 case DRAWOP_DRAW_ARC:
2222 {
2223 // TODO: don't yet know how to calculate the bounding box
2224 // for an arc. So pretend it's a line; to get a correct
2225 // bounding box, draw a blank rectangle first, of the correct
2226 // size.
2227 wxOpDraw *opDraw = (wxOpDraw *)op;
2228 if (opDraw->m_x1 < minX) minX = opDraw->m_x1;
2229 if (opDraw->m_x1 > maxX) maxX = opDraw->m_x1;
2230 if (opDraw->m_y1 < minY) minY = opDraw->m_y1;
2231 if (opDraw->m_y1 > maxY) maxY = opDraw->m_y1;
2232 if (opDraw->m_x2 < minX) minX = opDraw->m_x2;
2233 if (opDraw->m_x2 > maxX) maxX = opDraw->m_x2;
2234 if (opDraw->m_y2 < minY) minY = opDraw->m_y2;
2235 if (opDraw->m_y2 > maxY) maxY = opDraw->m_y2;
2236 break;
2237 }
2238 case DRAWOP_DRAW_POLYLINE:
2239 case DRAWOP_DRAW_POLYGON:
2240 case DRAWOP_DRAW_SPLINE:
2241 {
2242 wxOpPolyDraw *poly = (wxOpPolyDraw *)op;
2243 for (int i = 0; i < poly->m_noPoints; i++)
2244 {
2245 if (poly->m_points[i].x < minX) minX = poly->m_points[i].x;
2246 if (poly->m_points[i].x > maxX) maxX = poly->m_points[i].x;
2247 if (poly->m_points[i].y < minY) minY = poly->m_points[i].y;
2248 if (poly->m_points[i].y > maxY) maxY = poly->m_points[i].y;
2249 }
2250 break;
2251 }
2252 default:
2253 break;
2254 }
2255 node = node->Next();
2256 }
2257
2258 *boundMinX = minX;
2259 *boundMinY = minY;
2260 *boundMaxX = maxX;
2261 *boundMaxY = maxY;
2262/*
2263 *w = (double)fabs(maxX - minX);
2264 *h = (double)fabs(maxY - minY);
2265*/
2266}
2267
2268// Calculate size from current operations
2269void wxPseudoMetaFile::CalculateSize(wxDrawnShape* shape)
2270{
2271 double boundMinX, boundMinY, boundMaxX, boundMaxY;
2272
2273 GetBounds(& boundMinX, & boundMinY, & boundMaxX, & boundMaxY);
2274
2275 SetSize(boundMaxX - boundMinX, boundMaxY - boundMinY);
2276
2277 if (shape)
2278 {
2279 shape->SetWidth(m_width);
2280 shape->SetHeight(m_height);
2281 }
2282}
2283
2284// Set of functions for drawing into a pseudo metafile.
2285// They use integers, but doubles are used internally for accuracy
2286// when scaling.
2287
2288void wxPseudoMetaFile::DrawLine(const wxPoint& pt1, const wxPoint& pt2)
2289{
2290 wxOpDraw *theOp = new wxOpDraw(DRAWOP_DRAW_LINE,
2291 (double) pt1.x, (double) pt1.y, (double) pt2.x, (double) pt2.y);
2292
2293 m_ops.Append(theOp);
2294}
2295
2296void wxPseudoMetaFile::DrawRectangle(const wxRect& rect)
2297{
2298 wxOpDraw *theOp = new wxOpDraw(DRAWOP_DRAW_RECT,
2299 (double) rect.x, (double) rect.y, (double) rect.width, (double) rect.height);
2300
2301 m_ops.Append(theOp);
2302}
2303
2304void wxPseudoMetaFile::DrawRoundedRectangle(const wxRect& rect, double radius)
2305{
2306 wxOpDraw *theOp = new wxOpDraw(DRAWOP_DRAW_ROUNDED_RECT,
2307 (double) rect.x, (double) rect.y, (double) rect.width, (double) rect.height);
2308
2309 theOp->m_radius = radius;
2310
2311 m_ops.Append(theOp);
2312}
2313
2314void wxPseudoMetaFile::DrawEllipse(const wxRect& rect)
2315{
2316 wxOpDraw *theOp = new wxOpDraw(DRAWOP_DRAW_ELLIPSE,
2317 (double) rect.x, (double) rect.y, (double) rect.width, (double) rect.height);
2318
2319 m_ops.Append(theOp);
2320}
2321
2322void wxPseudoMetaFile::DrawArc(const wxPoint& centrePt, const wxPoint& startPt, const wxPoint& endPt)
2323{
2324 wxOpDraw *theOp = new wxOpDraw(DRAWOP_DRAW_ARC,
2325 (double) centrePt.x, (double) centrePt.y, (double) startPt.x, (double) startPt.y);
2326
2327 theOp->m_x3 = (double) endPt.x;
2328 theOp->m_y3 = (double) endPt.y;
2329
2330 m_ops.Append(theOp);
2331}
2332
2333void wxPseudoMetaFile::DrawEllipticArc(const wxRect& rect, double startAngle, double endAngle)
2334{
2335 const double pi = 3.1415926535897932384626433832795 ;
2336
2337 double startAngleRadians = startAngle* (pi*2.0/360.0);
2338 double endAngleRadians = endAngle* (pi*2.0/360.0);
2339
2340 wxOpDraw *theOp = new wxOpDraw(DRAWOP_DRAW_ELLIPTIC_ARC,
2341 (double) rect.x, (double) rect.y, (double) rect.width, (double) rect.height);
2342
2343 theOp->m_x3 = startAngleRadians;
2344 theOp->m_y3 = endAngleRadians;
2345
2346 m_ops.Append(theOp);
2347}
2348
2349void wxPseudoMetaFile::DrawPoint(const wxPoint& pt)
2350{
2351 wxOpDraw *theOp = new wxOpDraw(DRAWOP_DRAW_POINT,
2352 (double) pt.x, (double) pt.y, 0.0, 0.0);
2353
2354 m_ops.Append(theOp);
2355}
2356
2357void wxPseudoMetaFile::DrawText(const wxString& text, const wxPoint& pt)
2358{
2359 wxOpDraw *theOp = new wxOpDraw(DRAWOP_DRAW_TEXT,
2360 (double) pt.x, (double) pt.y, 0.0, 0.0);
2361
2362 theOp->m_textString = copystring(text);
2363
2364 m_ops.Append(theOp);
2365}
2366
2367void wxPseudoMetaFile::DrawLines(int n, wxPoint pts[])
2368{
2369 wxRealPoint* realPoints = new wxRealPoint[n];
2370 int i;
2371 for (i = 0; i < n; i++)
2372 {
2373 realPoints[i].x = pts[i].x;
2374 realPoints[i].y = pts[i].y;
2375 }
2376 wxOpPolyDraw* theOp = new wxOpPolyDraw(DRAWOP_DRAW_POLYLINE, n, realPoints);
2377 m_ops.Append(theOp);
2378}
2379
2380void wxPseudoMetaFile::DrawPolygon(int n, wxPoint pts[], int flags)
2381{
2382 wxRealPoint* realPoints = new wxRealPoint[n];
2383 int i;
2384 for (i = 0; i < n; i++)
2385 {
2386 realPoints[i].x = pts[i].x;
2387 realPoints[i].y = pts[i].y;
2388 }
2389 wxOpPolyDraw* theOp = new wxOpPolyDraw(DRAWOP_DRAW_POLYGON, n, realPoints);
2390 m_ops.Append(theOp);
2391
2392 if (flags & oglMETAFLAGS_OUTLINE)
2393 m_outlineOp = (m_ops.Number() - 1);
2394}
2395
2396void wxPseudoMetaFile::DrawSpline(int n, wxPoint pts[])
2397{
2398 wxRealPoint* realPoints = new wxRealPoint[n];
2399 int i;
2400 for (i = 0; i < n; i++)
2401 {
2402 realPoints[i].x = pts[i].x;
2403 realPoints[i].y = pts[i].y;
2404 }
2405 wxOpPolyDraw* theOp = new wxOpPolyDraw(DRAWOP_DRAW_SPLINE, n, realPoints);
2406 m_ops.Append(theOp);
2407}
2408
2409void wxPseudoMetaFile::SetClippingRect(const wxRect& rect)
2410{
2411 wxOpSetClipping* theOp = new wxOpSetClipping(DRAWOP_SET_CLIPPING_RECT,
2412 (double) rect.x, (double) rect.y, (double) rect.width, (double) rect.height);
2413}
2414
2415void wxPseudoMetaFile::DestroyClippingRect()
2416{
2417 wxOpSetClipping* theOp = new wxOpSetClipping(DRAWOP_DESTROY_CLIPPING_RECT,
2418 0.0, 0.0, 0.0, 0.0);
2419
2420 m_ops.Append(theOp);
2421}
2422
2423void wxPseudoMetaFile::SetPen(wxPen* pen, bool isOutline)
2424{
2425 m_gdiObjects.Append(pen);
2426 int n = m_gdiObjects.Number();
2427
2428 wxOpSetGDI* theOp = new wxOpSetGDI(DRAWOP_SET_PEN, this, n - 1);
2429
2430 m_ops.Append(theOp);
2431
2432 if (isOutline)
2433 {
2434 m_outlineColours.Append((wxObject*) (n - 1));
2435 }
2436}
2437
2438void wxPseudoMetaFile::SetBrush(wxBrush* brush, bool isFill)
2439{
2440 m_gdiObjects.Append(brush);
2441 int n = m_gdiObjects.Number();
2442
2443 wxOpSetGDI* theOp = new wxOpSetGDI(DRAWOP_SET_BRUSH, this, n - 1);
2444
2445 m_ops.Append(theOp);
2446
2447 if (isFill)
2448 {
2449 m_fillColours.Append((wxObject*) (n - 1));
2450 }
2451}
2452
2453void wxPseudoMetaFile::SetFont(wxFont* font)
2454{
2455 m_gdiObjects.Append(font);
2456 int n = m_gdiObjects.Number();
2457
2458 wxOpSetGDI* theOp = new wxOpSetGDI(DRAWOP_SET_FONT, this, n - 1);
2459
2460 m_ops.Append(theOp);
2461}
2462
2463void wxPseudoMetaFile::SetTextColour(const wxColour& colour)
2464{
2465 wxOpSetGDI* theOp = new wxOpSetGDI(DRAWOP_SET_TEXT_COLOUR, this, 0);
2466 theOp->m_r = colour.Red();
2467 theOp->m_g = colour.Green();
2468 theOp->m_b = colour.Blue();
2469
2470 m_ops.Append(theOp);
2471}
2472
2473void wxPseudoMetaFile::SetBackgroundColour(const wxColour& colour)
2474{
2475 wxOpSetGDI* theOp = new wxOpSetGDI(DRAWOP_SET_BK_COLOUR, this, 0);
2476 theOp->m_r = colour.Red();
2477 theOp->m_g = colour.Green();
2478 theOp->m_b = colour.Blue();
2479
2480 m_ops.Append(theOp);
2481}
2482
2483void wxPseudoMetaFile::SetBackgroundMode(int mode)
2484{
2485 wxOpSetGDI* theOp = new wxOpSetGDI(DRAWOP_SET_BK_MODE, this, 0, mode);
2486
2487 m_ops.Append(theOp);
2488}
2489
wxWidgets (Impactor)