]> git.saurik.com Git - wxWidgets.git/blame - contrib/src/ogl/basic.cpp
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
fixed outdated filenames
[wxWidgets.git] / contrib / src / ogl / basic.cpp
CommitLineData
1fc25a89
JS		 1/////////////////////////////////////////////////////////////////////////////
2// Name: basic.cpp
3// Purpose: Basic OGL classes
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 "basic.h"
14#endif
15
16// For compilers that support precompilation, includes "wx.h".
92a19c2e 17#include "wx/wxprec.h"
1fc25a89
JS		 18
19#ifdef __BORLANDC__
20#pragma hdrstop
21#endif
22
23#ifndef WX_PRECOMP
24#include <wx/wx.h>
25#endif
26
27#include <wx/wxexpr.h>
28
3f1802b5
JS		 29#ifdef new
30#undef new
31#endif
32
1fc25a89
JS		 33#if wxUSE_IOSTREAMH
34#include <iostream.h>
35#else
36#include <iostream>
37#endif
38
39#include <stdio.h>
40#include <ctype.h>
41#include <math.h>
42
43#include <wx/ogl/basic.h>
44#include <wx/ogl/basicp.h>
45#include <wx/ogl/composit.h>
46#include <wx/ogl/lines.h>
47#include <wx/ogl/canvas.h>
48#include <wx/ogl/divided.h>
49#include <wx/ogl/misc.h>
50
51// Control point types
52// Rectangle and most other shapes
53#define CONTROL_POINT_VERTICAL 1
54#define CONTROL_POINT_HORIZONTAL 2
55#define CONTROL_POINT_DIAGONAL 3
56
57// Line
58#define CONTROL_POINT_ENDPOINT_TO 4
59#define CONTROL_POINT_ENDPOINT_FROM 5
60#define CONTROL_POINT_LINE 6
61
62IMPLEMENT_DYNAMIC_CLASS(wxShapeTextLine, wxObject)
63IMPLEMENT_DYNAMIC_CLASS(wxAttachmentPoint, wxObject)
64
65wxShapeTextLine::wxShapeTextLine(double the_x, double the_y, const wxString& the_line)
66{
67 m_x = the_x; m_y = the_y; m_line = the_line;
68}
69
70wxShapeTextLine::~wxShapeTextLine()
71{
72}
73
74IMPLEMENT_ABSTRACT_CLASS(wxShapeEvtHandler, wxObject)
75
76wxShapeEvtHandler::wxShapeEvtHandler(wxShapeEvtHandler *prev, wxShape *shape)
77{
78 m_previousHandler = prev;
79 m_handlerShape = shape;
80}
81
82wxShapeEvtHandler::~wxShapeEvtHandler()
83{
84}
85
86// Creates a copy of this event handler.
87wxShapeEvtHandler* wxShapeEvtHandler::CreateNewCopy()
88{
89 wxShapeEvtHandler* newObject = (wxShapeEvtHandler*) GetClassInfo()->CreateObject();
90
91 wxASSERT( (newObject != NULL) );
92 wxASSERT( (newObject->IsKindOf(CLASSINFO(wxShapeEvtHandler))) );
93
94 newObject->m_previousHandler = newObject;
95
96 CopyData(*newObject);
97
98 return newObject;
99}
100
101
102void wxShapeEvtHandler::OnDelete()
103{
104 if (this != GetShape())
105 delete this;
106}
107
108void wxShapeEvtHandler::OnDraw(wxDC& dc)
109{
110 if (m_previousHandler)
111 m_previousHandler->OnDraw(dc);
112}
113
114void wxShapeEvtHandler::OnMoveLinks(wxDC& dc)
115{
116 if (m_previousHandler)
117 m_previousHandler->OnMoveLinks(dc);
118}
119
120void wxShapeEvtHandler::OnMoveLink(wxDC& dc, bool moveControlPoints)
121{
122 if (m_previousHandler)
123 m_previousHandler->OnMoveLink(dc, moveControlPoints);
124}
125
126void wxShapeEvtHandler::OnDrawContents(wxDC& dc)
127{
128 if (m_previousHandler)
129 m_previousHandler->OnDrawContents(dc);
130}
131
132void wxShapeEvtHandler::OnDrawBranches(wxDC& dc, bool erase)
133{
134 if (m_previousHandler)
135 m_previousHandler->OnDrawBranches(dc, erase);
136}
137
138void wxShapeEvtHandler::OnSize(double x, double y)
139{
140 if (m_previousHandler)
141 m_previousHandler->OnSize(x, y);
142}
143
144bool wxShapeEvtHandler::OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display)
145{
146 if (m_previousHandler)
147 return m_previousHandler->OnMovePre(dc, x, y, old_x, old_y, display);
148 else
149 return TRUE;
150}
151
152void wxShapeEvtHandler::OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display)
153{
154 if (m_previousHandler)
155 m_previousHandler->OnMovePost(dc, x, y, old_x, old_y, display);
156}
157
158void wxShapeEvtHandler::OnErase(wxDC& dc)
159{
160 if (m_previousHandler)
161 m_previousHandler->OnErase(dc);
162}
163
164void wxShapeEvtHandler::OnEraseContents(wxDC& dc)
165{
166 if (m_previousHandler)
167 m_previousHandler->OnEraseContents(dc);
168}
169
170void wxShapeEvtHandler::OnHighlight(wxDC& dc)
171{
172 if (m_previousHandler)
173 m_previousHandler->OnHighlight(dc);
174}
175
176void wxShapeEvtHandler::OnLeftClick(double x, double y, int keys, int attachment)
177{
178 if (m_previousHandler)
179 m_previousHandler->OnLeftClick(x, y, keys, attachment);
180}
181
182void wxShapeEvtHandler::OnLeftDoubleClick(double x, double y, int keys, int attachment)
183{
184 if (m_previousHandler)
185 m_previousHandler->OnLeftDoubleClick(x, y, keys, attachment);
186}
187
188void wxShapeEvtHandler::OnRightClick(double x, double y, int keys, int attachment)
189{
190 if (m_previousHandler)
191 m_previousHandler->OnRightClick(x, y, keys, attachment);
192}
193
194void wxShapeEvtHandler::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
195{
196 if (m_previousHandler)
197 m_previousHandler->OnDragLeft(draw, x, y, keys, attachment);
198}
199
200void wxShapeEvtHandler::OnBeginDragLeft(double x, double y, int keys, int attachment)
201{
202 if (m_previousHandler)
203 m_previousHandler->OnBeginDragLeft(x, y, keys, attachment);
204}
205
206void wxShapeEvtHandler::OnEndDragLeft(double x, double y, int keys, int attachment)
207{
208 if (m_previousHandler)
209 m_previousHandler->OnEndDragLeft(x, y, keys, attachment);
210}
211
212void wxShapeEvtHandler::OnDragRight(bool draw, double x, double y, int keys, int attachment)
213{
214 if (m_previousHandler)
215 m_previousHandler->OnDragRight(draw, x, y, keys, attachment);
216}
217
218void wxShapeEvtHandler::OnBeginDragRight(double x, double y, int keys, int attachment)
219{
220 if (m_previousHandler)
221 m_previousHandler->OnBeginDragRight(x, y, keys, attachment);
222}
223
224void wxShapeEvtHandler::OnEndDragRight(double x, double y, int keys, int attachment)
225{
226 if (m_previousHandler)
227 m_previousHandler->OnEndDragRight(x, y, keys, attachment);
228}
229
230// Control points ('handles') redirect control to the actual shape, to make it easier
231// to override sizing behaviour.
232void wxShapeEvtHandler::OnSizingDragLeft(wxControlPoint* pt, bool draw, double x, double y, int keys, int attachment)
233{
234 if (m_previousHandler)
235 m_previousHandler->OnSizingDragLeft(pt, draw, x, y, keys, attachment);
236}
237
238void wxShapeEvtHandler::OnSizingBeginDragLeft(wxControlPoint* pt, double x, double y, int keys, int attachment)
239{
240 if (m_previousHandler)
241 m_previousHandler->OnSizingBeginDragLeft(pt, x, y, keys, attachment);
242}
243
244void wxShapeEvtHandler::OnSizingEndDragLeft(wxControlPoint* pt, double x, double y, int keys, int attachment)
245{
246 if (m_previousHandler)
247 m_previousHandler->OnSizingEndDragLeft(pt, x, y, keys, attachment);
248}
249
250void wxShapeEvtHandler::OnDrawOutline(wxDC& dc, double x, double y, double w, double h)
251{
252 if (m_previousHandler)
253 m_previousHandler->OnDrawOutline(dc, x, y, w, h);
254}
255
256void wxShapeEvtHandler::OnDrawControlPoints(wxDC& dc)
257{
258 if (m_previousHandler)
259 m_previousHandler->OnDrawControlPoints(dc);
260}
261
262void wxShapeEvtHandler::OnEraseControlPoints(wxDC& dc)
263{
264 if (m_previousHandler)
265 m_previousHandler->OnEraseControlPoints(dc);
266}
267
268// Can override this to prevent or intercept line reordering.
269void wxShapeEvtHandler::OnChangeAttachment(int attachment, wxLineShape* line, wxList& ordering)
270{
271 if (m_previousHandler)
272 m_previousHandler->OnChangeAttachment(attachment, line, ordering);
273}
274
275IMPLEMENT_ABSTRACT_CLASS(wxShape, wxShapeEvtHandler)
276
277wxShape::wxShape(wxShapeCanvas *can)
278{
279 m_eventHandler = this;
280 SetShape(this);
281 m_id = 0;
282 m_formatted = FALSE;
283 m_canvas = can;
284 m_xpos = 0.0; m_ypos = 0.0;
285 m_pen = g_oglBlackPen;
286 m_brush = wxWHITE_BRUSH;
287 m_font = g_oglNormalFont;
288 m_textColour = wxBLACK;
289 m_textColourName = "BLACK";
290 m_visible = FALSE;
1fc25a89
JS		 291 m_selected = FALSE;
292 m_attachmentMode = ATTACHMENT_MODE_NONE;
293 m_spaceAttachments = TRUE;
294 m_disableLabel = FALSE;
295 m_fixedWidth = FALSE;
296 m_fixedHeight = FALSE;
297 m_drawHandles = TRUE;
298 m_sensitivity = OP_ALL;
299 m_draggable = TRUE;
300 m_parent = NULL;
301 m_formatMode = FORMAT_CENTRE_HORIZ | FORMAT_CENTRE_VERT;
302 m_shadowMode = SHADOW_NONE;
303 m_shadowOffsetX = 6;
304 m_shadowOffsetY = 6;
305 m_shadowBrush = wxBLACK_BRUSH;
306 m_textMarginX = 5;
307 m_textMarginY = 5;
308 m_regionName = "0";
309 m_centreResize = TRUE;
310 m_maintainAspectRatio = FALSE;
311 m_highlighted = FALSE;
312 m_rotation = 0.0;
313 m_branchNeckLength = 10;
314 m_branchStemLength = 10;
315 m_branchSpacing = 10;
316 m_branchStyle = BRANCHING_ATTACHMENT_NORMAL;
317
318 // Set up a default region. Much of the above will be put into
319 // the region eventually (the duplication is for compatibility)
320 wxShapeRegion *region = new wxShapeRegion;
321 m_regions.Append(region);
322 region->SetName("0");
323 region->SetFont(g_oglNormalFont);
324 region->SetFormatMode(FORMAT_CENTRE_HORIZ | FORMAT_CENTRE_VERT);
325 region->SetColour("BLACK");
326}
327
328wxShape::~wxShape()
329{
330 if (m_parent)
331 m_parent->GetChildren().DeleteObject(this);
332
333 ClearText();
334 ClearRegions();
335 ClearAttachments();
336
337 if (m_canvas)
338 m_canvas->RemoveShape(this);
339
340 GetEventHandler()->OnDelete();
341}
342
343void wxShape::SetHighlight(bool hi, bool recurse)
344{
345 m_highlighted = hi;
346 if (recurse)
347 {
348 wxNode *node = m_children.First();
349 while (node)
350 {
351 wxShape *child = (wxShape *)node->Data();
352 child->SetHighlight(hi, recurse);
353 node = node->Next();
354 }
355 }
356}
357
358void wxShape::SetSensitivityFilter(int sens, bool recursive)
359{
360 if (sens & OP_DRAG_LEFT)
361 m_draggable = TRUE;
362 else
363 m_draggable = FALSE;
364
365 m_sensitivity = sens;
366 if (recursive)
367 {
368 wxNode *node = m_children.First();
369 while (node)
370 {
371 wxShape *obj = (wxShape *)node->Data();
372 obj->SetSensitivityFilter(sens, TRUE);
373 node = node->Next();
374 }
375 }
376}
377
378void wxShape::SetDraggable(bool drag, bool recursive)
379{
380 m_draggable = drag;
381 if (m_draggable)
382 m_sensitivity |= OP_DRAG_LEFT;
383 else
384 if (m_sensitivity & OP_DRAG_LEFT)
385 m_sensitivity = m_sensitivity - OP_DRAG_LEFT;
386
387 if (recursive)
388 {
389 wxNode *node = m_children.First();
390 while (node)
391 {
392 wxShape *obj = (wxShape *)node->Data();
393 obj->SetDraggable(drag, TRUE);
394 node = node->Next();
395 }
396 }
397}
398
399void wxShape::SetDrawHandles(bool drawH)
400{
401 m_drawHandles = drawH;
402 wxNode *node = m_children.First();
403 while (node)
404 {
405 wxShape *obj = (wxShape *)node->Data();
406 obj->SetDrawHandles(drawH);
407 node = node->Next();
408 }
409}
410
411void wxShape::SetShadowMode(int mode, bool redraw)
412{
413 if (redraw && GetCanvas())
414 {
415 wxClientDC dc(GetCanvas());
416 GetCanvas()->PrepareDC(dc);
417 Erase(dc);
418
419 m_shadowMode = mode;
420
421 Draw(dc);
422 }
423 else
424 {
425 m_shadowMode = mode;
426 }
427}
428
429void wxShape::SetCanvas(wxShapeCanvas *theCanvas)
430{
431 m_canvas = theCanvas;
432 wxNode *node = m_children.First();
433 while (node)
434 {
435 wxShape *child = (wxShape *)node->Data();
436 child->SetCanvas(theCanvas);
437 node = node->Next();
438 }
439}
440
441void wxShape::AddToCanvas(wxShapeCanvas *theCanvas, wxShape *addAfter)
442{
443 theCanvas->AddShape(this, addAfter);
444 wxNode *node = m_children.First();
445 wxShape *lastImage = this;
446 while (node)
447 {
448 wxShape *object = (wxShape *)node->Data();
449 object->AddToCanvas(theCanvas, lastImage);
450 lastImage = object;
451
452 node = node->Next();
453 }
454}
455
456// Insert at front of canvas
457void wxShape::InsertInCanvas(wxShapeCanvas *theCanvas)
458{
459 theCanvas->InsertShape(this);
460 wxNode *node = m_children.First();
461 wxShape *lastImage = this;
462 while (node)
463 {
464 wxShape *object = (wxShape *)node->Data();
465 object->AddToCanvas(theCanvas, lastImage);
466 lastImage = object;
467
468 node = node->Next();
469 }
470}
471
472void wxShape::RemoveFromCanvas(wxShapeCanvas *theCanvas)
473{
474 if (Selected())
475 Select(FALSE);
476 theCanvas->RemoveShape(this);
477 wxNode *node = m_children.First();
478 while (node)
479 {
480 wxShape *object = (wxShape *)node->Data();
481 object->RemoveFromCanvas(theCanvas);
482
483 node = node->Next();
484 }
485}
486
487void wxShape::ClearAttachments()
488{
489 wxNode *node = m_attachmentPoints.First();
490 while (node)
491 {
492 wxAttachmentPoint *point = (wxAttachmentPoint *)node->Data();
493 delete point;
494 node = node->Next();
495 }
496 m_attachmentPoints.Clear();
497}
498
499void wxShape::ClearText(int regionId)
500{
501 if (regionId == 0)
502 {
503 m_text.DeleteContents(TRUE);
504 m_text.Clear();
505 m_text.DeleteContents(FALSE);
506 }
507 wxNode *node = m_regions.Nth(regionId);
508 if (!node)
509 return;
510 wxShapeRegion *region = (wxShapeRegion *)node->Data();
511 region->ClearText();
512}
513
514void wxShape::ClearRegions()
515{
516 wxNode *node = m_regions.First();
517 while (node)
518 {
519 wxShapeRegion *region = (wxShapeRegion *)node->Data();
520 wxNode *next = node->Next();
521 delete region;
522 delete node;
523 node = next;
524 }
525}
526
527void wxShape::AddRegion(wxShapeRegion *region)
528{
529 m_regions.Append(region);
530}
531
532void wxShape::SetDefaultRegionSize()
533{
534 wxNode *node = m_regions.First();
535 if (!node) return;
536 wxShapeRegion *region = (wxShapeRegion *)node->Data();
537 double w, h;
538 GetBoundingBoxMin(&w, &h);
539 region->SetSize(w, h);
540}
541
542bool wxShape::HitTest(double x, double y, int *attachment, double *distance)
543{
544// if (!sensitive)
545// return FALSE;
546
547 double width = 0.0, height = 0.0;
548 GetBoundingBoxMin(&width, &height);
549 if (fabs(width) < 4.0) width = 4.0;
550 if (fabs(height) < 4.0) height = 4.0;
551
552 width += (double)4.0; height += (double)4.0; // Allowance for inaccurate mousing
553
554 double left = (double)(m_xpos - (width/2.0));
555 double top = (double)(m_ypos - (height/2.0));
556 double right = (double)(m_xpos + (width/2.0));
557 double bottom = (double)(m_ypos + (height/2.0));
558
559 int nearest_attachment = 0;
560
561 // If within the bounding box, check the attachment points
562 // within the object.
563
564 if (x >= left && x <= right && y >= top && y <= bottom)
565 {
566 int n = GetNumberOfAttachments();
567 double nearest = 999999.0;
568
569 // GetAttachmentPosition[Edge] takes a logical attachment position,
570 // i.e. if it's rotated through 90%, position 0 is East-facing.
571
572 for (int i = 0; i < n; i++)
573 {
574 double xp, yp;
575 if (GetAttachmentPositionEdge(i, &xp, &yp))
576 {
577 double l = (double)sqrt(((xp - x) * (xp - x)) +
578 ((yp - y) * (yp - y)));
579
580 if (l < nearest)
581 {
582 nearest = l;
583 nearest_attachment = i;
584 }
585 }
586 }
587 *attachment = nearest_attachment;
588 *distance = nearest;
589 return TRUE;
590 }
591 else return FALSE;
592}
593
594// Format a text string according to the region size, adding
595// strings with positions to region text list
596
597static bool GraphicsInSizeToContents = FALSE; // Infinite recursion elimination
598void wxShape::FormatText(wxDC& dc, const wxString& s, int i)
599{
600 double w, h;
601 ClearText(i);
602
603 if (m_regions.Number() < 1)
604 return;
605 wxNode *node = m_regions.Nth(i);
606 if (!node)
607 return;
608
609 wxShapeRegion *region = (wxShapeRegion *)node->Data();
610 region->SetText(s);
611 dc.SetFont(* region->GetFont());
612
613 region->GetSize(&w, &h);
614
615 wxStringList *stringList = oglFormatText(dc, s, (w-5), (h-5), region->GetFormatMode());
616 node = stringList->First();
617 while (node)
618 {
619 char *s = (char *)node->Data();
620 wxShapeTextLine *line = new wxShapeTextLine(0.0, 0.0, s);
621 region->GetFormattedText().Append((wxObject *)line);
622 node = node->Next();
623 }
624 delete stringList;
625 double actualW = w;
626 double actualH = h;
627 // Don't try to resize an object with more than one image (this case should be dealt
628 // with by overriden handlers)
629 if ((region->GetFormatMode() & FORMAT_SIZE_TO_CONTENTS) &&
630 (region->GetFormattedText().Number() > 0) &&
631 (m_regions.Number() == 1) && !GraphicsInSizeToContents)
632 {
633 oglGetCentredTextExtent(dc, &(region->GetFormattedText()), m_xpos, m_ypos, w, h, &actualW, &actualH);
634 if ((actualW+m_textMarginX != w ) || (actualH+m_textMarginY != h))
635 {
636 // If we are a descendant of a composite, must make sure the composite gets
637 // resized properly
638 wxShape *topAncestor = GetTopAncestor();
639
640 if (topAncestor != this)
641 {
642 // Make sure we don't recurse infinitely
643 GraphicsInSizeToContents = TRUE;
644
645 wxCompositeShape *composite = (wxCompositeShape *)topAncestor;
646 composite->Erase(dc);
647 SetSize(actualW+m_textMarginX, actualH+m_textMarginY);
648 Move(dc, m_xpos, m_ypos);
649 composite->CalculateSize();
650 if (composite->Selected())
651 {
652 composite->DeleteControlPoints(& dc);
653 composite->MakeControlPoints();
654 composite->MakeMandatoryControlPoints();
655 }
656 // Where infinite recursion might happen if we didn't stop it
657 composite->Draw(dc);
658
659 GraphicsInSizeToContents = FALSE;
660 }
661 else
662 {
663 Erase(dc);
664 SetSize(actualW+m_textMarginX, actualH+m_textMarginY);
665 Move(dc, m_xpos, m_ypos);
666 }
667 SetSize(actualW+m_textMarginX, actualH+m_textMarginY);
668 Move(dc, m_xpos, m_ypos);
669 EraseContents(dc);
670 }
671 }
672 oglCentreText(dc, &(region->GetFormattedText()), m_xpos, m_ypos, actualW, actualH, region->GetFormatMode());
673 m_formatted = TRUE;
674}
675
676void wxShape::Recentre(wxDC& dc)
677{
678 double w, h;
679 GetBoundingBoxMin(&w, &h);
680
681 int noRegions = m_regions.Number();
682 for (int i = 0; i < noRegions; i++)
683 {
684 wxNode *node = m_regions.Nth(i);
685 if (node)
686 {
687 wxShapeRegion *region = (wxShapeRegion *)node->Data();
688 oglCentreText(dc, &(region->GetFormattedText()), m_xpos, m_ypos, w, h, region->GetFormatMode());
689 }
690 }
691}
692
693bool wxShape::GetPerimeterPoint(double x1, double y1,
694 double x2, double y2,
695 double *x3, double *y3)
696{
697 return FALSE;
698}
699
700void wxShape::SetPen(wxPen *the_pen)
701{
702 m_pen = the_pen;
703}
704
705void wxShape::SetBrush(wxBrush *the_brush)
706{
707 m_brush = the_brush;
708}
709
710// Get the top-most (non-division) ancestor, or self
711wxShape *wxShape::GetTopAncestor()
712{
713 if (!GetParent())
714 return this;
715
716 if (GetParent()->IsKindOf(CLASSINFO(wxDivisionShape)))
717 return this;
718 else return GetParent()->GetTopAncestor();
719}
720
721/*
722 * Region functions
723 *
724 */
725void wxShape::SetFont(wxFont *the_font, int regionId)
726{
727 m_font = the_font;
728 wxNode *node = m_regions.Nth(regionId);
729 if (!node)
730 return;
731 wxShapeRegion *region = (wxShapeRegion *)node->Data();
732 region->SetFont(the_font);
733}
734
735wxFont *wxShape::GetFont(int n) const
736{
737 wxNode *node = m_regions.Nth(n);
738 if (!node)
739 return NULL;
740 wxShapeRegion *region = (wxShapeRegion *)node->Data();
741 return region->GetFont();
742}
743
744void wxShape::SetFormatMode(int mode, int regionId)
745{
746 wxNode *node = m_regions.Nth(regionId);
747 if (!node)
748 return;
749 wxShapeRegion *region = (wxShapeRegion *)node->Data();
750 region->SetFormatMode(mode);
751}
752
753int wxShape::GetFormatMode(int regionId) const
754{
755 wxNode *node = m_regions.Nth(regionId);
756 if (!node)
757 return 0;
758 wxShapeRegion *region = (wxShapeRegion *)node->Data();
759 return region->GetFormatMode();
760}
761
762void wxShape::SetTextColour(const wxString& the_colour, int regionId)
763{
764 wxColour *wxcolour = wxTheColourDatabase->FindColour(the_colour);
765 m_textColour = wxcolour;
766 m_textColourName = the_colour;
767
768 wxNode *node = m_regions.Nth(regionId);
769 if (!node)
770 return;
771 wxShapeRegion *region = (wxShapeRegion *)node->Data();
772 region->SetColour(the_colour);
773}
774
775wxString wxShape::GetTextColour(int regionId) const
776{
777 wxNode *node = m_regions.Nth(regionId);
778 if (!node)
779 return wxString("");
780 wxShapeRegion *region = (wxShapeRegion *)node->Data();
781 return region->GetColour();
782}
783
784void wxShape::SetRegionName(const wxString& name, int regionId)
785{
786 wxNode *node = m_regions.Nth(regionId);
787 if (!node)
788 return;
789 wxShapeRegion *region = (wxShapeRegion *)node->Data();
790 region->SetName(name);
791}
792
793wxString wxShape::GetRegionName(int regionId)
794{
795 wxNode *node = m_regions.Nth(regionId);
796 if (!node)
797 return wxString("");
798 wxShapeRegion *region = (wxShapeRegion *)node->Data();
799 return region->GetName();
800}
801
802int wxShape::GetRegionId(const wxString& name)
803{
804 wxNode *node = m_regions.First();
805 int i = 0;
806 while (node)
807 {
808 wxShapeRegion *region = (wxShapeRegion *)node->Data();
809 if (region->GetName() == name)
810 return i;
811 node = node->Next();
812 i ++;
813 }
814 return -1;
815}
816
817// Name all m_regions in all subimages recursively.
818void wxShape::NameRegions(const wxString& parentName)
819{
820 int n = GetNumberOfTextRegions();
c1fa2fda 821 wxString buff;
1fc25a89
JS		 822 for (int i = 0; i < n; i++)
823 {
824 if (parentName.Length() > 0)
c1fa2fda 825 buff << parentName << "." << i;
1fc25a89 826 else
c1fa2fda
RD		 827 buff << i;
828 SetRegionName(buff, i);
1fc25a89
JS		 829 }
830 wxNode *node = m_children.First();
831 int j = 0;
832 while (node)
833 {
c1fa2fda 834 buff.Empty();
1fc25a89
JS		 835 wxShape *child = (wxShape *)node->Data();
836 if (parentName.Length() > 0)
f29c1773 837 buff << parentName << "." << j;
1fc25a89 838 else
f29c1773 839 buff << j;
c1fa2fda 840 child->NameRegions(buff);
1fc25a89
JS		 841 node = node->Next();
842 j ++;
843 }
844}
845
846// Get a region by name, possibly looking recursively into composites.
847wxShape *wxShape::FindRegion(const wxString& name, int *regionId)
848{
849 int id = GetRegionId(name);
850 if (id > -1)
851 {
852 *regionId = id;
853 return this;
854 }
855
856 wxNode *node = m_children.First();
857 while (node)
858 {
859 wxShape *child = (wxShape *)node->Data();
860 wxShape *actualImage = child->FindRegion(name, regionId);
861 if (actualImage)
862 return actualImage;
863 node = node->Next();
864 }
865 return NULL;
866}
867
868// Finds all region names for this image (composite or simple).
869// Supply empty string list.
870void wxShape::FindRegionNames(wxStringList& list)
871{
872 int n = GetNumberOfTextRegions();
873 for (int i = 0; i < n; i++)
874 {
875 wxString name(GetRegionName(i));
c1fa2fda 876 list.Add(name);
1fc25a89
JS		 877 }
878
879 wxNode *node = m_children.First();
880 while (node)
881 {
882 wxShape *child = (wxShape *)node->Data();
883 child->FindRegionNames(list);
884 node = node->Next();
885 }
886}
887
888void wxShape::AssignNewIds()
889{
890// if (m_id == 0)
891 m_id = wxNewId();
892 wxNode *node = m_children.First();
893 while (node)
894 {
895 wxShape *child = (wxShape *)node->Data();
896 child->AssignNewIds();
897 node = node->Next();
898 }
899}
900
901void wxShape::OnDraw(wxDC& dc)
902{
903}
904
905void wxShape::OnMoveLinks(wxDC& dc)
906{
907 // Want to set the ends of all attached links
908 // to point to/from this object
909
910 wxNode *current = m_lines.First();
911 while (current)
912 {
913 wxLineShape *line = (wxLineShape *)current->Data();
914 line->GetEventHandler()->OnMoveLink(dc);
915 current = current->Next();
916 }
917}
918
919
920void wxShape::OnDrawContents(wxDC& dc)
921{
922 double bound_x, bound_y;
923 GetBoundingBoxMin(&bound_x, &bound_y);
924 if (m_regions.Number() < 1) return;
925
926 if (m_pen) dc.SetPen(* m_pen);
927
928 wxShapeRegion *region = (wxShapeRegion *)m_regions.First()->Data();
929 if (region->GetFont()) dc.SetFont(* region->GetFont());
930
931 dc.SetTextForeground(* (region->GetActualColourObject()));
932 dc.SetBackgroundMode(wxTRANSPARENT);
933 if (!m_formatted)
934 {
935 oglCentreText(dc, &(region->GetFormattedText()), m_xpos, m_ypos, bound_x, bound_y, region->GetFormatMode());
936 m_formatted = TRUE;
937 }
938 if (!GetDisableLabel())
939 {
940 oglDrawFormattedText(dc, &(region->GetFormattedText()), m_xpos, m_ypos, bound_x, bound_y, region->GetFormatMode());
941 }
942}
943
944void wxShape::DrawContents(wxDC& dc)
945{
946 GetEventHandler()->OnDrawContents(dc);
947}
948
949void wxShape::OnSize(double x, double y)
950{
951}
952
953bool wxShape::OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display)
954{
955 return TRUE;
956}
957
958void wxShape::OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display)
959{
960}
961
962void wxShape::OnErase(wxDC& dc)
963{
964 if (!m_visible)
965 return;
966
967 // Erase links
968 wxNode *current = m_lines.First();
969 while (current)
970 {
971 wxLineShape *line = (wxLineShape *)current->Data();
972 line->GetEventHandler()->OnErase(dc);
973 current = current->Next();
974 }
975 GetEventHandler()->OnEraseContents(dc);
976}
977
978void wxShape::OnEraseContents(wxDC& dc)
979{
980 if (!m_visible)
981 return;
982
983 double maxX, maxY, minX, minY;
984 double xp = GetX();
985 double yp = GetY();
986 GetBoundingBoxMin(&minX, &minY);
987 GetBoundingBoxMax(&maxX, &maxY);
988 double topLeftX = (double)(xp - (maxX / 2.0) - 2.0);
989 double topLeftY = (double)(yp - (maxY / 2.0) - 2.0);
990
991 int penWidth = 0;
992 if (m_pen)
993 penWidth = m_pen->GetWidth();
994
67d54b58
RD		 995 dc.SetPen(GetBackgroundPen());
996 dc.SetBrush(GetBackgroundBrush());
997
1fc25a89
JS		 998 dc.DrawRectangle(WXROUND(topLeftX - penWidth), WXROUND(topLeftY - penWidth),
999 WXROUND(maxX + penWidth*2.0 + 4.0), WXROUND(maxY + penWidth*2.0 + 4.0));
1000}
1001
1002void wxShape::EraseLinks(wxDC& dc, int attachment, bool recurse)
1003{
1004 if (!m_visible)
1005 return;
1006
1007 wxNode *current = m_lines.First();
1008 while (current)
1009 {
1010 wxLineShape *line = (wxLineShape *)current->Data();
1011 if (attachment == -1 || ((line->GetTo() == this && line->GetAttachmentTo() == attachment) ||
1012 (line->GetFrom() == this && line->GetAttachmentFrom() == attachment)))
1013 line->GetEventHandler()->OnErase(dc);
1014 current = current->Next();
1015 }
1016 if (recurse)
1017 {
1018 wxNode *node = m_children.First();
1019 while (node)
1020 {
1021 wxShape *child = (wxShape *)node->Data();
1022 child->EraseLinks(dc, attachment, recurse);
1023 node = node->Next();
1024 }
1025 }
1026}
1027
1028void wxShape::DrawLinks(wxDC& dc, int attachment, bool recurse)
1029{
1030 if (!m_visible)
1031 return;
1032
1033 wxNode *current = m_lines.First();
1034 while (current)
1035 {
1036 wxLineShape *line = (wxLineShape *)current->Data();
1037 if (attachment == -1 ||
1038 (line->GetTo() == this && line->GetAttachmentTo() == attachment) ||
1039 (line->GetFrom() == this && line->GetAttachmentFrom() == attachment))
1040 line->Draw(dc);
1041 current = current->Next();
1042 }
1043 if (recurse)
1044 {
1045 wxNode *node = m_children.First();
1046 while (node)
1047 {
1048 wxShape *child = (wxShape *)node->Data();
1049 child->DrawLinks(dc, attachment, recurse);
1050 node = node->Next();
1051 }
1052 }
1053}
1054
1055// Returns TRUE if pt1 <= pt2 in the sense that one point comes before another on an
1056// edge of the shape.
1057// attachmentPoint is the attachment point (= side) in question.
1058
1059// This is the default, rectangular implementation.
1060bool wxShape::AttachmentSortTest(int attachmentPoint, const wxRealPoint& pt1, const wxRealPoint& pt2)
1061{
1062 int physicalAttachment = LogicalToPhysicalAttachment(attachmentPoint);
1063 switch (physicalAttachment)
1064 {
1065 case 0:
1066 case 2:
1067 {
1068 return (pt1.x <= pt2.x) ;
1069 break;
1070 }
1071 case 1:
1072 case 3:
1073 {
1074 return (pt1.y <= pt2.y) ;
1075 break;
1076 }
1077 }
1078
1079 return FALSE;
1080}
1081
1082bool wxShape::MoveLineToNewAttachment(wxDC& dc, wxLineShape *to_move,
1083 double x, double y)
1084{
1085 if (GetAttachmentMode() == ATTACHMENT_MODE_NONE)
1086 return FALSE;
1087
1088 int newAttachment, oldAttachment;
1089 double distance;
1090
1091 // Is (x, y) on this object? If so, find the new attachment point
1092 // the user has moved the point to
1093 bool hit = HitTest(x, y, &newAttachment, &distance);
1094 if (!hit)
1095 return FALSE;
1096
1097 EraseLinks(dc);
1098
1099 if (to_move->GetTo() == this)
1100 oldAttachment = to_move->GetAttachmentTo();
1101 else
1102 oldAttachment = to_move->GetAttachmentFrom();
1103
1104 // The links in a new ordering.
1105 wxList newOrdering;
1106
1107 // First, add all links to the new list.
1108 wxNode *node = m_lines.First();
1109 while (node)
1110 {
1111 newOrdering.Append(node->Data());
1112 node = node->Next();
1113 }
1114
1115 // Delete the line object from the list of links; we're going to move
1116 // it to another position in the list
1117 newOrdering.DeleteObject(to_move);
1118
1119 double old_x = (double) -99999.9;
1120 double old_y = (double) -99999.9;
1121
1122 node = newOrdering.First();
1123 bool found = FALSE;
1124
1125 while (!found && node)
1126 {
1127 wxLineShape *line = (wxLineShape *)node->Data();
1128 if ((line->GetTo() == this && oldAttachment == line->GetAttachmentTo()) ||
1129 (line->GetFrom() == this && oldAttachment == line->GetAttachmentFrom()))
1130 {
1131 double startX, startY, endX, endY;
1132 double xp, yp;
1133 line->GetEnds(&startX, &startY, &endX, &endY);
1134 if (line->GetTo() == this)
1135 {
1136 xp = endX;
1137 yp = endY;
1138 } else
1139 {
1140 xp = startX;
1141 yp = startY;
1142 }
1143
1144 wxRealPoint thisPoint(xp, yp);
1145 wxRealPoint lastPoint(old_x, old_y);
1146 wxRealPoint newPoint(x, y);
1147
1148 if (AttachmentSortTest(newAttachment, newPoint, thisPoint) && AttachmentSortTest(newAttachment, lastPoint, newPoint))
1149 {
1150 found = TRUE;
1151 newOrdering.Insert(node, to_move);
1152 }
1153
1154 old_x = xp;
1155 old_y = yp;
1156 }
1157 node = node->Next();
1158 }
1159
1160 if (!found)
1161 newOrdering.Append(to_move);
1162
1163 GetEventHandler()->OnChangeAttachment(newAttachment, to_move, newOrdering);
1164
1165 return TRUE;
1166}
1167
1168void wxShape::OnChangeAttachment(int attachment, wxLineShape* line, wxList& ordering)
1169{
1170 if (line->GetTo() == this)
1171 line->SetAttachmentTo(attachment);
1172 else
1173 line->SetAttachmentFrom(attachment);
1174
1175 ApplyAttachmentOrdering(ordering);
1176
1177 wxClientDC dc(GetCanvas());
1178 GetCanvas()->PrepareDC(dc);
1179
1180 MoveLinks(dc);
1181
1182 if (!GetCanvas()->GetQuickEditMode()) GetCanvas()->Redraw(dc);
1183}
1184
1185// Reorders the lines according to the given list.
1186void wxShape::ApplyAttachmentOrdering(wxList& linesToSort)
1187{
1188 // This is a temporary store of all the lines.
1189 wxList linesStore;
1190
1191 wxNode *node = m_lines.First();
1192 while (node)
1193 {
1194 wxLineShape *line = (wxLineShape *)node->Data();
1195 linesStore.Append(line);
1196 node = node->Next();;
1197 }
1198
1199 m_lines.Clear();
1200
1201 node = linesToSort.First();
1202 while (node)
1203 {
1204 wxLineShape *line = (wxLineShape *)node->Data();
1205 if (linesStore.Member(line))
1206 {
1207 // Done this one
1208 linesStore.DeleteObject(line);
1209 m_lines.Append(line);
1210 }
1211 node = node->Next();
1212 }
1213
1214 // Now add any lines that haven't been listed in linesToSort.
1215 node = linesStore.First();
1216 while (node)
1217 {
1218 wxLineShape *line = (wxLineShape *)node->Data();
1219 m_lines.Append(line);
1220 node = node->Next();
1221 }
1222}
1223
1224// Reorders the lines coming into the node image at this attachment
1225// position, in the order in which they appear in linesToSort.
1226// Any remaining lines not in the list will be added to the end.
1227void wxShape::SortLines(int attachment, wxList& linesToSort)
1228{
1229 // This is a temporary store of all the lines at this attachment
1230 // point. We'll tick them off as we've processed them.
1231 wxList linesAtThisAttachment;
1232
1233 wxNode *node = m_lines.First();
1234 while (node)
1235 {
1236 wxLineShape *line = (wxLineShape *)node->Data();
1237 wxNode *next = node->Next();
1238 if ((line->GetTo() == this && line->GetAttachmentTo() == attachment) ||
1239 (line->GetFrom() == this && line->GetAttachmentFrom() == attachment))
1240 {
1241 linesAtThisAttachment.Append(line);
1242 delete node;
1243 node = next;
1244 }
1245 else node = node->Next();
1246 }
1247
1248 node = linesToSort.First();
1249 while (node)
1250 {
1251 wxLineShape *line = (wxLineShape *)node->Data();
1252 if (linesAtThisAttachment.Member(line))
1253 {
1254 // Done this one
1255 linesAtThisAttachment.DeleteObject(line);
1256 m_lines.Append(line);
1257 }
1258 node = node->Next();
1259 }
1260
1261 // Now add any lines that haven't been listed in linesToSort.
1262 node = linesAtThisAttachment.First();
1263 while (node)
1264 {
1265 wxLineShape *line = (wxLineShape *)node->Data();
1266 m_lines.Append(line);
1267 node = node->Next();
1268 }
1269}
1270
1271void wxShape::OnHighlight(wxDC& dc)
1272{
1273}
1274
1275void wxShape::OnLeftClick(double x, double y, int keys, int attachment)
1276{
1277 if ((m_sensitivity & OP_CLICK_LEFT) != OP_CLICK_LEFT)
1278 {
1279 attachment = 0;
1280 double dist;
1281 if (m_parent)
1282 {
1283 m_parent->HitTest(x, y, &attachment, &dist);
1284 m_parent->GetEventHandler()->OnLeftClick(x, y, keys, attachment);
1285 }
1286 return;
1287 }
1288}
1289
1290void wxShape::OnRightClick(double x, double y, int keys, int attachment)
1291{
1292 if ((m_sensitivity & OP_CLICK_RIGHT) != OP_CLICK_RIGHT)
1293 {
1294 attachment = 0;
1295 double dist;
1296 if (m_parent)
1297 {
1298 m_parent->HitTest(x, y, &attachment, &dist);
1299 m_parent->GetEventHandler()->OnRightClick(x, y, keys, attachment);
1300 }
1301 return;
1302 }
1303}
1304
1305double DragOffsetX = 0.0;
1306double DragOffsetY = 0.0;
1307
1308void wxShape::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
1309{
1310 if ((m_sensitivity & OP_DRAG_LEFT) != OP_DRAG_LEFT)
1311 {
1312 attachment = 0;
1313 double dist;
1314 if (m_parent)
1315 {
1316 m_parent->HitTest(x, y, &attachment, &dist);
1317 m_parent->GetEventHandler()->OnDragLeft(draw, x, y, keys, attachment);
1318 }
1319 return;
1320 }
1321
1322 wxClientDC dc(GetCanvas());
1323 GetCanvas()->PrepareDC(dc);
1324
1325 dc.SetLogicalFunction(OGLRBLF);
1326
1327 wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1328 dc.SetPen(dottedPen);
1329 dc.SetBrush(* wxTRANSPARENT_BRUSH);
1330
1331 double xx, yy;
1332 xx = x + DragOffsetX;
1333 yy = y + DragOffsetY;
1334
1335 m_canvas->Snap(&xx, &yy);
1336// m_xpos = xx; m_ypos = yy;
1337 double w, h;
1338 GetBoundingBoxMax(&w, &h);
1339 GetEventHandler()->OnDrawOutline(dc, xx, yy, w, h);
1340}
1341
1342void wxShape::OnBeginDragLeft(double x, double y, int keys, int attachment)
1343{
1344 if ((m_sensitivity & OP_DRAG_LEFT) != OP_DRAG_LEFT)
1345 {
1346 attachment = 0;
1347 double dist;
1348 if (m_parent)
1349 {
1350 m_parent->HitTest(x, y, &attachment, &dist);
1351 m_parent->GetEventHandler()->OnBeginDragLeft(x, y, keys, attachment);
1352 }
1353 return;
1354 }
1355
1356 DragOffsetX = m_xpos - x;
1357 DragOffsetY = m_ypos - y;
1358
1359 wxClientDC dc(GetCanvas());
1360 GetCanvas()->PrepareDC(dc);
1361
1362 // New policy: don't erase shape until end of drag.
1363// Erase(dc);
1364
1365 double xx, yy;
1366 xx = x + DragOffsetX;
1367 yy = y + DragOffsetY;
1368 m_canvas->Snap(&xx, &yy);
1369// m_xpos = xx; m_ypos = yy;
1370 dc.SetLogicalFunction(OGLRBLF);
1371
1372 wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1373 dc.SetPen(dottedPen);
1374 dc.SetBrush((* wxTRANSPARENT_BRUSH));
1375
1376 double w, h;
1377 GetBoundingBoxMax(&w, &h);
1378 GetEventHandler()->OnDrawOutline(dc, xx, yy, w, h);
1379 m_canvas->CaptureMouse();
1380}
1381
1382void wxShape::OnEndDragLeft(double x, double y, int keys, int attachment)
1383{
1384 m_canvas->ReleaseMouse();
1385 if ((m_sensitivity & OP_DRAG_LEFT) != OP_DRAG_LEFT)
1386 {
1387 attachment = 0;
1388 double dist;
1389 if (m_parent)
1390 {
1391 m_parent->HitTest(x, y, &attachment, &dist);
1392 m_parent->GetEventHandler()->OnEndDragLeft(x, y, keys, attachment);
1393 }
1394 return;
1395 }
1396
1397 wxClientDC dc(GetCanvas());
1398 GetCanvas()->PrepareDC(dc);
1399
1400 dc.SetLogicalFunction(wxCOPY);
1401
1402 double xx = x + DragOffsetX;
1403 double yy = y + DragOffsetY;
1404 m_canvas->Snap(&xx, &yy);
1405// canvas->Snap(&m_xpos, &m_ypos);
1406
1407 // New policy: erase shape at end of drag.
1408 Erase(dc);
1409
1410 Move(dc, xx, yy);
1411 if (m_canvas && !m_canvas->GetQuickEditMode()) m_canvas->Redraw(dc);
1412}
1413
1414void wxShape::OnDragRight(bool draw, double x, double y, int keys, int attachment)
1415{
1416 if ((m_sensitivity & OP_DRAG_RIGHT) != OP_DRAG_RIGHT)
1417 {
1418 attachment = 0;
1419 double dist;
1420 if (m_parent)
1421 {
1422 m_parent->HitTest(x, y, &attachment, &dist);
1423 m_parent->GetEventHandler()->OnDragRight(draw, x, y, keys, attachment);
1424 }
1425 return;
1426 }
1427}
1428
1429void wxShape::OnBeginDragRight(double x, double y, int keys, int attachment)
1430{
1431 if ((m_sensitivity & OP_DRAG_RIGHT) != OP_DRAG_RIGHT)
1432 {
1433 attachment = 0;
1434 double dist;
1435 if (m_parent)
1436 {
1437 m_parent->HitTest(x, y, &attachment, &dist);
1438 m_parent->GetEventHandler()->OnBeginDragRight(x, y, keys, attachment);
1439 }
1440 return;
1441 }
1442}
1443
1444void wxShape::OnEndDragRight(double x, double y, int keys, int attachment)
1445{
1446 if ((m_sensitivity & OP_DRAG_RIGHT) != OP_DRAG_RIGHT)
1447 {
1448 attachment = 0;
1449 double dist;
1450 if (m_parent)
1451 {
1452 m_parent->HitTest(x, y, &attachment, &dist);
1453 m_parent->GetEventHandler()->OnEndDragRight(x, y, keys, attachment);
1454 }
1455 return;
1456 }
1457}
1458
1459void wxShape::OnDrawOutline(wxDC& dc, double x, double y, double w, double h)
1460{
1461 double top_left_x = (double)(x - w/2.0);
1462 double top_left_y = (double)(y - h/2.0);
1463 double top_right_x = (double)(top_left_x + w);
1464 double top_right_y = (double)top_left_y;
1465 double bottom_left_x = (double)top_left_x;
1466 double bottom_left_y = (double)(top_left_y + h);
1467 double bottom_right_x = (double)top_right_x;
1468 double bottom_right_y = (double)bottom_left_y;
1469
1470 wxPoint points[5];
1471 points[0].x = WXROUND(top_left_x); points[0].y = WXROUND(top_left_y);
1472 points[1].x = WXROUND(top_right_x); points[1].y = WXROUND(top_right_y);
1473 points[2].x = WXROUND(bottom_right_x); points[2].y = WXROUND(bottom_right_y);
1474 points[3].x = WXROUND(bottom_left_x); points[3].y = WXROUND(bottom_left_y);
1475 points[4].x = WXROUND(top_left_x); points[4].y = WXROUND(top_left_y);
1476
1477 dc.DrawLines(5, points);
1478}
1479
1480void wxShape::Attach(wxShapeCanvas *can)
1481{
1482 m_canvas = can;
1483}
1484
1485void wxShape::Detach()
1486{
1487 m_canvas = NULL;
1488}
1489
1490void wxShape::Move(wxDC& dc, double x, double y, bool display)
1491{
1492 double old_x = m_xpos;
1493 double old_y = m_ypos;
1494
1495 if (!GetEventHandler()->OnMovePre(dc, x, y, old_x, old_y, display))
1496 {
1497// m_xpos = old_x;
1498// m_ypos = old_y;
1499 return;
1500 }
1501
1502 m_xpos = x; m_ypos = y;
1503
1504 ResetControlPoints();
1505
1506 if (display)
1507 Draw(dc);
1508
1509 MoveLinks(dc);
1510
1511 GetEventHandler()->OnMovePost(dc, x, y, old_x, old_y, display);
1512}
1513
1514void wxShape::MoveLinks(wxDC& dc)
1515{
1516 GetEventHandler()->OnMoveLinks(dc);
1517}
1518
1519
1520void wxShape::Draw(wxDC& dc)
1521{
1522 if (m_visible)
1523 {
1524 GetEventHandler()->OnDraw(dc);
1525 GetEventHandler()->OnDrawContents(dc);
1526 GetEventHandler()->OnDrawControlPoints(dc);
1527 GetEventHandler()->OnDrawBranches(dc);
1528 }
1529}
1530
1531void wxShape::Flash()
1532{
1533 if (GetCanvas())
1534 {
1535 wxClientDC dc(GetCanvas());
1536 GetCanvas()->PrepareDC(dc);
1537
1538 dc.SetLogicalFunction(OGLRBLF);
1539 Draw(dc);
1540 dc.SetLogicalFunction(wxCOPY);
1541 Draw(dc);
1542 }
1543}
1544
1545void wxShape::Show(bool show)
1546{
1547 m_visible = show;
1548 wxNode *node = m_children.First();
1549 while (node)
1550 {
1551 wxShape *image = (wxShape *)node->Data();
1552 image->Show(show);
1553 node = node->Next();
1554 }
1555}
1556
1557void wxShape::Erase(wxDC& dc)
1558{
1559 GetEventHandler()->OnErase(dc);
1560 GetEventHandler()->OnEraseControlPoints(dc);
1561 GetEventHandler()->OnDrawBranches(dc, TRUE);
1562}
1563
1564void wxShape::EraseContents(wxDC& dc)
1565{
1566 GetEventHandler()->OnEraseContents(dc);
1567}
1568
1569void wxShape::AddText(const wxString& string)
1570{
1571 wxNode *node = m_regions.First();
1572 if (!node)
1573 return;
1574 wxShapeRegion *region = (wxShapeRegion *)node->Data();
1575 region->ClearText();
1576 wxShapeTextLine *new_line =
1577 new wxShapeTextLine(0.0, 0.0, string);
1578 region->GetFormattedText().Append(new_line);
1579
1580 m_formatted = FALSE;
1581}
1582
1583void wxShape::SetSize(double x, double y, bool recursive)
1584{
1585 SetAttachmentSize(x, y);
1586 SetDefaultRegionSize();
1587}
1588
1589void wxShape::SetAttachmentSize(double w, double h)
1590{
1591 double scaleX;
1592 double scaleY;
1593 double width, height;
1594 GetBoundingBoxMin(&width, &height);
1595 if (width == 0.0)
1596 scaleX = 1.0;
1597 else scaleX = w/width;
1598 if (height == 0.0)
1599 scaleY = 1.0;
1600 else scaleY = h/height;
1601
1602 wxNode *node = m_attachmentPoints.First();
1603 while (node)
1604 {
1605 wxAttachmentPoint *point = (wxAttachmentPoint *)node->Data();
1606 point->m_x = (double)(point->m_x * scaleX);
1607 point->m_y = (double)(point->m_y * scaleY);
1608 node = node->Next();
1609 }
1610}
1611
1612// Add line FROM this object
1613void wxShape::AddLine(wxLineShape *line, wxShape *other,
1614 int attachFrom, int attachTo,
1615 // The line ordering
1616 int positionFrom, int positionTo)
1617{
1618 if (positionFrom == -1)
1619 {
1620 if (!m_lines.Member(line))
1621 m_lines.Append(line);
1622 }
1623 else
1624 {
1625 // Don't preserve old ordering if we have new ordering instructions
1626 m_lines.DeleteObject(line);
1627 if (positionFrom < m_lines.Number())
1628 {
1629 wxNode* node = m_lines.Nth(positionFrom);
1630 m_lines.Insert(node, line);
1631 }
1632 else
1633 m_lines.Append(line);
1634 }
1635
1636 if (positionTo == -1)
1637 {
1638 if (!other->m_lines.Member(line))
1639 other->m_lines.Append(line);
1640 }
1641 else
1642 {
1643 // Don't preserve old ordering if we have new ordering instructions
1644 other->m_lines.DeleteObject(line);
1645 if (positionTo < other->m_lines.Number())
1646 {
1647 wxNode* node = other->m_lines.Nth(positionTo);
1648 other->m_lines.Insert(node, line);
1649 }
1650 else
1651 other->m_lines.Append(line);
1652 }
1653#if 0
1654 // Wrong: doesn't preserve ordering of shape already linked
1655 m_lines.DeleteObject(line);
1656 other->m_lines.DeleteObject(line);
1657
1658 if (positionFrom == -1)
1659 m_lines.Append(line);
1660 else
1661 {
1662 if (positionFrom < m_lines.Number())
1663 {
1664 wxNode* node = m_lines.Nth(positionFrom);
1665 m_lines.Insert(node, line);
1666 }
1667 else
1668 m_lines.Append(line);
1669 }
1670
1671 if (positionTo == -1)
1672 other->m_lines.Append(line);
1673 else
1674 {
1675 if (positionTo < other->m_lines.Number())
1676 {
1677 wxNode* node = other->m_lines.Nth(positionTo);
1678 other->m_lines.Insert(node, line);
1679 }
1680 else
1681 other->m_lines.Append(line);
1682 }
1683#endif
1684
1685 line->SetFrom(this);
1686 line->SetTo(other);
1687 line->SetAttachments(attachFrom, attachTo);
1688}
1689
1690void wxShape::RemoveLine(wxLineShape *line)
1691{
1692 if (line->GetFrom() == this)
1693 line->GetTo()->m_lines.DeleteObject(line);
1694 else
1695 line->GetFrom()->m_lines.DeleteObject(line);
1696
1697 m_lines.DeleteObject(line);
1698}
1699
1700#ifdef PROLOGIO
1701void wxShape::WriteAttributes(wxExpr *clause)
1702{
1703 clause->AddAttributeValueString("type", GetClassInfo()->GetClassName());
1704 clause->AddAttributeValue("id", m_id);
1705
1706 if (m_pen)
1707 {
1708 int penWidth = m_pen->GetWidth();
1709 int penStyle = m_pen->GetStyle();
1710 if (penWidth != 1)
1711 clause->AddAttributeValue("pen_width", (long)penWidth);
1712 if (penStyle != wxSOLID)
1713 clause->AddAttributeValue("pen_style", (long)penStyle);
1714
1715 wxString penColour = wxTheColourDatabase->FindName(m_pen->GetColour());
1716 if (penColour == "")
1717 {
1718 wxString hex(oglColourToHex(m_pen->GetColour()));
1719 hex = wxString("#") + hex;
1720 clause->AddAttributeValueString("pen_colour", hex);
1721 }
1722 else if (penColour != "BLACK")
1723 clause->AddAttributeValueString("pen_colour", penColour);
1724 }
1725
1726 if (m_brush)
1727 {
1728 wxString brushColour = wxTheColourDatabase->FindName(m_brush->GetColour());
1729
1730 if (brushColour == "")
1731 {
1732 wxString hex(oglColourToHex(m_brush->GetColour()));
1733 hex = wxString("#") + hex;
1734 clause->AddAttributeValueString("brush_colour", hex);
1735 }
1736 else if (brushColour != "WHITE")
1737 clause->AddAttributeValueString("brush_colour", brushColour);
1738
1739 if (m_brush->GetStyle() != wxSOLID)
1740 clause->AddAttributeValue("brush_style", (long)m_brush->GetStyle());
1741 }
1742
1743 // Output line ids
1744
1745 int n_lines = m_lines.Number();
1746 if (n_lines > 0)
1747 {
1748 wxExpr *list = new wxExpr(wxExprList);
1749 wxNode *node = m_lines.First();
1750 while (node)
1751 {
1752 wxShape *line = (wxShape *)node->Data();
1753 wxExpr *id_expr = new wxExpr(line->GetId());
1754 list->Append(id_expr);
1755 node = node->Next();
1756 }
1757 clause->AddAttributeValue("arcs", list);
1758 }
1759
1760 // Miscellaneous members
1761 if (m_attachmentMode != 0)
1762 clause->AddAttributeValue("use_attachments", (long)m_attachmentMode);
1763 if (m_sensitivity != OP_ALL)
1764 clause->AddAttributeValue("sensitivity", (long)m_sensitivity);
1765 if (!m_spaceAttachments)
1766 clause->AddAttributeValue("space_attachments", (long)m_spaceAttachments);
1767 if (m_fixedWidth)
1768 clause->AddAttributeValue("fixed_width", (long)m_fixedWidth);
1769 if (m_fixedHeight)
1770 clause->AddAttributeValue("fixed_height", (long)m_fixedHeight);
1771 if (m_shadowMode != SHADOW_NONE)
1772 clause->AddAttributeValue("shadow_mode", (long)m_shadowMode);
1773 if (m_centreResize != TRUE)
1774 clause->AddAttributeValue("centre_resize", (long)0);
1775 clause->AddAttributeValue("maintain_aspect_ratio", (long) m_maintainAspectRatio);
1776 if (m_highlighted != FALSE)
1777 clause->AddAttributeValue("hilite", (long)m_highlighted);
1778
1779 if (m_parent) // For composite objects
1780 clause->AddAttributeValue("parent", (long)m_parent->GetId());
1781
1782 if (m_rotation != 0.0)
1783 clause->AddAttributeValue("rotation", m_rotation);
1784
1785 if (!this->IsKindOf(CLASSINFO(wxLineShape)))
1786 {
1787 clause->AddAttributeValue("neck_length", (long) m_branchNeckLength);
1788 clause->AddAttributeValue("stem_length", (long) m_branchStemLength);
1789 clause->AddAttributeValue("branch_spacing", (long) m_branchSpacing);
1790 clause->AddAttributeValue("branch_style", (long) m_branchStyle);
1791 }
1792
1793 // Write user-defined attachment points, if any
1794 if (m_attachmentPoints.Number() > 0)
1795 {
1796 wxExpr *attachmentList = new wxExpr(wxExprList);
1797 wxNode *node = m_attachmentPoints.First();
1798 while (node)
1799 {
1800 wxAttachmentPoint *point = (wxAttachmentPoint *)node->Data();
1801 wxExpr *pointExpr = new wxExpr(wxExprList);
1802 pointExpr->Append(new wxExpr((long)point->m_id));
1803 pointExpr->Append(new wxExpr(point->m_x));
1804 pointExpr->Append(new wxExpr(point->m_y));
1805 attachmentList->Append(pointExpr);
1806 node = node->Next();
1807 }
1808 clause->AddAttributeValue("user_attachments", attachmentList);
1809 }
1810
1811 // Write text regions
1812 WriteRegions(clause);
1813}
1814
1815void wxShape::WriteRegions(wxExpr *clause)
1816{
1817 // Output regions as region1 = (...), region2 = (...), etc
1818 // and formatted text as text1 = (...), text2 = (...) etc.
1819 int regionNo = 1;
1820 char regionNameBuf[20];
1821 char textNameBuf[20];
1822 wxNode *node = m_regions.First();
1823 while (node)
1824 {
1825 wxShapeRegion *region = (wxShapeRegion *)node->Data();
1826 sprintf(regionNameBuf, "region%d", regionNo);
1827 sprintf(textNameBuf, "text%d", regionNo);
1828
1829 // Original text and region attributes:
1830 // region1 = (regionName regionText x y width height minWidth minHeight proportionX proportionY
1831 // formatMode fontSize fontFamily fontStyle fontWeight textColour)
1832 wxExpr *regionExpr = new wxExpr(wxExprList);
1833 regionExpr->Append(new wxExpr(wxExprString, region->m_regionName));
1834 regionExpr->Append(new wxExpr(wxExprString, region->m_regionText));
1835
1836 regionExpr->Append(new wxExpr(region->m_x));
1837 regionExpr->Append(new wxExpr(region->m_y));
1838 regionExpr->Append(new wxExpr(region->GetWidth()));
1839 regionExpr->Append(new wxExpr(region->GetHeight()));
1840
1841 regionExpr->Append(new wxExpr(region->m_minWidth));
1842 regionExpr->Append(new wxExpr(region->m_minHeight));
1843 regionExpr->Append(new wxExpr(region->m_regionProportionX));
1844 regionExpr->Append(new wxExpr(region->m_regionProportionY));
1845
1846 regionExpr->Append(new wxExpr((long)region->m_formatMode));
1847
1848 regionExpr->Append(new wxExpr((long)(region->m_font ? region->m_font->GetPointSize() : 10)));
1849 regionExpr->Append(new wxExpr((long)(region->m_font ? region->m_font->GetFamily() : wxDEFAULT)));
1850 regionExpr->Append(new wxExpr((long)(region->m_font ? region->m_font->GetStyle() : wxDEFAULT)));
1851 regionExpr->Append(new wxExpr((long)(region->m_font ? region->m_font->GetWeight() : wxNORMAL)));
1852 regionExpr->Append(new wxExpr(wxExprString, region->m_textColour));
1853
1854 // New members for pen colour/style
1855 regionExpr->Append(new wxExpr(wxExprString, region->m_penColour));
1856 regionExpr->Append(new wxExpr((long)region->m_penStyle));
1857
1858 // Formatted text:
1859 // text1 = ((x y string) (x y string) ...)
1860 wxExpr *textExpr = new wxExpr(wxExprList);
1861
1862 wxNode *textNode = region->m_formattedText.First();
1863 while (textNode)
1864 {
1865 wxShapeTextLine *line = (wxShapeTextLine *)textNode->Data();
1866 wxExpr *list2 = new wxExpr(wxExprList);
1867 list2->Append(new wxExpr(line->GetX()));
1868 list2->Append(new wxExpr(line->GetY()));
1869 list2->Append(new wxExpr(wxExprString, line->GetText()));
1870 textExpr->Append(list2);
1871 textNode = textNode->Next();
1872 }
1873
1874 // Now add both attributes to the clause
1875 clause->AddAttributeValue(regionNameBuf, regionExpr);
1876 clause->AddAttributeValue(textNameBuf, textExpr);
1877
1878 node = node->Next();
1879 regionNo ++;
1880 }
1881}
1882
1883void wxShape::ReadAttributes(wxExpr *clause)
1884{
1885 clause->GetAttributeValue("id", m_id);
1886 wxRegisterId(m_id);
1887
1888 clause->GetAttributeValue("x", m_xpos);
1889 clause->GetAttributeValue("y", m_ypos);
1890
1891 // Input text strings (FOR COMPATIBILITY WITH OLD FILES ONLY. SEE REGION CODE BELOW.)
1892 ClearText();
1893 wxExpr *strings = clause->AttributeValue("text");
1894 if (strings && strings->Type() == wxExprList)
1895 {
1896 m_formatted = TRUE; // Assume text is formatted unless we prove otherwise
1897 wxExpr *node = strings->value.first;
1898 while (node)
1899 {
1900 wxExpr *string_expr = node;
1901 double the_x = 0.0;
1902 double the_y = 0.0;
1903 wxString the_string("");
1904
1905 // string_expr can either be a string, or a list of
1906 // 3 elements: x, y, and string.
1907 if (string_expr->Type() == wxExprString)
1908 {
1909 the_string = string_expr->StringValue();
1910 m_formatted = FALSE;
1911 }
1912 else if (string_expr->Type() == wxExprList)
1913 {
1914 wxExpr *first = string_expr->value.first;
1915 wxExpr *second = first ? first->next : (wxExpr*) NULL;
1916 wxExpr *third = second ? second->next : (wxExpr*) NULL;
1917
1918 if (first && second && third &&
1919 (first->Type() == wxExprReal || first->Type() == wxExprInteger) &&
1920 (second->Type() == wxExprReal || second->Type() == wxExprInteger) &&
1921 third->Type() == wxExprString)
1922 {
1923 if (first->Type() == wxExprReal)
1924 the_x = first->RealValue();
1925 else the_x = (double)first->IntegerValue();
1926
1927 if (second->Type() == wxExprReal)
1928 the_y = second->RealValue();
1929 else the_y = (double)second->IntegerValue();
1930
1931 the_string = third->StringValue();
1932 }
1933 }
1934 wxShapeTextLine *line =
c1fa2fda 1935 new wxShapeTextLine(the_x, the_y, the_string);
1fc25a89
JS		 1936 m_text.Append(line);
1937
1938 node = node->next;
1939 }
1940 }
1941
1942 wxString pen_string = "";
1943 wxString brush_string = "";
1944 int pen_width = 1;
1945 int pen_style = wxSOLID;
1946 int brush_style = wxSOLID;
1947 m_attachmentMode = ATTACHMENT_MODE_NONE;
1948
1949 clause->GetAttributeValue("pen_colour", pen_string);
1950 clause->GetAttributeValue("text_colour", m_textColourName);
1951
1952 SetTextColour(m_textColourName);
1953
1954 clause->GetAttributeValue("region_name", m_regionName);
1955
1956 clause->GetAttributeValue("brush_colour", brush_string);
1957 clause->GetAttributeValue("pen_width", pen_width);
1958 clause->GetAttributeValue("pen_style", pen_style);
1959 clause->GetAttributeValue("brush_style", brush_style);
1960
1961 int iVal = (int) m_attachmentMode;
1962 clause->GetAttributeValue("use_attachments", iVal);
1963 m_attachmentMode = iVal;
1964
1965 clause->GetAttributeValue("sensitivity", m_sensitivity);
1966
1967 iVal = (int) m_spaceAttachments;
1968 clause->GetAttributeValue("space_attachments", iVal);
1969 m_spaceAttachments = (iVal != 0);
1970
1971 iVal = (int) m_fixedWidth;
1972 clause->GetAttributeValue("fixed_width", iVal);
1973 m_fixedWidth = (iVal != 0);
1974
1975 iVal = (int) m_fixedHeight;
1976 clause->GetAttributeValue("fixed_height", iVal);
1977 m_fixedHeight = (iVal != 0);
1978
1979 clause->GetAttributeValue("format_mode", m_formatMode);
1980 clause->GetAttributeValue("shadow_mode", m_shadowMode);
1981
1982 iVal = m_branchNeckLength;
1983 clause->GetAttributeValue("neck_length", iVal);
1984 m_branchNeckLength = iVal;
1985
1986 iVal = m_branchStemLength;
1987 clause->GetAttributeValue("stem_length", iVal);
1988 m_branchStemLength = iVal;
1989
1990 iVal = m_branchSpacing;
1991 clause->GetAttributeValue("branch_spacing", iVal);
1992 m_branchSpacing = iVal;
1993
1994 clause->GetAttributeValue("branch_style", m_branchStyle);
1995
1996 iVal = (int) m_centreResize;
1997 clause->GetAttributeValue("centre_resize", iVal);
1998 m_centreResize = (iVal != 0);
1999
2000 iVal = (int) m_maintainAspectRatio;
2001 clause->GetAttributeValue("maintain_aspect_ratio", iVal);
2002 m_maintainAspectRatio = (iVal != 0);
2003
2004 iVal = (int) m_highlighted;
2005 clause->GetAttributeValue("hilite", iVal);
2006 m_highlighted = (iVal != 0);
2007
2008 clause->GetAttributeValue("rotation", m_rotation);
2009
2010 if (pen_string == "")
2011 pen_string = "BLACK";
2012 if (brush_string == "")
2013 brush_string = "WHITE";
2014
2015 if (pen_string.GetChar(0) == '#')
2016 {
2017 wxColour col(oglHexToColour(pen_string.After('#')));
2018 m_pen = wxThePenList->FindOrCreatePen(col, pen_width, pen_style);
2019 }
2020 else
2021 m_pen = wxThePenList->FindOrCreatePen(pen_string, pen_width, pen_style);
2022
2023 if (!m_pen)
2024 m_pen = wxBLACK_PEN;
2025
2026 if (brush_string.GetChar(0) == '#')
2027 {
2028 wxColour col(oglHexToColour(brush_string.After('#')));
2029 m_brush = wxTheBrushList->FindOrCreateBrush(col, brush_style);
2030 }
2031 else
2032 m_brush = wxTheBrushList->FindOrCreateBrush(brush_string, brush_style);
2033
2034 if (!m_brush)
2035 m_brush = wxWHITE_BRUSH;
2036
2037 int point_size = 10;
2038 clause->GetAttributeValue("point_size", point_size);
2039 SetFont(oglMatchFont(point_size));
2040
2041 // Read user-defined attachment points, if any
2042 wxExpr *attachmentList = clause->AttributeValue("user_attachments");
2043 if (attachmentList)
2044 {
2045 wxExpr *pointExpr = attachmentList->GetFirst();
2046 while (pointExpr)
2047 {
2048 wxExpr *idExpr = pointExpr->Nth(0);
2049 wxExpr *xExpr = pointExpr->Nth(1);
2050 wxExpr *yExpr = pointExpr->Nth(2);
2051 if (idExpr && xExpr && yExpr)
2052 {
2053 wxAttachmentPoint *point = new wxAttachmentPoint;
2054 point->m_id = (int)idExpr->IntegerValue();
2055 point->m_x = xExpr->RealValue();
2056 point->m_y = yExpr->RealValue();
2057 m_attachmentPoints.Append((wxObject *)point);
2058 }
2059 pointExpr = pointExpr->GetNext();
2060 }
2061 }
2062
2063 // Read text regions
2064 ReadRegions(clause);
2065}
2066
2067void wxShape::ReadRegions(wxExpr *clause)
2068{
2069 ClearRegions();
2070
2071 // region1 = (regionName regionText x y width height minWidth minHeight proportionX proportionY
2072 // formatMode fontSize fontFamily fontStyle fontWeight textColour)
2073 int regionNo = 1;
2074 char regionNameBuf[20];
2075 char textNameBuf[20];
2076
2077 wxExpr *regionExpr = NULL;
2078 wxExpr *textExpr = NULL;
2079 sprintf(regionNameBuf, "region%d", regionNo);
2080 sprintf(textNameBuf, "text%d", regionNo);
2081
2082 m_formatted = TRUE; // Assume text is formatted unless we prove otherwise
2083
2084 while ((regionExpr = clause->AttributeValue(regionNameBuf)))
2085 {
2086 /*
2087 * Get the region information
2088 *
2089 */
2090
2091 wxString regionName("");
2092 wxString regionText("");
2093 double x = 0.0;
2094 double y = 0.0;
2095 double width = 0.0;
2096 double height = 0.0;
2097 double minWidth = 5.0;
2098 double minHeight = 5.0;
2099 double m_regionProportionX = -1.0;
2100 double m_regionProportionY = -1.0;
2101 int formatMode = FORMAT_NONE;
2102 int fontSize = 10;
2103 int fontFamily = wxSWISS;
2104 int fontStyle = wxNORMAL;
2105 int fontWeight = wxNORMAL;
2106 wxString regionTextColour("");
2107 wxString penColour("");
2108 int penStyle = wxSOLID;
2109
2110 if (regionExpr->Type() == wxExprList)
2111 {
2112 wxExpr *nameExpr = regionExpr->Nth(0);
2113 wxExpr *textExpr = regionExpr->Nth(1);
2114 wxExpr *xExpr = regionExpr->Nth(2);
2115 wxExpr *yExpr = regionExpr->Nth(3);
2116 wxExpr *widthExpr = regionExpr->Nth(4);
2117 wxExpr *heightExpr = regionExpr->Nth(5);
2118 wxExpr *minWidthExpr = regionExpr->Nth(6);
2119 wxExpr *minHeightExpr = regionExpr->Nth(7);
2120 wxExpr *propXExpr = regionExpr->Nth(8);
2121 wxExpr *propYExpr = regionExpr->Nth(9);
2122 wxExpr *formatExpr = regionExpr->Nth(10);
2123 wxExpr *sizeExpr = regionExpr->Nth(11);
2124 wxExpr *familyExpr = regionExpr->Nth(12);
2125 wxExpr *styleExpr = regionExpr->Nth(13);
2126 wxExpr *weightExpr = regionExpr->Nth(14);
2127 wxExpr *colourExpr = regionExpr->Nth(15);
2128 wxExpr *penColourExpr = regionExpr->Nth(16);
2129 wxExpr *penStyleExpr = regionExpr->Nth(17);
2130
2131 regionName = nameExpr->StringValue();
2132 regionText = textExpr->StringValue();
2133
2134 x = xExpr->RealValue();
2135 y = yExpr->RealValue();
2136
2137 width = widthExpr->RealValue();
2138 height = heightExpr->RealValue();
2139
2140 minWidth = minWidthExpr->RealValue();
2141 minHeight = minHeightExpr->RealValue();
2142
2143 m_regionProportionX = propXExpr->RealValue();
2144 m_regionProportionY = propYExpr->RealValue();
2145
2146 formatMode = (int) formatExpr->IntegerValue();
2147 fontSize = (int)sizeExpr->IntegerValue();
2148 fontFamily = (int)familyExpr->IntegerValue();
2149 fontStyle = (int)styleExpr->IntegerValue();
2150 fontWeight = (int)weightExpr->IntegerValue();
2151
2152 if (colourExpr)
2153 {
2154 regionTextColour = colourExpr->StringValue();
2155 }
2156 else
2157 regionTextColour = "BLACK";
2158
2159 if (penColourExpr)
2160 penColour = penColourExpr->StringValue();
2161 if (penStyleExpr)
2162 penStyle = (int)penStyleExpr->IntegerValue();
2163 }
2164 wxFont *font = wxTheFontList->FindOrCreateFont(fontSize, fontFamily, fontStyle, fontWeight);
2165
2166 wxShapeRegion *region = new wxShapeRegion;
2167 region->SetProportions(m_regionProportionX, m_regionProportionY);
2168 region->SetFont(font);
2169 region->SetSize(width, height);
2170 region->SetPosition(x, y);
2171 region->SetMinSize(minWidth, minHeight);
2172 region->SetFormatMode(formatMode);
2173 region->SetPenStyle(penStyle);
2174 if (penColour != "")
2175 region->SetPenColour(penColour);
2176
2177 region->m_textColour = regionTextColour;
2178 region->m_regionText = regionText;
2179 region->m_regionName = regionName;
2180
2181 m_regions.Append(region);
2182
2183 /*
2184 * Get the formatted text strings
2185 *
2186 */
2187 textExpr = clause->AttributeValue(textNameBuf);
2188 if (textExpr && (textExpr->Type() == wxExprList))
2189 {
2190 wxExpr *node = textExpr->value.first;
2191 while (node)
2192 {
2193 wxExpr *string_expr = node;
2194 double the_x = 0.0;
2195 double the_y = 0.0;
2196 wxString the_string("");
2197
2198 // string_expr can either be a string, or a list of
2199 // 3 elements: x, y, and string.
2200 if (string_expr->Type() == wxExprString)
2201 {
2202 the_string = string_expr->StringValue();
2203 m_formatted = FALSE;
2204 }
2205 else if (string_expr->Type() == wxExprList)
2206 {
2207 wxExpr *first = string_expr->value.first;
2208 wxExpr *second = first ? first->next : (wxExpr*) NULL;
2209 wxExpr *third = second ? second->next : (wxExpr*) NULL;
2210
2211 if (first && second && third &&
2212 (first->Type() == wxExprReal || first->Type() == wxExprInteger) &&
2213 (second->Type() == wxExprReal || second->Type() == wxExprInteger) &&
2214 third->Type() == wxExprString)
2215 {
2216 if (first->Type() == wxExprReal)
2217 the_x = first->RealValue();
2218 else the_x = (double)first->IntegerValue();
2219
2220 if (second->Type() == wxExprReal)
2221 the_y = second->RealValue();
2222 else the_y = (double)second->IntegerValue();
2223
2224 the_string = third->StringValue();
2225 }
2226 }
2227 if (the_string)
2228 {
2229 wxShapeTextLine *line =
c1fa2fda 2230 new wxShapeTextLine(the_x, the_y, the_string);
1fc25a89
JS		 2231 region->m_formattedText.Append(line);
2232 }
2233 node = node->next;
2234 }
2235 }
2236
2237 regionNo ++;
2238 sprintf(regionNameBuf, "region%d", regionNo);
2239 sprintf(textNameBuf, "text%d", regionNo);
2240 }
2241
2242 // Compatibility: check for no regions (old file).
2243 // Lines and divided rectangles must deal with this compatibility
2244 // theirselves. Composites _may_ not have any regions anyway.
2245 if ((m_regions.Number() == 0) &&
2246 !this->IsKindOf(CLASSINFO(wxLineShape)) && !this->IsKindOf(CLASSINFO(wxDividedShape)) &&
2247 !this->IsKindOf(CLASSINFO(wxCompositeShape)))
2248 {
2249 wxShapeRegion *newRegion = new wxShapeRegion;
2250 newRegion->SetName("0");
2251 m_regions.Append((wxObject *)newRegion);
2252 if (m_text.Number() > 0)
2253 {
2254 newRegion->ClearText();
2255 wxNode *node = m_text.First();
2256 while (node)
2257 {
2258 wxShapeTextLine *textLine = (wxShapeTextLine *)node->Data();
2259 wxNode *next = node->Next();
2260 newRegion->GetFormattedText().Append((wxObject *)textLine);
2261 delete node;
2262 node = next;
2263 }
2264 }
2265 }
2266}
2267
2268#endif
2269
2270void wxShape::Copy(wxShape& copy)
2271{
2272 copy.m_id = m_id;
2273 copy.m_xpos = m_xpos;
2274 copy.m_ypos = m_ypos;
2275 copy.m_pen = m_pen;
2276 copy.m_brush = m_brush;
2277 copy.m_textColour = m_textColour;
2278 copy.m_centreResize = m_centreResize;
2279 copy.m_maintainAspectRatio = m_maintainAspectRatio;
2280 copy.m_attachmentMode = m_attachmentMode;
2281 copy.m_spaceAttachments = m_spaceAttachments;
2282 copy.m_highlighted = m_highlighted;
2283 copy.m_rotation = m_rotation;
2284 copy.m_textColourName = m_textColourName;
2285 copy.m_regionName = m_regionName;
2286
2287 copy.m_sensitivity = m_sensitivity;
2288 copy.m_draggable = m_draggable;
2289 copy.m_fixedWidth = m_fixedWidth;
2290 copy.m_fixedHeight = m_fixedHeight;
2291 copy.m_formatMode = m_formatMode;
2292 copy.m_drawHandles = m_drawHandles;
2293
2294 copy.m_visible = m_visible;
2295 copy.m_shadowMode = m_shadowMode;
2296 copy.m_shadowOffsetX = m_shadowOffsetX;
2297 copy.m_shadowOffsetY = m_shadowOffsetY;
2298 copy.m_shadowBrush = m_shadowBrush;
2299
2300 copy.m_branchNeckLength = m_branchNeckLength;
2301 copy.m_branchStemLength = m_branchStemLength;
2302 copy.m_branchSpacing = m_branchSpacing;
2303
2304 // Copy text regions
2305 copy.ClearRegions();
2306 wxNode *node = m_regions.First();
2307 while (node)
2308 {
2309 wxShapeRegion *region = (wxShapeRegion *)node->Data();
2310 wxShapeRegion *newRegion = new wxShapeRegion(*region);
2311 copy.m_regions.Append(newRegion);
2312 node = node->Next();
2313 }
2314
2315 // Copy attachments
2316 copy.ClearAttachments();
2317 node = m_attachmentPoints.First();
2318 while (node)
2319 {
2320 wxAttachmentPoint *point = (wxAttachmentPoint *)node->Data();
2321 wxAttachmentPoint *newPoint = new wxAttachmentPoint;
2322 newPoint->m_id = point->m_id;
2323 newPoint->m_x = point->m_x;
2324 newPoint->m_y = point->m_y;
2325 copy.m_attachmentPoints.Append((wxObject *)newPoint);
2326 node = node->Next();
2327 }
2328
2329 // Copy lines
2330 copy.m_lines.Clear();
2331 node = m_lines.First();
2332 while (node)
2333 {
2334 wxLineShape* line = (wxLineShape*) node->Data();
2335 copy.m_lines.Append(line);
2336 node = node->Next();
2337 }
2338}
2339
2340// Create and return a new, fully copied object.
2341wxShape *wxShape::CreateNewCopy(bool resetMapping, bool recompute)
2342{
2343 if (resetMapping)
2344 oglObjectCopyMapping.Clear();
2345
2346 wxShape* newObject = (wxShape*) GetClassInfo()->CreateObject();
2347
2348 wxASSERT( (newObject != NULL) );
2349 wxASSERT( (newObject->IsKindOf(CLASSINFO(wxShape))) );
2350
2351 Copy(*newObject);
2352
2353 if (GetEventHandler() != this)
2354 {
2355 wxShapeEvtHandler* newHandler = GetEventHandler()->CreateNewCopy();
2356 newObject->SetEventHandler(newHandler);
2357 newObject->SetPreviousHandler(NULL);
2358 newHandler->SetPreviousHandler(newObject);
2359 newHandler->SetShape(newObject);
2360 }
2361
2362 if (recompute)
2363 newObject->Recompute();
2364 return newObject;
2365}
2366
2367// Does the copying for this object, including copying event
2368// handler data if any. Calls the virtual Copy function.
2369void wxShape::CopyWithHandler(wxShape& copy)
2370{
2371 Copy(copy);
2372
2373 if (GetEventHandler() != this)
2374 {
2375 wxASSERT( copy.GetEventHandler() != NULL );
2376 wxASSERT( copy.GetEventHandler() != (&copy) );
2377 wxASSERT( GetEventHandler()->GetClassInfo() == copy.GetEventHandler()->GetClassInfo() );
2378 GetEventHandler()->CopyData(* (copy.GetEventHandler()));
2379 }
2380}
2381
2382
2383// Default - make 6 control points
2384void wxShape::MakeControlPoints()
2385{
2386 double maxX, maxY, minX, minY;
2387
2388 GetBoundingBoxMax(&maxX, &maxY);
2389 GetBoundingBoxMin(&minX, &minY);
2390
2391 double widthMin = (double)(minX + CONTROL_POINT_SIZE + 2);
2392 double heightMin = (double)(minY + CONTROL_POINT_SIZE + 2);
2393
2394 // Offsets from main object
2395 double top = (double)(- (heightMin / 2.0));
2396 double bottom = (double)(heightMin / 2.0 + (maxY - minY));
2397 double left = (double)(- (widthMin / 2.0));
2398 double right = (double)(widthMin / 2.0 + (maxX - minX));
2399
2400 wxControlPoint *control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, left, top,
2401 CONTROL_POINT_DIAGONAL);
2402 m_canvas->AddShape(control);
2403 m_controlPoints.Append(control);
2404
2405 control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, 0, top,
2406 CONTROL_POINT_VERTICAL);
2407 m_canvas->AddShape(control);
2408 m_controlPoints.Append(control);
2409
2410 control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, right, top,
2411 CONTROL_POINT_DIAGONAL);
2412 m_canvas->AddShape(control);
2413 m_controlPoints.Append(control);
2414
2415 control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, right, 0,
2416 CONTROL_POINT_HORIZONTAL);
2417 m_canvas->AddShape(control);
2418 m_controlPoints.Append(control);
2419
2420 control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, right, bottom,
2421 CONTROL_POINT_DIAGONAL);
2422 m_canvas->AddShape(control);
2423 m_controlPoints.Append(control);
2424
2425 control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, 0, bottom,
2426 CONTROL_POINT_VERTICAL);
2427 m_canvas->AddShape(control);
2428 m_controlPoints.Append(control);
2429
2430 control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, left, bottom,
2431 CONTROL_POINT_DIAGONAL);
2432 m_canvas->AddShape(control);
2433 m_controlPoints.Append(control);
2434
2435 control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, left, 0,
2436 CONTROL_POINT_HORIZONTAL);
2437 m_canvas->AddShape(control);
2438 m_controlPoints.Append(control);
2439
2440}
2441
2442void wxShape::MakeMandatoryControlPoints()
2443{
2444 wxNode *node = m_children.First();
2445 while (node)
2446 {
2447 wxShape *child = (wxShape *)node->Data();
2448 child->MakeMandatoryControlPoints();
2449 node = node->Next();
2450 }
2451}
2452
2453void wxShape::ResetMandatoryControlPoints()
2454{
2455 wxNode *node = m_children.First();
2456 while (node)
2457 {
2458 wxShape *child = (wxShape *)node->Data();
2459 child->ResetMandatoryControlPoints();
2460 node = node->Next();
2461 }
2462}
2463
2464void wxShape::ResetControlPoints()
2465{
2466 ResetMandatoryControlPoints();
2467
2468 if (m_controlPoints.Number() < 1)
2469 return;
2470
2471 double maxX, maxY, minX, minY;
2472
2473 GetBoundingBoxMax(&maxX, &maxY);
2474 GetBoundingBoxMin(&minX, &minY);
2475
2476 double widthMin = (double)(minX + CONTROL_POINT_SIZE + 2);
2477 double heightMin = (double)(minY + CONTROL_POINT_SIZE + 2);
2478
2479 // Offsets from main object
2480 double top = (double)(- (heightMin / 2.0));
2481 double bottom = (double)(heightMin / 2.0 + (maxY - minY));
2482 double left = (double)(- (widthMin / 2.0));
2483 double right = (double)(widthMin / 2.0 + (maxX - minX));
2484
2485 wxNode *node = m_controlPoints.First();
2486 wxControlPoint *control = (wxControlPoint *)node->Data();
2487 control->m_xoffset = left; control->m_yoffset = top;
2488
2489 node = node->Next(); control = (wxControlPoint *)node->Data();
2490 control->m_xoffset = 0; control->m_yoffset = top;
2491
2492 node = node->Next(); control = (wxControlPoint *)node->Data();
2493 control->m_xoffset = right; control->m_yoffset = top;
2494
2495 node = node->Next(); control = (wxControlPoint *)node->Data();
2496 control->m_xoffset = right; control->m_yoffset = 0;
2497
2498 node = node->Next(); control = (wxControlPoint *)node->Data();
2499 control->m_xoffset = right; control->m_yoffset = bottom;
2500
2501 node = node->Next(); control = (wxControlPoint *)node->Data();
2502 control->m_xoffset = 0; control->m_yoffset = bottom;
2503
2504 node = node->Next(); control = (wxControlPoint *)node->Data();
2505 control->m_xoffset = left; control->m_yoffset = bottom;
2506
2507 node = node->Next(); control = (wxControlPoint *)node->Data();
2508 control->m_xoffset = left; control->m_yoffset = 0;
2509}
2510
2511void wxShape::DeleteControlPoints(wxDC *dc)
2512{
2513 wxNode *node = m_controlPoints.First();
2514 while (node)
2515 {
2516 wxControlPoint *control = (wxControlPoint *)node->Data();
2517 if (dc)
2518 control->GetEventHandler()->OnErase(*dc);
2519 m_canvas->RemoveShape(control);
2520 delete control;
2521 delete node;
2522 node = m_controlPoints.First();
2523 }
2524 // Children of divisions are contained objects,
2525 // so stop here
2526 if (!IsKindOf(CLASSINFO(wxDivisionShape)))
2527 {
2528 node = m_children.First();
2529 while (node)
2530 {
2531 wxShape *child = (wxShape *)node->Data();
2532 child->DeleteControlPoints(dc);
2533 node = node->Next();
2534 }
2535 }
2536}
2537
2538void wxShape::OnDrawControlPoints(wxDC& dc)
2539{
2540 if (!m_drawHandles)
2541 return;
2542
2543 dc.SetBrush(* wxBLACK_BRUSH);
2544 dc.SetPen(* wxBLACK_PEN);
2545
2546 wxNode *node = m_controlPoints.First();
2547 while (node)
2548 {
2549 wxControlPoint *control = (wxControlPoint *)node->Data();
2550 control->Draw(dc);
2551 node = node->Next();
2552 }
2553 // Children of divisions are contained objects,
2554 // so stop here.
2555 // This test bypasses the type facility for speed
2556 // (critical when drawing)
2557 if (!IsKindOf(CLASSINFO(wxDivisionShape)))
2558 {
2559 node = m_children.First();
2560 while (node)
2561 {
2562 wxShape *child = (wxShape *)node->Data();
2563 child->GetEventHandler()->OnDrawControlPoints(dc);
2564 node = node->Next();
2565 }
2566 }
2567}
2568
2569void wxShape::OnEraseControlPoints(wxDC& dc)
2570{
2571 wxNode *node = m_controlPoints.First();
2572 while (node)
2573 {
2574 wxControlPoint *control = (wxControlPoint *)node->Data();
2575 control->Erase(dc);
2576 node = node->Next();
2577 }
2578 if (!IsKindOf(CLASSINFO(wxDivisionShape)))
2579 {
2580 node = m_children.First();
2581 while (node)
2582 {
2583 wxShape *child = (wxShape *)node->Data();
2584 child->GetEventHandler()->OnEraseControlPoints(dc);
2585 node = node->Next();
2586 }
2587 }
2588}
2589
2590void wxShape::Select(bool select, wxDC* dc)
2591{
2592 m_selected = select;
2593 if (select)
2594 {
2595 MakeControlPoints();
2596 // Children of divisions are contained objects,
2597 // so stop here
2598 if (!IsKindOf(CLASSINFO(wxDivisionShape)))
2599 {
2600 wxNode *node = m_children.First();
2601 while (node)
2602 {
2603 wxShape *child = (wxShape *)node->Data();
2604 child->MakeMandatoryControlPoints();
2605 node = node->Next();
2606 }
2607 }
2608 if (dc)
2609 GetEventHandler()->OnDrawControlPoints(*dc);
2610 }
2611 if (!select)
2612 {
2613 DeleteControlPoints(dc);
2614 if (!IsKindOf(CLASSINFO(wxDivisionShape)))
2615 {
2616 wxNode *node = m_children.First();
2617 while (node)
2618 {
2619 wxShape *child = (wxShape *)node->Data();
2620 child->DeleteControlPoints(dc);
2621 node = node->Next();
2622 }
2623 }
2624 }
2625}
2626
2627bool wxShape::Selected() const
2628{
2629 return m_selected;
2630}
2631
2632bool wxShape::AncestorSelected() const
2633{
2634 if (m_selected) return TRUE;
2635 if (!GetParent())
2636 return FALSE;
2637 else
2638 return GetParent()->AncestorSelected();
2639}
2640
2641int wxShape::GetNumberOfAttachments() const
2642{
2643 // Should return the MAXIMUM attachment point id here,
2644 // so higher-level functions can iterate through all attachments,
2645 // even if they're not contiguous.
2646 if (m_attachmentPoints.Number() == 0)
2647 return 4;
2648 else
2649 {
2650 int maxN = 3;
2651 wxNode *node = m_attachmentPoints.First();
2652 while (node)
2653 {
2654 wxAttachmentPoint *point = (wxAttachmentPoint *)node->Data();
2655 if (point->m_id > maxN)
2656 maxN = point->m_id;
2657 node = node->Next();
2658 }
2659 return maxN+1;;
2660 }
2661}
2662
2663bool wxShape::AttachmentIsValid(int attachment) const
2664{
2665 if (m_attachmentPoints.Number() == 0)
2666 {
2667 return ((attachment >= 0) && (attachment < 4)) ;
2668 }
2669
2670 wxNode *node = m_attachmentPoints.First();
2671 while (node)
2672 {
2673 wxAttachmentPoint *point = (wxAttachmentPoint *)node->Data();
2674 if (point->m_id == attachment)
2675 return TRUE;
2676 node = node->Next();
2677 }
2678 return FALSE;
2679}
2680
2681bool wxShape::GetAttachmentPosition(int attachment, double *x, double *y,
2682 int nth, int no_arcs, wxLineShape *line)
2683{
2684 if (m_attachmentMode == ATTACHMENT_MODE_NONE)
2685 {
2686 *x = m_xpos; *y = m_ypos;
2687 return TRUE;
2688 }
2689 else if (m_attachmentMode == ATTACHMENT_MODE_BRANCHING)
2690 {
2691 wxRealPoint pt, stemPt;
2692 GetBranchingAttachmentPoint(attachment, nth, pt, stemPt);
2693 *x = pt.x;
2694 *y = pt.y;
2695 return TRUE;
2696 }
2697 else if (m_attachmentMode == ATTACHMENT_MODE_EDGE)
2698 {
2699 if (m_attachmentPoints.Number() > 0)
2700 {
2701 wxNode *node = m_attachmentPoints.First();
2702 while (node)
2703 {
2704 wxAttachmentPoint *point = (wxAttachmentPoint *)node->Data();
2705 if (point->m_id == attachment)
2706 {
2707 *x = (double)(m_xpos + point->m_x);
2708 *y = (double)(m_ypos + point->m_y);
2709 return TRUE;
2710 }
2711 node = node->Next();
2712 }
2713 *x = m_xpos; *y = m_ypos;
2714 return FALSE;
2715 }
2716 else
2717 {
2718 // Assume is rectangular
2719 double w, h;
2720 GetBoundingBoxMax(&w, &h);
2721 double top = (double)(m_ypos + h/2.0);
2722 double bottom = (double)(m_ypos - h/2.0);
2723 double left = (double)(m_xpos - w/2.0);
2724 double right = (double)(m_xpos + w/2.0);
2725
2726 bool isEnd = (line && line->IsEnd(this));
2727
2728 int physicalAttachment = LogicalToPhysicalAttachment(attachment);
2729
2730 // Simplified code
2731 switch (physicalAttachment)
2732 {
2733 case 0:
2734 {
2735 wxRealPoint pt = CalcSimpleAttachment(wxRealPoint(left, bottom), wxRealPoint(right, bottom),
2736 nth, no_arcs, line);
2737
2738 *x = pt.x; *y = pt.y;
2739 break;
2740 }
2741 case 1:
2742 {
2743 wxRealPoint pt = CalcSimpleAttachment(wxRealPoint(right, bottom), wxRealPoint(right, top),
2744 nth, no_arcs, line);
2745
2746 *x = pt.x; *y = pt.y;
2747 break;
2748 }
2749 case 2:
2750 {
2751 wxRealPoint pt = CalcSimpleAttachment(wxRealPoint(left, top), wxRealPoint(right, top),
2752 nth, no_arcs, line);
2753
2754 *x = pt.x; *y = pt.y;
2755 break;
2756 }
2757 case 3:
2758 {
2759 wxRealPoint pt = CalcSimpleAttachment(wxRealPoint(left, bottom), wxRealPoint(left, top),
2760 nth, no_arcs, line);
2761
2762 *x = pt.x; *y = pt.y;
2763 break;
2764 }
2765 default:
2766 {
2767 return FALSE;
2768 break;
2769 }
2770 }
2771 return TRUE;
2772 }
2773 }
2774 return FALSE;
2775}
2776
2777void wxShape::GetBoundingBoxMax(double *w, double *h)
2778{
2779 double ww, hh;
2780 GetBoundingBoxMin(&ww, &hh);
2781 if (m_shadowMode != SHADOW_NONE)
2782 {
2783 ww += m_shadowOffsetX;
2784 hh += m_shadowOffsetY;
2785 }
2786 *w = ww;
2787 *h = hh;
2788}
2789
2790// Returns TRUE if image is a descendant of this composite
2791bool wxShape::HasDescendant(wxShape *image)
2792{
2793 if (image == this)
2794 return TRUE;
2795 wxNode *node = m_children.First();
2796 while (node)
2797 {
2798 wxShape *child = (wxShape *)node->Data();
2799 bool ans = child->HasDescendant(image);
2800 if (ans)
2801 return TRUE;
2802 node = node->Next();
2803 }
2804 return FALSE;
2805}
2806
2807// Clears points from a list of wxRealPoints, and clears list
2808void wxShape::ClearPointList(wxList& list)
2809{
2810 wxNode* node = list.First();
2811 while (node)
2812 {
2813 wxRealPoint* pt = (wxRealPoint*) node->Data();
2814 delete pt;
2815
2816 node = node->Next();
2817 }
2818 list.Clear();
2819}
2820
2821// Assuming the attachment lies along a vertical or horizontal line,
2822// calculate the position on that point.
2823wxRealPoint wxShape::CalcSimpleAttachment(const wxRealPoint& pt1, const wxRealPoint& pt2,
2824 int nth, int noArcs, wxLineShape* line)
2825{
2826 bool isEnd = (line && line->IsEnd(this));
2827
2828 // Are we horizontal or vertical?
2829 bool isHorizontal = (oglRoughlyEqual(pt1.y, pt2.y) == TRUE);
2830
2831 double x, y;
2832
2833 if (isHorizontal)
2834 {
2835 wxRealPoint firstPoint, secondPoint;
2836 if (pt1.x > pt2.x)
2837 {
2838 firstPoint = pt2;
2839 secondPoint = pt1;
2840 }
2841 else
2842 {
2843 firstPoint = pt1;
2844 secondPoint = pt2;
2845 }
2846
2847 if (m_spaceAttachments)
2848 {
2849 if (line && (line->GetAlignmentType(isEnd) == LINE_ALIGNMENT_TO_NEXT_HANDLE))
2850 {
2851 // Align line according to the next handle along
2852 wxRealPoint *point = line->GetNextControlPoint(this);
2853 if (point->x < firstPoint.x)
2854 x = firstPoint.x;
2855 else if (point->x > secondPoint.x)
2856 x = secondPoint.x;
2857 else
2858 x = point->x;
2859 }
2860 else
2861 x = firstPoint.x + (nth + 1)*(secondPoint.x - firstPoint.x)/(noArcs + 1);
2862 }
2863 else x = (secondPoint.x - firstPoint.x)/2.0; // Midpoint
2864
2865 y = pt1.y;
2866 }
2867 else
2868 {
2869 wxASSERT( oglRoughlyEqual(pt1.x, pt2.x) == TRUE );
2870
2871 wxRealPoint firstPoint, secondPoint;
2872 if (pt1.y > pt2.y)
2873 {
2874 firstPoint = pt2;
2875 secondPoint = pt1;
2876 }
2877 else
2878 {
2879 firstPoint = pt1;
2880 secondPoint = pt2;
2881 }
2882
2883 if (m_spaceAttachments)
2884 {
2885 if (line && (line->GetAlignmentType(isEnd) == LINE_ALIGNMENT_TO_NEXT_HANDLE))
2886 {
2887 // Align line according to the next handle along
2888 wxRealPoint *point = line->GetNextControlPoint(this);
2889 if (point->y < firstPoint.y)
2890 y = firstPoint.y;
2891 else if (point->y > secondPoint.y)
2892 y = secondPoint.y;
2893 else
2894 y = point->y;
2895 }
2896 else
2897 y = firstPoint.y + (nth + 1)*(secondPoint.y - firstPoint.y)/(noArcs + 1);
2898 }
2899 else y = (secondPoint.y - firstPoint.y)/2.0; // Midpoint
2900
2901 x = pt1.x;
2902 }
2903
2904 return wxRealPoint(x, y);
2905}
2906
2907// Return the zero-based position in m_lines of line.
2908int wxShape::GetLinePosition(wxLineShape* line)
2909{
2910 int i = 0;
2911 for (i = 0; i < m_lines.Number(); i++)
2912 if ((wxLineShape*) (m_lines.Nth(i)->Data()) == line)
2913 return i;
2914
2915 return 0;
2916}
2917
2918//
2919// |________|
2920// | <- root
2921// | <- neck
2922// shoulder1 ->---------<- shoulder2
2923// | | | | |
2924// <- branching attachment point N-1
2925
2926// This function gets information about where branching connections go.
2927// Returns FALSE if there are no lines at this attachment.
2928bool wxShape::GetBranchingAttachmentInfo(int attachment, wxRealPoint& root, wxRealPoint& neck,
2929 wxRealPoint& shoulder1, wxRealPoint& shoulder2)
2930{
2931 int physicalAttachment = LogicalToPhysicalAttachment(attachment);
2932
2933 // Number of lines at this attachment.
2934 int lineCount = GetAttachmentLineCount(attachment);
2935
2936 if (lineCount == 0)
2937 return FALSE;
2938
2939 int totalBranchLength = m_branchSpacing * (lineCount - 1);
2940
2941 root = GetBranchingAttachmentRoot(attachment);
2942
2943 // Assume that we have attachment points 0 to 3: top, right, bottom, left.
2944 switch (physicalAttachment)
2945 {
2946 case 0:
2947 {
2948 neck.x = GetX();
2949 neck.y = root.y - m_branchNeckLength;
2950
2951 shoulder1.x = root.x - (totalBranchLength/2.0) ;
2952 shoulder2.x = root.x + (totalBranchLength/2.0) ;
2953
2954 shoulder1.y = neck.y;
2955 shoulder2.y = neck.y;
2956 break;
2957 }
2958 case 1:
2959 {
2960 neck.x = root.x + m_branchNeckLength;
2961 neck.y = root.y;
2962
2963 shoulder1.x = neck.x ;
2964 shoulder2.x = neck.x ;
2965
2966 shoulder1.y = neck.y - (totalBranchLength/2.0) ;
2967 shoulder2.y = neck.y + (totalBranchLength/2.0) ;
2968 break;
2969 }
2970 case 2:
2971 {
2972 neck.x = GetX();
2973 neck.y = root.y + m_branchNeckLength;
2974
2975 shoulder1.x = root.x - (totalBranchLength/2.0) ;
2976 shoulder2.x = root.x + (totalBranchLength/2.0) ;
2977
2978 shoulder1.y = neck.y;
2979 shoulder2.y = neck.y;
2980 break;
2981 }
2982 case 3:
2983 {
2984 neck.x = root.x - m_branchNeckLength;
2985 neck.y = root.y ;
2986
2987 shoulder1.x = neck.x ;
2988 shoulder2.x = neck.x ;
2989
2990 shoulder1.y = neck.y - (totalBranchLength/2.0) ;
2991 shoulder2.y = neck.y + (totalBranchLength/2.0) ;
2992 break;
2993 }
2994 default:
2995 {
c1fa2fda 2996 wxFAIL_MSG( wxT("Unrecognised attachment point in GetBranchingAttachmentInfo.") );
1fc25a89
JS		 2997 break;
2998 }
2999 }
3000 return TRUE;
3001}
3002
3003// n is the number of the adjoining line, from 0 to N-1 where N is the number of lines
3004// at this attachment point.
3005// Get the attachment point where the arc joins the stem, and also the point where the
3006// the stem meets the shoulder.
3007bool wxShape::GetBranchingAttachmentPoint(int attachment, int n, wxRealPoint& pt, wxRealPoint& stemPt)
3008{
3009 int physicalAttachment = LogicalToPhysicalAttachment(attachment);
3010
3011 wxRealPoint root, neck, shoulder1, shoulder2;
3012 GetBranchingAttachmentInfo(attachment, root, neck, shoulder1, shoulder2);
3013
3014 // Assume that we have attachment points 0 to 3: top, right, bottom, left.
3015 switch (physicalAttachment)
3016 {
3017 case 0:
3018 {
3019 pt.y = neck.y - m_branchStemLength;
3020 pt.x = shoulder1.x + n*m_branchSpacing;
3021
3022 stemPt.x = pt.x;
3023 stemPt.y = neck.y;
3024 break;
3025 }
3026 case 2:
3027 {
3028 pt.y = neck.y + m_branchStemLength;
3029 pt.x = shoulder1.x + n*m_branchSpacing;
3030
3031 stemPt.x = pt.x;
3032 stemPt.y = neck.y;
3033 break;
3034 }
3035 case 1:
3036 {
3037 pt.x = neck.x + m_branchStemLength;
3038 pt.y = shoulder1.y + n*m_branchSpacing;
3039
3040 stemPt.x = neck.x;
3041 stemPt.y = pt.y;
3042 break;
3043 }
3044 case 3:
3045 {
3046 pt.x = neck.x - m_branchStemLength;
3047 pt.y = shoulder1.y + n*m_branchSpacing;
3048
3049 stemPt.x = neck.x;
3050 stemPt.y = pt.y;
3051 break;
3052 }
3053 default:
3054 {
c1fa2fda 3055 wxFAIL_MSG( wxT("Unrecognised attachment point in GetBranchingAttachmentPoint.") );
1fc25a89
JS		 3056 break;
3057 }
3058 }
3059
3060 return TRUE;
3061}
3062
3063// Get the number of lines at this attachment position.
3064int wxShape::GetAttachmentLineCount(int attachment) const
3065{
3066 int count = 0;
3067 wxNode* node = m_lines.First();
3068 while (node)
3069 {
3070 wxLineShape* lineShape = (wxLineShape*) node->Data();
3071 if ((lineShape->GetFrom() == this) && (lineShape->GetAttachmentFrom() == attachment))
3072 count ++;
3073 else if ((lineShape->GetTo() == this) && (lineShape->GetAttachmentTo() == attachment))
3074 count ++;
3075
3076 node = node->Next();
3077 }
3078 return count;
3079}
3080
3081// This function gets the root point at the given attachment.
3082wxRealPoint wxShape::GetBranchingAttachmentRoot(int attachment)
3083{
3084 int physicalAttachment = LogicalToPhysicalAttachment(attachment);
3085
3086 wxRealPoint root;
3087
3088 double width, height;
3089 GetBoundingBoxMax(& width, & height);
3090
3091 // Assume that we have attachment points 0 to 3: top, right, bottom, left.
3092 switch (physicalAttachment)
3093 {
3094 case 0:
3095 {
3096 root.x = GetX() ;
3097 root.y = GetY() - height/2.0;
3098 break;
3099 }
3100 case 1:
3101 {
3102 root.x = GetX() + width/2.0;
3103 root.y = GetY() ;
3104 break;
3105 }
3106 case 2:
3107 {
3108 root.x = GetX() ;
3109 root.y = GetY() + height/2.0;
3110 break;
3111 }
3112 case 3:
3113 {
3114 root.x = GetX() - width/2.0;
3115 root.y = GetY() ;
3116 break;
3117 }
3118 default:
3119 {
c1fa2fda 3120 wxFAIL_MSG( wxT("Unrecognised attachment point in GetBranchingAttachmentRoot.") );
1fc25a89
JS		 3121 break;
3122 }
3123 }
3124 return root;
3125}
3126
3127// Draw or erase the branches (not the actual arcs though)
3128void wxShape::OnDrawBranches(wxDC& dc, int attachment, bool erase)
3129{
3130 int count = GetAttachmentLineCount(attachment);
3131 if (count == 0)
3132 return;
3133
3134 wxRealPoint root, neck, shoulder1, shoulder2;
3135 GetBranchingAttachmentInfo(attachment, root, neck, shoulder1, shoulder2);
3136
3137 if (erase)
3138 {
3139 dc.SetPen(*wxWHITE_PEN);
3140 dc.SetBrush(*wxWHITE_BRUSH);
3141 }
3142 else
3143 {
3144 dc.SetPen(*wxBLACK_PEN);
3145 dc.SetBrush(*wxBLACK_BRUSH);
3146 }
3147
3148 // Draw neck
3149 dc.DrawLine((long) root.x, (long) root.y, (long) neck.x, (long) neck.y);
3150
3151 if (count > 1)
3152 {
3153 // Draw shoulder-to-shoulder line
3154 dc.DrawLine((long) shoulder1.x, (long) shoulder1.y, (long) shoulder2.x, (long) shoulder2.y);
3155 }
3156 // Draw all the little branches
3157 int i;
3158 for (i = 0; i < count; i++)
3159 {
3160 wxRealPoint pt, stemPt;
3161 GetBranchingAttachmentPoint(attachment, i, pt, stemPt);
3162 dc.DrawLine((long) stemPt.x, (long) stemPt.y, (long) pt.x, (long) pt.y);
3163
3164 if ((GetBranchStyle() & BRANCHING_ATTACHMENT_BLOB) && (count > 1))
3165 {
3166 long blobSize=6;
3167// dc.DrawEllipse((long) (stemPt.x + 0.5 - (blobSize/2.0)), (long) (stemPt.y + 0.5 - (blobSize/2.0)), blobSize, blobSize);
3168 dc.DrawEllipse((long) (stemPt.x - (blobSize/2.0)), (long) (stemPt.y - (blobSize/2.0)), blobSize, blobSize);
3169 }
3170 }
3171}
3172
3173// Draw or erase the branches (not the actual arcs though)
3174void wxShape::OnDrawBranches(wxDC& dc, bool erase)
3175{
3176 if (m_attachmentMode != ATTACHMENT_MODE_BRANCHING)
3177 return;
3178
3179 int count = GetNumberOfAttachments();
3180 int i;
3181 for (i = 0; i < count; i++)
3182 OnDrawBranches(dc, i, erase);
3183}
3184
3185// Only get the attachment position at the _edge_ of the shape, ignoring
3186// branching mode. This is used e.g. to indicate the edge of interest, not the point
3187// on the attachment branch.
3188bool wxShape::GetAttachmentPositionEdge(int attachment, double *x, double *y,
3189 int nth, int no_arcs, wxLineShape *line)
3190{
3191 int oldMode = m_attachmentMode;
3192
3193 // Calculate as if to edge, not branch
3194 if (m_attachmentMode == ATTACHMENT_MODE_BRANCHING)
3195 m_attachmentMode = ATTACHMENT_MODE_EDGE;
3196 bool success = GetAttachmentPosition(attachment, x, y, nth, no_arcs, line);
3197 m_attachmentMode = oldMode;
3198
3199 return success;
3200}
3201
3202// Rotate the standard attachment point from physical (0 is always North)
3203// to logical (0 -> 1 if rotated by 90 degrees)
3204int wxShape::PhysicalToLogicalAttachment(int physicalAttachment) const
3205{
3206 const double pi = 3.1415926535897932384626433832795 ;
3207 int i;
3208 if (oglRoughlyEqual(GetRotation(), 0.0))
3209 {
3210 i = physicalAttachment;
3211 }
3212 else if (oglRoughlyEqual(GetRotation(), (pi/2.0)))
3213 {
3214 i = physicalAttachment - 1;
3215 }
3216 else if (oglRoughlyEqual(GetRotation(), pi))
3217 {
3218 i = physicalAttachment - 2;
3219 }
3220 else if (oglRoughlyEqual(GetRotation(), (3.0*pi/2.0)))
3221 {
3222 i = physicalAttachment - 3;
3223 }
3224 else
3225 // Can't handle -- assume the same.
3226 return physicalAttachment;
3227
3228 if (i < 0)
3229 i += 4;
3230
3231 return i;
3232}
3233
3234// Rotate the standard attachment point from logical
3235// to physical (0 is always North)
3236int wxShape::LogicalToPhysicalAttachment(int logicalAttachment) const
3237{
3238 const double pi = 3.1415926535897932384626433832795 ;
3239 int i;
3240 if (oglRoughlyEqual(GetRotation(), 0.0))
3241 {
3242 i = logicalAttachment;
3243 }
3244 else if (oglRoughlyEqual(GetRotation(), (pi/2.0)))
3245 {
3246 i = logicalAttachment + 1;
3247 }
3248 else if (oglRoughlyEqual(GetRotation(), pi))
3249 {
3250 i = logicalAttachment + 2;
3251 }
3252 else if (oglRoughlyEqual(GetRotation(), (3.0*pi/2.0)))
3253 {
3254 i = logicalAttachment + 3;
3255 }
3256 else
3257 // Can't handle -- assume the same.
3258 return logicalAttachment;
3259
3260 if (i > 3)
3261 i -= 4;
3262
3263 return i;
3264}
3265
3266void wxShape::Rotate(double WXUNUSED(x), double WXUNUSED(y), double theta)
3267{
3268 const double pi = 3.1415926535897932384626433832795 ;
3269 m_rotation = theta;
3270 if (m_rotation < 0.0)
3271 {
3272 m_rotation += 2*pi;
3273 }
3274 else if (m_rotation > 2*pi)
3275 {
3276 m_rotation -= 2*pi;
3277 }
3278}
3279
67d54b58
RD		 3280
3281wxPen wxShape::GetBackgroundPen()
3282{
3283 if (GetCanvas())
3284 {
3285 wxColour c = GetCanvas()->GetBackgroundColour();
3286 return wxPen(c, 1, wxSOLID);
3287 }
3288 return * g_oglWhiteBackgroundPen;
3289}
3290
3291
3292wxBrush wxShape::GetBackgroundBrush()
3293{
3294 if (GetCanvas())
3295 {
3296 wxColour c = GetCanvas()->GetBackgroundColour();
3297 return wxBrush(c, wxSOLID);
3298 }
3299 return * g_oglWhiteBackgroundBrush;
3300}
3301
wxWidgets (Impactor)