]> git.saurik.com Git - wxWidgets.git/blob - contrib/src/ogl/composit.cpp
added .chm support for Unix (Markus Sinner)
[wxWidgets.git] / contrib / src / ogl / composit.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: composit.cpp
3 // Purpose: Composite OGL class
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 "composit.h"
14 #endif
15
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
18
19 #ifdef __BORLANDC__
20 #pragma hdrstop
21 #endif
22
23 #ifndef WX_PRECOMP
24 #include <wx/wx.h>
25 #endif
26
27 #if wxUSE_PROLOGIO
28 #include <wx/deprecated/wxexpr.h>
29 #endif
30
31 #include "wx/ogl/ogl.h"
32
33
34 #if wxUSE_PROLOGIO
35 // Sometimes, objects need to access the whole database to
36 // construct themselves.
37 wxExprDatabase *GlobalwxExprDatabase = NULL;
38 #endif
39
40 /*
41 * Division control point
42 */
43
44 class wxDivisionControlPoint: public wxControlPoint
45 {
46 DECLARE_DYNAMIC_CLASS(wxDivisionControlPoint)
47 public:
48 wxDivisionControlPoint() {}
49 wxDivisionControlPoint(wxShapeCanvas *the_canvas, wxShape *object, double size, double the_xoffset, double the_yoffset, int the_type);
50 ~wxDivisionControlPoint();
51
52 void OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
53 void OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
54 void OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
55 };
56
57 IMPLEMENT_DYNAMIC_CLASS(wxDivisionControlPoint, wxControlPoint)
58
59 /*
60 * Composite object
61 *
62 */
63
64 IMPLEMENT_DYNAMIC_CLASS(wxCompositeShape, wxRectangleShape)
65
66 wxCompositeShape::wxCompositeShape(): wxRectangleShape(10.0, 10.0)
67 {
68 // selectable = FALSE;
69 m_oldX = m_xpos;
70 m_oldY = m_ypos;
71 }
72
73 wxCompositeShape::~wxCompositeShape()
74 {
75 wxNode *node = m_constraints.GetFirst();
76 while (node)
77 {
78 wxOGLConstraint *constraint = (wxOGLConstraint *)node->GetData();
79 delete constraint;
80 node = node->GetNext();
81 }
82 node = m_children.GetFirst();
83 while (node)
84 {
85 wxShape *object = (wxShape *)node->GetData();
86 wxNode *next = node->GetNext();
87 object->Unlink();
88 delete object;
89 node = next;
90 }
91 }
92
93 void wxCompositeShape::OnDraw(wxDC& dc)
94 {
95 double x1 = (double)(m_xpos - m_width/2.0);
96 double y1 = (double)(m_ypos - m_height/2.0);
97
98 if (m_shadowMode != SHADOW_NONE)
99 {
100 if (m_shadowBrush)
101 dc.SetBrush(* m_shadowBrush);
102 dc.SetPen(* g_oglTransparentPen);
103
104 if (m_cornerRadius != 0.0)
105 dc.DrawRoundedRectangle(WXROUND(x1 + m_shadowOffsetX), WXROUND(y1 + m_shadowOffsetY),
106 WXROUND(m_width), WXROUND(m_height), m_cornerRadius);
107 else
108 dc.DrawRectangle(WXROUND(x1 + m_shadowOffsetX), WXROUND(y1 + m_shadowOffsetY), WXROUND(m_width), WXROUND(m_height));
109 }
110 }
111
112 void wxCompositeShape::OnDrawContents(wxDC& dc)
113 {
114 wxNode *node = m_children.GetFirst();
115 while (node)
116 {
117 wxShape *object = (wxShape *)node->GetData();
118 object->Draw(dc);
119 object->DrawLinks(dc);
120 node = node->GetNext();
121 }
122 wxShape::OnDrawContents(dc);
123 }
124
125 bool wxCompositeShape::OnMovePre(wxDC& dc, double x, double y, double oldx, double oldy, bool display)
126 {
127 double diffX = x - oldx;
128 double diffY = y - oldy;
129 wxNode *node = m_children.GetFirst();
130 while (node)
131 {
132 wxShape *object = (wxShape *)node->GetData();
133
134 object->Erase(dc);
135 object->Move(dc, object->GetX() + diffX, object->GetY() + diffY, display);
136
137 node = node->GetNext();
138 }
139 return TRUE;
140 }
141
142 void wxCompositeShape::OnErase(wxDC& dc)
143 {
144 wxRectangleShape::OnErase(dc);
145 wxNode *node = m_children.GetFirst();
146 while (node)
147 {
148 wxShape *object = (wxShape *)node->GetData();
149 object->Erase(dc);
150 node = node->GetNext();
151 }
152 }
153
154 static double objectStartX = 0.0;
155 static double objectStartY = 0.0;
156
157 void wxCompositeShape::OnDragLeft(bool WXUNUSED(draw), double x, double y, int WXUNUSED(keys), int WXUNUSED(attachment))
158 {
159 double xx = x;
160 double yy = y;
161 m_canvas->Snap(&xx, &yy);
162 double offsetX = xx - objectStartX;
163 double offsetY = yy - objectStartY;
164
165 wxClientDC dc(GetCanvas());
166 GetCanvas()->PrepareDC(dc);
167
168 dc.SetLogicalFunction(OGLRBLF);
169 wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
170 dc.SetPen(dottedPen);
171 dc.SetBrush((* wxTRANSPARENT_BRUSH));
172
173 GetEventHandler()->OnDrawOutline(dc, GetX() + offsetX, GetY() + offsetY, GetWidth(), GetHeight());
174 // wxShape::OnDragLeft(draw, x, y, keys, attachment);
175 }
176
177 void wxCompositeShape::OnBeginDragLeft(double x, double y, int WXUNUSED(keys), int WXUNUSED(attachment))
178 {
179 objectStartX = x;
180 objectStartY = y;
181
182 wxClientDC dc(GetCanvas());
183 GetCanvas()->PrepareDC(dc);
184
185 Erase(dc);
186
187 dc.SetLogicalFunction(OGLRBLF);
188
189 wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
190 dc.SetPen(dottedPen);
191 dc.SetBrush((* wxTRANSPARENT_BRUSH));
192 m_canvas->CaptureMouse();
193
194 double xx = x;
195 double yy = y;
196 m_canvas->Snap(&xx, &yy);
197 double offsetX = xx - objectStartX;
198 double offsetY = yy - objectStartY;
199
200 GetEventHandler()->OnDrawOutline(dc, GetX() + offsetX, GetY() + offsetY, GetWidth(), GetHeight());
201
202 // wxShape::OnBeginDragLeft(x, y, keys, attachment);
203 }
204
205 void wxCompositeShape::OnEndDragLeft(double x, double y, int keys, int WXUNUSED(attachment))
206 {
207 // wxShape::OnEndDragLeft(x, y, keys, attachment);
208
209 wxClientDC dc(GetCanvas());
210 GetCanvas()->PrepareDC(dc);
211
212 m_canvas->ReleaseMouse();
213
214 if (!m_draggable)
215 {
216 if (m_parent) m_parent->GetEventHandler()->OnEndDragLeft(x, y, keys, 0);
217 return;
218 }
219
220 dc.SetLogicalFunction(wxCOPY);
221 double xx = x;
222 double yy = y;
223 m_canvas->Snap(&xx, &yy);
224 double offsetX = xx - objectStartX;
225 double offsetY = yy - objectStartY;
226
227 Move(dc, GetX() + offsetX, GetY() + offsetY);
228
229 if (m_canvas && !m_canvas->GetQuickEditMode()) m_canvas->Redraw(dc);
230 }
231
232 void wxCompositeShape::OnRightClick(double x, double y, int keys, int WXUNUSED(attachment))
233 {
234 // If we get a ctrl-right click, this means send the message to
235 // the division, so we can invoke a user interface for dealing with regions.
236 if (keys & KEY_CTRL)
237 {
238 wxNode *node = m_divisions.GetFirst();
239 while (node)
240 {
241 wxDivisionShape *division = (wxDivisionShape *)node->GetData();
242 wxNode *next = node->GetNext();
243 int attach = 0;
244 double dist = 0.0;
245 if (division->HitTest(x, y, &attach, &dist))
246 {
247 division->GetEventHandler()->OnRightClick(x, y, keys, attach);
248 node = NULL;
249 }
250 if (node)
251 node = next;
252 }
253 }
254 }
255
256 void wxCompositeShape::SetSize(double w, double h, bool recursive)
257 {
258 SetAttachmentSize(w, h);
259
260 double xScale = (double)(w/(wxMax(1.0, GetWidth())));
261 double yScale = (double)(h/(wxMax(1.0, GetHeight())));
262
263 m_width = w;
264 m_height = h;
265
266 if (!recursive) return;
267
268 wxNode *node = m_children.GetFirst();
269
270 wxClientDC dc(GetCanvas());
271 GetCanvas()->PrepareDC(dc);
272
273 double xBound, yBound;
274 while (node)
275 {
276 wxShape *object = (wxShape *)node->GetData();
277
278 // Scale the position first
279 double newX = (double)(((object->GetX() - GetX())*xScale) + GetX());
280 double newY = (double)(((object->GetY() - GetY())*yScale) + GetY());
281 object->Show(FALSE);
282 object->Move(dc, newX, newY);
283 object->Show(TRUE);
284
285 // Now set the scaled size
286 object->GetBoundingBoxMin(&xBound, &yBound);
287 object->SetSize(object->GetFixedWidth() ? xBound : xScale*xBound,
288 object->GetFixedHeight() ? yBound : yScale*yBound);
289
290 node = node->GetNext();
291 }
292 SetDefaultRegionSize();
293 }
294
295 void wxCompositeShape::AddChild(wxShape *child, wxShape *addAfter)
296 {
297 m_children.Append(child);
298 child->SetParent(this);
299 if (m_canvas)
300 {
301 // Ensure we add at the right position
302 if (addAfter)
303 child->RemoveFromCanvas(m_canvas);
304 child->AddToCanvas(m_canvas, addAfter);
305 }
306 }
307
308 void wxCompositeShape::RemoveChild(wxShape *child)
309 {
310 m_children.DeleteObject(child);
311 m_divisions.DeleteObject(child);
312 RemoveChildFromConstraints(child);
313 child->SetParent(NULL);
314 }
315
316 void wxCompositeShape::DeleteConstraintsInvolvingChild(wxShape *child)
317 {
318 wxNode *node = m_constraints.GetFirst();
319 while (node)
320 {
321 wxOGLConstraint *constraint = (wxOGLConstraint *)node->GetData();
322 wxNode *nextNode = node->GetNext();
323
324 if ((constraint->m_constrainingObject == child) ||
325 constraint->m_constrainedObjects.Member(child))
326 {
327 delete constraint;
328 delete node;
329 }
330 node = nextNode;
331 }
332 }
333
334 void wxCompositeShape::RemoveChildFromConstraints(wxShape *child)
335 {
336 wxNode *node = m_constraints.GetFirst();
337 while (node)
338 {
339 wxOGLConstraint *constraint = (wxOGLConstraint *)node->GetData();
340 wxNode *nextNode = node->GetNext();
341
342 if (constraint->m_constrainedObjects.Member(child))
343 constraint->m_constrainedObjects.DeleteObject(child);
344 if (constraint->m_constrainingObject == child)
345 constraint->m_constrainingObject = NULL;
346
347 // Delete the constraint if no participants left
348 if (!constraint->m_constrainingObject)
349 {
350 delete constraint;
351 delete node;
352 }
353
354 node = nextNode;
355 }
356 }
357
358 void wxCompositeShape::Copy(wxShape& copy)
359 {
360 wxRectangleShape::Copy(copy);
361
362 wxASSERT( copy.IsKindOf(CLASSINFO(wxCompositeShape)) ) ;
363
364 wxCompositeShape& compositeCopy = (wxCompositeShape&) copy;
365
366 // Associate old and new copies for compositeCopying constraints and division geometry
367 oglObjectCopyMapping.Append((long)this, &compositeCopy);
368
369 // Copy the children
370 wxNode *node = m_children.GetFirst();
371 while (node)
372 {
373 wxShape *object = (wxShape *)node->GetData();
374 wxShape *newObject = object->CreateNewCopy(FALSE, FALSE);
375 if (newObject->GetId() == 0)
376 newObject->SetId(wxNewId());
377
378 newObject->SetParent(&compositeCopy);
379 compositeCopy.m_children.Append(newObject);
380
381 // Some m_children may be divisions
382 if (m_divisions.Member(object))
383 compositeCopy.m_divisions.Append(newObject);
384
385 oglObjectCopyMapping.Append((long)object, newObject);
386
387 node = node->GetNext();
388 }
389
390 // Copy the constraints
391 node = m_constraints.GetFirst();
392 while (node)
393 {
394 wxOGLConstraint *constraint = (wxOGLConstraint *)node->GetData();
395
396 wxShape *newConstraining = (wxShape *)(oglObjectCopyMapping.Find((long)constraint->m_constrainingObject)->GetData());
397
398 wxList newConstrainedList;
399 wxNode *node2 = constraint->m_constrainedObjects.GetFirst();
400 while (node2)
401 {
402 wxShape *constrainedObject = (wxShape *)node2->GetData();
403 wxShape *newConstrained = (wxShape *)(oglObjectCopyMapping.Find((long)constrainedObject)->GetData());
404 newConstrainedList.Append(newConstrained);
405 node2 = node2->GetNext();
406 }
407
408 wxOGLConstraint *newConstraint = new wxOGLConstraint(constraint->m_constraintType, newConstraining,
409 newConstrainedList);
410 newConstraint->m_constraintId = constraint->m_constraintId;
411 if (constraint->m_constraintName)
412 {
413 newConstraint->m_constraintName = constraint->m_constraintName;
414 }
415 newConstraint->SetSpacing(constraint->m_xSpacing, constraint->m_ySpacing);
416 compositeCopy.m_constraints.Append(newConstraint);
417
418 node = node->GetNext();
419 }
420
421 // Now compositeCopy the division geometry
422 node = m_divisions.GetFirst();
423 while (node)
424 {
425 wxDivisionShape *division = (wxDivisionShape *)node->GetData();
426 wxNode *node1 = oglObjectCopyMapping.Find((long)division);
427 wxNode *leftNode = NULL;
428 wxNode *topNode = NULL;
429 wxNode *rightNode = NULL;
430 wxNode *bottomNode = NULL;
431 if (division->GetLeftSide())
432 leftNode = oglObjectCopyMapping.Find((long)division->GetLeftSide());
433 if (division->GetTopSide())
434 topNode = oglObjectCopyMapping.Find((long)division->GetTopSide());
435 if (division->GetRightSide())
436 rightNode = oglObjectCopyMapping.Find((long)division->GetRightSide());
437 if (division->GetBottomSide())
438 bottomNode = oglObjectCopyMapping.Find((long)division->GetBottomSide());
439 if (node1)
440 {
441 wxDivisionShape *newDivision = (wxDivisionShape *)node1->GetData();
442 if (leftNode)
443 newDivision->SetLeftSide((wxDivisionShape *)leftNode->GetData());
444 if (topNode)
445 newDivision->SetTopSide((wxDivisionShape *)topNode->GetData());
446 if (rightNode)
447 newDivision->SetRightSide((wxDivisionShape *)rightNode->GetData());
448 if (bottomNode)
449 newDivision->SetBottomSide((wxDivisionShape *)bottomNode->GetData());
450 }
451 node = node->GetNext();
452 }
453 }
454
455 wxOGLConstraint *wxCompositeShape::AddConstraint(wxOGLConstraint *constraint)
456 {
457 m_constraints.Append(constraint);
458 if (constraint->m_constraintId == 0)
459 constraint->m_constraintId = wxNewId();
460 return constraint;
461 }
462
463 wxOGLConstraint *wxCompositeShape::AddConstraint(int type, wxShape *constraining, wxList& constrained)
464 {
465 wxOGLConstraint *constraint = new wxOGLConstraint(type, constraining, constrained);
466 if (constraint->m_constraintId == 0)
467 constraint->m_constraintId = wxNewId();
468 m_constraints.Append(constraint);
469 return constraint;
470 }
471
472 wxOGLConstraint *wxCompositeShape::AddConstraint(int type, wxShape *constraining, wxShape *constrained)
473 {
474 wxList l;
475 l.Append(constrained);
476 wxOGLConstraint *constraint = new wxOGLConstraint(type, constraining, l);
477 if (constraint->m_constraintId == 0)
478 constraint->m_constraintId = wxNewId();
479 m_constraints.Append(constraint);
480 return constraint;
481 }
482
483 wxOGLConstraint *wxCompositeShape::FindConstraint(long cId, wxCompositeShape **actualComposite)
484 {
485 wxNode *node = m_constraints.GetFirst();
486 while (node)
487 {
488 wxOGLConstraint *constraint = (wxOGLConstraint *)node->GetData();
489 if (constraint->m_constraintId == cId)
490 {
491 if (actualComposite)
492 *actualComposite = this;
493 return constraint;
494 }
495 node = node->GetNext();
496 }
497 // If not found, try children.
498 node = m_children.GetFirst();
499 while (node)
500 {
501 wxShape *child = (wxShape *)node->GetData();
502 if (child->IsKindOf(CLASSINFO(wxCompositeShape)))
503 {
504 wxOGLConstraint *constraint = ((wxCompositeShape *)child)->FindConstraint(cId, actualComposite);
505 if (constraint)
506 {
507 if (actualComposite)
508 *actualComposite = (wxCompositeShape *)child;
509 return constraint;
510 }
511 }
512 node = node->GetNext();
513 }
514 return NULL;
515 }
516
517 void wxCompositeShape::DeleteConstraint(wxOGLConstraint *constraint)
518 {
519 m_constraints.DeleteObject(constraint);
520 delete constraint;
521 }
522
523 void wxCompositeShape::CalculateSize()
524 {
525 double maxX = (double) -999999.9;
526 double maxY = (double) -999999.9;
527 double minX = (double) 999999.9;
528 double minY = (double) 999999.9;
529
530 double w, h;
531 wxNode *node = m_children.GetFirst();
532 while (node)
533 {
534 wxShape *object = (wxShape *)node->GetData();
535
536 // Recalculate size of composite objects because may not conform
537 // to size it was set to - depends on the children.
538 object->CalculateSize();
539
540 object->GetBoundingBoxMax(&w, &h);
541 if ((object->GetX() + (w/2.0)) > maxX)
542 maxX = (double)(object->GetX() + (w/2.0));
543 if ((object->GetX() - (w/2.0)) < minX)
544 minX = (double)(object->GetX() - (w/2.0));
545 if ((object->GetY() + (h/2.0)) > maxY)
546 maxY = (double)(object->GetY() + (h/2.0));
547 if ((object->GetY() - (h/2.0)) < minY)
548 minY = (double)(object->GetY() - (h/2.0));
549
550 node = node->GetNext();
551 }
552 m_width = maxX - minX;
553 m_height = maxY - minY;
554 m_xpos = (double)(m_width/2.0 + minX);
555 m_ypos = (double)(m_height/2.0 + minY);
556 }
557
558 bool wxCompositeShape::Recompute()
559 {
560 int noIterations = 0;
561 bool changed = TRUE;
562 while (changed && (noIterations < 500))
563 {
564 changed = Constrain();
565 noIterations ++;
566 }
567 /*
568 #ifdef wx_x
569 if (changed)
570 cerr << "Warning: constraint algorithm failed after 500 iterations.\n";
571 #endif
572 */
573 return (!changed);
574 }
575
576 bool wxCompositeShape::Constrain()
577 {
578 CalculateSize();
579
580 bool changed = FALSE;
581 wxNode *node = m_children.GetFirst();
582 while (node)
583 {
584 wxShape *object = (wxShape *)node->GetData();
585 if (object->Constrain())
586 changed = TRUE;
587 node = node->GetNext();
588 }
589
590 node = m_constraints.GetFirst();
591 while (node)
592 {
593 wxOGLConstraint *constraint = (wxOGLConstraint *)node->GetData();
594 if (constraint->Evaluate()) changed = TRUE;
595 node = node->GetNext();
596 }
597 return changed;
598 }
599
600 #if wxUSE_PROLOGIO
601 void wxCompositeShape::WriteAttributes(wxExpr *clause)
602 {
603 wxRectangleShape::WriteAttributes(clause);
604
605 // clause->AddAttributeValue("selectable", (long)selectable);
606
607 // Output constraints as constraint1 = (...), constraint2 = (...), etc.
608 int constraintNo = 1;
609 wxChar m_constraintNameBuf[20];
610 wxNode *node = m_constraints.GetFirst();
611 while (node)
612 {
613 wxOGLConstraint *constraint = (wxOGLConstraint *)node->GetData();
614 wxSprintf(m_constraintNameBuf, _T("constraint%d"), constraintNo);
615
616 // Each constraint is stored in the form
617 // (type name id xspacing yspacing m_constrainingObjectId constrainedObjectIdList)
618 wxExpr *constraintExpr = new wxExpr(wxExprList);
619 constraintExpr->Append(new wxExpr((long)constraint->m_constraintType));
620 constraintExpr->Append(new wxExpr(wxExprString, constraint->m_constraintName));
621 constraintExpr->Append(new wxExpr(constraint->m_constraintId));
622 constraintExpr->Append(new wxExpr(constraint->m_xSpacing));
623 constraintExpr->Append(new wxExpr(constraint->m_ySpacing));
624 constraintExpr->Append(new wxExpr(constraint->m_constrainingObject->GetId()));
625
626 wxExpr *objectList = new wxExpr(wxExprList);
627 wxNode *node1 = constraint->m_constrainedObjects.GetFirst();
628 while (node1)
629 {
630 wxShape *obj = (wxShape *)node1->GetData();
631 objectList->Append(new wxExpr(obj->GetId()));
632 node1 = node1->GetNext();
633 }
634 constraintExpr->Append(objectList);
635
636 clause->AddAttributeValue(m_constraintNameBuf, constraintExpr);
637
638 node = node->GetNext();
639 constraintNo ++;
640 }
641
642 // Write the ids of all the child images
643 wxExpr *childrenExpr = new wxExpr(wxExprList);
644 node = m_children.GetFirst();
645 while (node)
646 {
647 wxShape *child = (wxShape *)node->GetData();
648 childrenExpr->Append(new wxExpr(child->GetId()));
649 node = node->GetNext();
650 }
651 clause->AddAttributeValue(_T("children"), childrenExpr);
652
653 // Write the ids of all the division images
654 if (m_divisions.GetCount() > 0)
655 {
656 wxExpr *divisionsExpr = new wxExpr(wxExprList);
657 node = m_divisions.GetFirst();
658 while (node)
659 {
660 wxShape *child = (wxShape *)node->GetData();
661 divisionsExpr->Append(new wxExpr(child->GetId()));
662 node = node->GetNext();
663 }
664 clause->AddAttributeValue(_T("divisions"), divisionsExpr);
665 }
666 }
667
668 // Problem. Child images are always written AFTER the parent
669 // so as to be able to link up to parent. So we may not be able
670 // to find the constraint participants until we've read everything
671 // in. Need to have another pass for composites.
672 void wxCompositeShape::ReadAttributes(wxExpr *clause)
673 {
674 wxRectangleShape::ReadAttributes(clause);
675
676 // clause->GetAttributeValue("selectable", selectable);
677 }
678
679 void wxCompositeShape::ReadConstraints(wxExpr *clause, wxExprDatabase *database)
680 {
681 // Constraints are output as constraint1 = (...), constraint2 = (...), etc.
682 int constraintNo = 1;
683 wxChar m_constraintNameBuf[20];
684 bool haveConstraints = TRUE;
685
686 while (haveConstraints)
687 {
688 wxSprintf(m_constraintNameBuf, _T("constraint%d"), constraintNo);
689 wxExpr *constraintExpr = NULL;
690 clause->GetAttributeValue(m_constraintNameBuf, &constraintExpr);
691 if (!constraintExpr)
692 {
693 haveConstraints = FALSE;
694 break;
695 }
696 int cType = 0;
697 double cXSpacing = 0.0;
698 double cYSpacing = 0.0;
699 wxString cName = wxEmptyString;
700 long cId = 0;
701 wxShape *m_constrainingObject = NULL;
702 wxList m_constrainedObjects;
703
704 // Each constraint is stored in the form
705 // (type name id xspacing yspacing m_constrainingObjectId constrainedObjectIdList)
706
707 wxExpr *typeExpr = constraintExpr->Nth(0);
708 wxExpr *nameExpr = constraintExpr->Nth(1);
709 wxExpr *idExpr = constraintExpr->Nth(2);
710 wxExpr *xExpr = constraintExpr->Nth(3);
711 wxExpr *yExpr = constraintExpr->Nth(4);
712 wxExpr *constrainingExpr = constraintExpr->Nth(5);
713 wxExpr *constrainedExpr = constraintExpr->Nth(6);
714
715 cType = (int)typeExpr->IntegerValue();
716 cXSpacing = xExpr->RealValue();
717 cYSpacing = yExpr->RealValue();
718 cName = nameExpr->StringValue();
719 cId = idExpr->IntegerValue();
720
721 wxExpr *objExpr1 = database->HashFind(_T("node_image"), constrainingExpr->IntegerValue());
722 if (objExpr1 && objExpr1->GetClientData())
723 m_constrainingObject = (wxShape *)objExpr1->GetClientData();
724 else
725 wxLogFatalError(wxT("Object graphics error: Couldn't find constraining image of composite."));
726
727 int i = 0;
728 wxExpr *currentIdExpr = constrainedExpr->Nth(i);
729 while (currentIdExpr)
730 {
731 long currentId = currentIdExpr->IntegerValue();
732 wxExpr *objExpr2 = database->HashFind(_T("node_image"), currentId);
733 if (objExpr2 && objExpr2->GetClientData())
734 {
735 m_constrainedObjects.Append((wxShape *)objExpr2->GetClientData());
736 }
737 else
738 {
739 wxLogFatalError(wxT("Object graphics error: Couldn't find constrained image of composite."));
740 }
741
742 i ++;
743 currentIdExpr = constrainedExpr->Nth(i);
744 }
745 wxOGLConstraint *newConstraint = AddConstraint(cType, m_constrainingObject, m_constrainedObjects);
746 newConstraint->SetSpacing(cXSpacing, cYSpacing);
747 newConstraint->m_constraintId = cId;
748 newConstraint->m_constraintName = cName;
749 constraintNo ++;
750 }
751 }
752 #endif
753
754 // Make this composite into a container by creating one wxDivisionShape
755 void wxCompositeShape::MakeContainer()
756 {
757 wxDivisionShape *division = OnCreateDivision();
758 m_divisions.Append(division);
759 AddChild(division);
760
761 division->SetSize(m_width, m_height);
762
763 wxClientDC dc(GetCanvas());
764 GetCanvas()->PrepareDC(dc);
765
766 division->Move(dc, GetX(), GetY());
767 Recompute();
768 division->Show(TRUE);
769 }
770
771 wxDivisionShape *wxCompositeShape::OnCreateDivision()
772 {
773 return new wxDivisionShape;
774 }
775
776 wxShape *wxCompositeShape::FindContainerImage()
777 {
778 wxNode *node = m_children.GetFirst();
779 while (node)
780 {
781 wxShape *child = (wxShape *)node->GetData();
782 if (!m_divisions.Member(child))
783 return child;
784 node = node->GetNext();
785 }
786 return NULL;
787 }
788
789 // Returns TRUE if division is a descendant of this container
790 bool wxCompositeShape::ContainsDivision(wxDivisionShape *division)
791 {
792 if (m_divisions.Member(division))
793 return TRUE;
794 wxNode *node = m_children.GetFirst();
795 while (node)
796 {
797 wxShape *child = (wxShape *)node->GetData();
798 if (child->IsKindOf(CLASSINFO(wxCompositeShape)))
799 {
800 bool ans = ((wxCompositeShape *)child)->ContainsDivision(division);
801 if (ans)
802 return TRUE;
803 }
804 node = node->GetNext();
805 }
806 return FALSE;
807 }
808
809 /*
810 * Division object
811 *
812 */
813
814 IMPLEMENT_DYNAMIC_CLASS(wxDivisionShape, wxCompositeShape)
815
816 wxDivisionShape::wxDivisionShape()
817 {
818 SetSensitivityFilter(OP_CLICK_LEFT | OP_CLICK_RIGHT | OP_DRAG_RIGHT);
819 SetCentreResize(FALSE);
820 SetAttachmentMode(TRUE);
821 m_leftSide = NULL;
822 m_rightSide = NULL;
823 m_topSide = NULL;
824 m_bottomSide = NULL;
825 m_handleSide = DIVISION_SIDE_NONE;
826 m_leftSidePen = wxBLACK_PEN;
827 m_topSidePen = wxBLACK_PEN;
828 m_leftSideColour = wxT("BLACK");
829 m_topSideColour = wxT("BLACK");
830 m_leftSideStyle = wxT("Solid");
831 m_topSideStyle = wxT("Solid");
832 ClearRegions();
833 }
834
835 wxDivisionShape::~wxDivisionShape()
836 {
837 }
838
839 void wxDivisionShape::OnDraw(wxDC& dc)
840 {
841 dc.SetBrush(* wxTRANSPARENT_BRUSH);
842 dc.SetBackgroundMode(wxTRANSPARENT);
843
844 double x1 = (double)(GetX() - (GetWidth()/2.0));
845 double y1 = (double)(GetY() - (GetHeight()/2.0));
846 double x2 = (double)(GetX() + (GetWidth()/2.0));
847 double y2 = (double)(GetY() + (GetHeight()/2.0));
848
849 // Should subtract 1 pixel if drawing under Windows
850 #ifdef __WXMSW__
851 y2 -= (double)1.0;
852 #endif
853
854 if (m_leftSide)
855 {
856 dc.SetPen(* m_leftSidePen);
857 dc.DrawLine(WXROUND(x1), WXROUND(y2), WXROUND(x1), WXROUND(y1));
858 }
859 if (m_topSide)
860 {
861 dc.SetPen(* m_topSidePen);
862 dc.DrawLine(WXROUND(x1), WXROUND(y1), WXROUND(x2), WXROUND(y1));
863 }
864
865 // For testing purposes, draw a rectangle so we know
866 // how big the division is.
867 // SetBrush(* wxCYAN_BRUSH);
868 // wxRectangleShape::OnDraw(dc);
869 }
870
871 void wxDivisionShape::OnDrawContents(wxDC& dc)
872 {
873 wxCompositeShape::OnDrawContents(dc);
874 }
875
876 bool wxDivisionShape::OnMovePre(wxDC& dc, double x, double y, double oldx, double oldy, bool display)
877 {
878 double diffX = x - oldx;
879 double diffY = y - oldy;
880 wxNode *node = m_children.GetFirst();
881 while (node)
882 {
883 wxShape *object = (wxShape *)node->GetData();
884 object->Erase(dc);
885 object->Move(dc, object->GetX() + diffX, object->GetY() + diffY, display);
886 node = node->GetNext();
887 }
888 return TRUE;
889 }
890
891 void wxDivisionShape::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
892 {
893 if ((m_sensitivity & OP_DRAG_LEFT) != OP_DRAG_LEFT)
894 {
895 attachment = 0;
896 double dist;
897 if (m_parent)
898 {
899 m_parent->HitTest(x, y, &attachment, &dist);
900 m_parent->GetEventHandler()->OnDragLeft(draw, x, y, keys, attachment);
901 }
902 return;
903 }
904 wxShape::OnDragLeft(draw, x, y, keys, attachment);
905 }
906
907 void wxDivisionShape::OnBeginDragLeft(double x, double y, int keys, int attachment)
908 {
909 if ((m_sensitivity & OP_DRAG_LEFT) != OP_DRAG_LEFT)
910 {
911 attachment = 0;
912 double dist;
913 if (m_parent)
914 {
915 m_parent->HitTest(x, y, &attachment, &dist);
916 m_parent->GetEventHandler()->OnBeginDragLeft(x, y, keys, attachment);
917 }
918 return;
919 }
920
921 wxShape::OnBeginDragLeft(x, y, keys, attachment);
922 }
923
924 void wxDivisionShape::OnEndDragLeft(double x, double y, int keys, int attachment)
925 {
926 m_canvas->ReleaseMouse();
927 if ((m_sensitivity & OP_DRAG_LEFT) != OP_DRAG_LEFT)
928 {
929 attachment = 0;
930 double dist;
931 if (m_parent)
932 {
933 m_parent->HitTest(x, y, &attachment, &dist);
934 m_parent->GetEventHandler()->OnEndDragLeft(x, y, keys, attachment);
935 }
936 return;
937 }
938
939 wxClientDC dc(GetCanvas());
940 GetCanvas()->PrepareDC(dc);
941
942 dc.SetLogicalFunction(wxCOPY);
943
944 m_canvas->Snap(&m_xpos, &m_ypos);
945 GetEventHandler()->OnMovePre(dc, x, y, m_oldX, m_oldY);
946
947 ResetControlPoints();
948 Draw(dc);
949 MoveLinks(dc);
950 GetEventHandler()->OnDrawControlPoints(dc);
951
952 if (m_canvas && !m_canvas->GetQuickEditMode()) m_canvas->Redraw(dc);
953 }
954
955 void wxDivisionShape::SetSize(double w, double h, bool recursive)
956 {
957 m_width = w;
958 m_height = h;
959 wxRectangleShape::SetSize(w, h, recursive);
960 }
961
962 void wxDivisionShape::CalculateSize()
963 {
964 }
965
966 void wxDivisionShape::Copy(wxShape& copy)
967 {
968 wxCompositeShape::Copy(copy);
969
970 wxASSERT( copy.IsKindOf(CLASSINFO(wxDivisionShape)) ) ;
971
972 wxDivisionShape& divisionCopy = (wxDivisionShape&) copy;
973
974 divisionCopy.m_leftSideStyle = m_leftSideStyle;
975 divisionCopy.m_topSideStyle = m_topSideStyle;
976 divisionCopy.m_leftSideColour = m_leftSideColour;
977 divisionCopy.m_topSideColour = m_topSideColour;
978
979 divisionCopy.m_leftSidePen = m_leftSidePen;
980 divisionCopy.m_topSidePen = m_topSidePen;
981 divisionCopy.m_handleSide = m_handleSide;
982
983 // Division geometry copying is handled at the wxCompositeShape level.
984 }
985
986 #if wxUSE_PROLOGIO
987 void wxDivisionShape::WriteAttributes(wxExpr *clause)
988 {
989 wxCompositeShape::WriteAttributes(clause);
990
991 if (m_leftSide)
992 clause->AddAttributeValue(_T("left_side"), (long)m_leftSide->GetId());
993 if (m_topSide)
994 clause->AddAttributeValue(_T("top_side"), (long)m_topSide->GetId());
995 if (m_rightSide)
996 clause->AddAttributeValue(_T("right_side"), (long)m_rightSide->GetId());
997 if (m_bottomSide)
998 clause->AddAttributeValue(_T("bottom_side"), (long)m_bottomSide->GetId());
999
1000 clause->AddAttributeValue(_T("handle_side"), (long)m_handleSide);
1001 clause->AddAttributeValueString(_T("left_colour"), m_leftSideColour);
1002 clause->AddAttributeValueString(_T("top_colour"), m_topSideColour);
1003 clause->AddAttributeValueString(_T("left_style"), m_leftSideStyle);
1004 clause->AddAttributeValueString(_T("top_style"), m_topSideStyle);
1005 }
1006
1007 void wxDivisionShape::ReadAttributes(wxExpr *clause)
1008 {
1009 wxCompositeShape::ReadAttributes(clause);
1010
1011 clause->GetAttributeValue(_T("handle_side"), m_handleSide);
1012 clause->GetAttributeValue(_T("left_colour"), m_leftSideColour);
1013 clause->GetAttributeValue(_T("top_colour"), m_topSideColour);
1014 clause->GetAttributeValue(_T("left_style"), m_leftSideStyle);
1015 clause->GetAttributeValue(_T("top_style"), m_topSideStyle);
1016 }
1017 #endif
1018
1019 // Experimental
1020 void wxDivisionShape::OnRightClick(double x, double y, int keys, int attachment)
1021 {
1022 if (keys & KEY_CTRL)
1023 {
1024 PopupMenu(x, y);
1025 }
1026 /*
1027 else if (keys & KEY_SHIFT)
1028 {
1029 if (m_leftSide || m_topSide || m_rightSide || m_bottomSide)
1030 {
1031 if (Selected())
1032 {
1033 Select(FALSE);
1034 GetParent()->Draw(dc);
1035 }
1036 else
1037 Select(TRUE);
1038 }
1039 }
1040 */
1041 else
1042 {
1043 attachment = 0;
1044 double dist;
1045 if (m_parent)
1046 {
1047 m_parent->HitTest(x, y, &attachment, &dist);
1048 m_parent->GetEventHandler()->OnRightClick(x, y, keys, attachment);
1049 }
1050 return;
1051 }
1052 }
1053
1054
1055 // Divide wxHORIZONTALly or wxVERTICALly
1056 bool wxDivisionShape::Divide(int direction)
1057 {
1058 // Calculate existing top-left, bottom-right
1059 double x1 = (double)(GetX() - (GetWidth()/2.0));
1060 double y1 = (double)(GetY() - (GetHeight()/2.0));
1061 wxCompositeShape *compositeParent = (wxCompositeShape *)GetParent();
1062 double oldWidth = GetWidth();
1063 double oldHeight = GetHeight();
1064 if (Selected())
1065 Select(FALSE);
1066
1067 wxClientDC dc(GetCanvas());
1068 GetCanvas()->PrepareDC(dc);
1069
1070 if (direction == wxVERTICAL)
1071 {
1072 // Dividing vertically means notionally putting a horizontal line through it.
1073 // Break existing piece into two.
1074 double newXPos1 = GetX();
1075 double newYPos1 = (double)(y1 + (GetHeight()/4.0));
1076 double newXPos2 = GetX();
1077 double newYPos2 = (double)(y1 + (3.0*GetHeight()/4.0));
1078 wxDivisionShape *newDivision = compositeParent->OnCreateDivision();
1079 newDivision->Show(TRUE);
1080
1081 Erase(dc);
1082
1083 // Anything adjoining the bottom of this division now adjoins the
1084 // bottom of the new division.
1085 wxNode *node = compositeParent->GetDivisions().GetFirst();
1086 while (node)
1087 {
1088 wxDivisionShape *obj = (wxDivisionShape *)node->GetData();
1089 if (obj->GetTopSide() == this)
1090 obj->SetTopSide(newDivision);
1091 node = node->GetNext();
1092 }
1093 newDivision->SetTopSide(this);
1094 newDivision->SetBottomSide(m_bottomSide);
1095 newDivision->SetLeftSide(m_leftSide);
1096 newDivision->SetRightSide(m_rightSide);
1097 m_bottomSide = newDivision;
1098
1099 compositeParent->GetDivisions().Append(newDivision);
1100
1101 // CHANGE: Need to insert this division at start of divisions in the object
1102 // list, because e.g.:
1103 // 1) Add division
1104 // 2) Add contained object
1105 // 3) Add division
1106 // Division is now receiving mouse events _before_ the contained object,
1107 // because it was added last (on top of all others)
1108
1109 // Add after the image that visualizes the container
1110 compositeParent->AddChild(newDivision, compositeParent->FindContainerImage());
1111
1112 m_handleSide = DIVISION_SIDE_BOTTOM;
1113 newDivision->SetHandleSide(DIVISION_SIDE_TOP);
1114
1115 SetSize(oldWidth, (double)(oldHeight/2.0));
1116 Move(dc, newXPos1, newYPos1);
1117
1118 newDivision->SetSize(oldWidth, (double)(oldHeight/2.0));
1119 newDivision->Move(dc, newXPos2, newYPos2);
1120 }
1121 else
1122 {
1123 // Dividing horizontally means notionally putting a vertical line through it.
1124 // Break existing piece into two.
1125 double newXPos1 = (double)(x1 + (GetWidth()/4.0));
1126 double newYPos1 = GetY();
1127 double newXPos2 = (double)(x1 + (3.0*GetWidth()/4.0));
1128 double newYPos2 = GetY();
1129 wxDivisionShape *newDivision = compositeParent->OnCreateDivision();
1130 newDivision->Show(TRUE);
1131
1132 Erase(dc);
1133
1134 // Anything adjoining the left of this division now adjoins the
1135 // left of the new division.
1136 wxNode *node = compositeParent->GetDivisions().GetFirst();
1137 while (node)
1138 {
1139 wxDivisionShape *obj = (wxDivisionShape *)node->GetData();
1140 if (obj->GetLeftSide() == this)
1141 obj->SetLeftSide(newDivision);
1142 node = node->GetNext();
1143 }
1144 newDivision->SetTopSide(m_topSide);
1145 newDivision->SetBottomSide(m_bottomSide);
1146 newDivision->SetLeftSide(this);
1147 newDivision->SetRightSide(m_rightSide);
1148 m_rightSide = newDivision;
1149
1150 compositeParent->GetDivisions().Append(newDivision);
1151 compositeParent->AddChild(newDivision, compositeParent->FindContainerImage());
1152
1153 m_handleSide = DIVISION_SIDE_RIGHT;
1154 newDivision->SetHandleSide(DIVISION_SIDE_LEFT);
1155
1156 SetSize((double)(oldWidth/2.0), oldHeight);
1157 Move(dc, newXPos1, newYPos1);
1158
1159 newDivision->SetSize((double)(oldWidth/2.0), oldHeight);
1160 newDivision->Move(dc, newXPos2, newYPos2);
1161 }
1162 if (compositeParent->Selected())
1163 {
1164 compositeParent->DeleteControlPoints(& dc);
1165 compositeParent->MakeControlPoints();
1166 compositeParent->MakeMandatoryControlPoints();
1167 }
1168 compositeParent->Draw(dc);
1169 return TRUE;
1170 }
1171
1172 // Make one control point for every visible line
1173 void wxDivisionShape::MakeControlPoints()
1174 {
1175 MakeMandatoryControlPoints();
1176 }
1177
1178 void wxDivisionShape::MakeMandatoryControlPoints()
1179 {
1180 double maxX, maxY;
1181
1182 GetBoundingBoxMax(&maxX, &maxY);
1183 double x, y;
1184 int direction;
1185 /*
1186 if (m_leftSide)
1187 {
1188 x = (double)(-maxX/2.0);
1189 y = 0.0;
1190 wxDivisionControlPoint *control = new wxDivisionControlPoint(m_canvas, this, CONTROL_POINT_SIZE, x, y,
1191 CONTROL_POINT_HORIZONTAL);
1192 m_canvas->AddShape(control);
1193 m_controlPoints.Append(control);
1194 }
1195 if (m_topSide)
1196 {
1197 x = 0.0;
1198 y = (double)(-maxY/2.0);
1199 wxDivisionControlPoint *control = new wxDivisionControlPoint(m_canvas, this, CONTROL_POINT_SIZE, x, y,
1200 CONTROL_POINT_VERTICAL);
1201 m_canvas->AddShape(control);
1202 m_controlPoints.Append(control);
1203 }
1204 */
1205 switch (m_handleSide)
1206 {
1207 case DIVISION_SIDE_LEFT:
1208 {
1209 x = (double)(-maxX/2.0);
1210 y = 0.0;
1211 direction = CONTROL_POINT_HORIZONTAL;
1212 break;
1213 }
1214 case DIVISION_SIDE_TOP:
1215 {
1216 x = 0.0;
1217 y = (double)(-maxY/2.0);
1218 direction = CONTROL_POINT_VERTICAL;
1219 break;
1220 }
1221 case DIVISION_SIDE_RIGHT:
1222 {
1223 x = (double)(maxX/2.0);
1224 y = 0.0;
1225 direction = CONTROL_POINT_HORIZONTAL;
1226 break;
1227 }
1228 case DIVISION_SIDE_BOTTOM:
1229 {
1230 x = 0.0;
1231 y = (double)(maxY/2.0);
1232 direction = CONTROL_POINT_VERTICAL;
1233 break;
1234 }
1235 default:
1236 break;
1237 }
1238 if (m_handleSide != DIVISION_SIDE_NONE)
1239 {
1240 wxDivisionControlPoint *control = new wxDivisionControlPoint(m_canvas, this, CONTROL_POINT_SIZE, x, y,
1241 direction);
1242 m_canvas->AddShape(control);
1243 m_controlPoints.Append(control);
1244 }
1245 }
1246
1247 void wxDivisionShape::ResetControlPoints()
1248 {
1249 ResetMandatoryControlPoints();
1250 }
1251
1252 void wxDivisionShape::ResetMandatoryControlPoints()
1253 {
1254 if (m_controlPoints.GetCount() < 1)
1255 return;
1256
1257 double maxX, maxY;
1258
1259 GetBoundingBoxMax(&maxX, &maxY);
1260 /*
1261 wxNode *node = m_controlPoints.GetFirst();
1262 while (node)
1263 {
1264 wxDivisionControlPoint *control = (wxDivisionControlPoint *)node->GetData();
1265 if (control->type == CONTROL_POINT_HORIZONTAL)
1266 {
1267 control->xoffset = (double)(-maxX/2.0); control->m_yoffset = 0.0;
1268 }
1269 else if (control->type == CONTROL_POINT_VERTICAL)
1270 {
1271 control->xoffset = 0.0; control->m_yoffset = (double)(-maxY/2.0);
1272 }
1273 node = node->GetNext();
1274 }
1275 */
1276 wxNode *node = m_controlPoints.GetFirst();
1277 if ((m_handleSide == DIVISION_SIDE_LEFT) && node)
1278 {
1279 wxDivisionControlPoint *control = (wxDivisionControlPoint *)node->GetData();
1280 control->m_xoffset = (double)(-maxX/2.0); control->m_yoffset = 0.0;
1281 }
1282
1283 if ((m_handleSide == DIVISION_SIDE_TOP) && node)
1284 {
1285 wxDivisionControlPoint *control = (wxDivisionControlPoint *)node->GetData();
1286 control->m_xoffset = 0.0; control->m_yoffset = (double)(-maxY/2.0);
1287 }
1288
1289 if ((m_handleSide == DIVISION_SIDE_RIGHT) && node)
1290 {
1291 wxDivisionControlPoint *control = (wxDivisionControlPoint *)node->GetData();
1292 control->m_xoffset = (double)(maxX/2.0); control->m_yoffset = 0.0;
1293 }
1294
1295 if ((m_handleSide == DIVISION_SIDE_BOTTOM) && node)
1296 {
1297 wxDivisionControlPoint *control = (wxDivisionControlPoint *)node->GetData();
1298 control->m_xoffset = 0.0; control->m_yoffset = (double)(maxY/2.0);
1299 }
1300 }
1301
1302 // Adjust a side, returning FALSE if it's not physically possible.
1303 bool wxDivisionShape::AdjustLeft(double left, bool test)
1304 {
1305 double x2 = (double)(GetX() + (GetWidth()/2.0));
1306
1307 if (left >= x2)
1308 return FALSE;
1309 if (test)
1310 return TRUE;
1311
1312 double newW = x2 - left;
1313 double newX = (double)(left + newW/2.0);
1314 SetSize(newW, GetHeight());
1315
1316 wxClientDC dc(GetCanvas());
1317 GetCanvas()->PrepareDC(dc);
1318
1319 Move(dc, newX, GetY());
1320
1321 return TRUE;
1322 }
1323
1324 bool wxDivisionShape::AdjustTop(double top, bool test)
1325 {
1326 double y2 = (double)(GetY() + (GetHeight()/2.0));
1327
1328 if (top >= y2)
1329 return FALSE;
1330 if (test)
1331 return TRUE;
1332
1333 double newH = y2 - top;
1334 double newY = (double)(top + newH/2.0);
1335 SetSize(GetWidth(), newH);
1336
1337 wxClientDC dc(GetCanvas());
1338 GetCanvas()->PrepareDC(dc);
1339
1340 Move(dc, GetX(), newY);
1341
1342 return TRUE;
1343 }
1344
1345 bool wxDivisionShape::AdjustRight(double right, bool test)
1346 {
1347 double x1 = (double)(GetX() - (GetWidth()/2.0));
1348
1349 if (right <= x1)
1350 return FALSE;
1351 if (test)
1352 return TRUE;
1353
1354 double newW = right - x1;
1355 double newX = (double)(x1 + newW/2.0);
1356 SetSize(newW, GetHeight());
1357
1358 wxClientDC dc(GetCanvas());
1359 GetCanvas()->PrepareDC(dc);
1360
1361 Move(dc, newX, GetY());
1362
1363 return TRUE;
1364 }
1365
1366 bool wxDivisionShape::AdjustBottom(double bottom, bool test)
1367 {
1368 double y1 = (double)(GetY() - (GetHeight()/2.0));
1369
1370 if (bottom <= y1)
1371 return FALSE;
1372 if (test)
1373 return TRUE;
1374
1375 double newH = bottom - y1;
1376 double newY = (double)(y1 + newH/2.0);
1377 SetSize(GetWidth(), newH);
1378
1379 wxClientDC dc(GetCanvas());
1380 GetCanvas()->PrepareDC(dc);
1381
1382 Move(dc, GetX(), newY);
1383
1384 return TRUE;
1385 }
1386
1387 wxDivisionControlPoint::wxDivisionControlPoint(wxShapeCanvas *the_canvas, wxShape *object, double size, double the_xoffset, double the_yoffset, int the_type):
1388 wxControlPoint(the_canvas, object, size, the_xoffset, the_yoffset, the_type)
1389 {
1390 SetEraseObject(FALSE);
1391 }
1392
1393 wxDivisionControlPoint::~wxDivisionControlPoint()
1394 {
1395 }
1396
1397 static double originalX = 0.0;
1398 static double originalY = 0.0;
1399 static double originalW = 0.0;
1400 static double originalH = 0.0;
1401
1402 // Implement resizing of canvas object
1403 void wxDivisionControlPoint::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
1404 {
1405 wxControlPoint::OnDragLeft(draw, x, y, keys, attachment);
1406 }
1407
1408 void wxDivisionControlPoint::OnBeginDragLeft(double x, double y, int keys, int attachment)
1409 {
1410 wxDivisionShape *division = (wxDivisionShape *)m_shape;
1411 originalX = division->GetX();
1412 originalY = division->GetY();
1413 originalW = division->GetWidth();
1414 originalH = division->GetHeight();
1415
1416 wxControlPoint::OnBeginDragLeft(x, y, keys, attachment);
1417 }
1418
1419 void wxDivisionControlPoint::OnEndDragLeft(double x, double y, int keys, int attachment)
1420 {
1421 wxControlPoint::OnEndDragLeft(x, y, keys, attachment);
1422
1423 wxClientDC dc(GetCanvas());
1424 GetCanvas()->PrepareDC(dc);
1425
1426 wxDivisionShape *division = (wxDivisionShape *)m_shape;
1427 wxCompositeShape *divisionParent = (wxCompositeShape *)division->GetParent();
1428
1429 // Need to check it's within the bounds of the parent composite.
1430 double x1 = (double)(divisionParent->GetX() - (divisionParent->GetWidth()/2.0));
1431 double y1 = (double)(divisionParent->GetY() - (divisionParent->GetHeight()/2.0));
1432 double x2 = (double)(divisionParent->GetX() + (divisionParent->GetWidth()/2.0));
1433 double y2 = (double)(divisionParent->GetY() + (divisionParent->GetHeight()/2.0));
1434
1435 // Need to check it has not made the division zero or negative width/height
1436 double dx1 = (double)(division->GetX() - (division->GetWidth()/2.0));
1437 double dy1 = (double)(division->GetY() - (division->GetHeight()/2.0));
1438 double dx2 = (double)(division->GetX() + (division->GetWidth()/2.0));
1439 double dy2 = (double)(division->GetY() + (division->GetHeight()/2.0));
1440
1441 bool success = TRUE;
1442 switch (division->GetHandleSide())
1443 {
1444 case DIVISION_SIDE_LEFT:
1445 {
1446 if ((x <= x1) || (x >= x2) || (x >= dx2))
1447 success = FALSE;
1448 // Try it out first...
1449 else if (!division->ResizeAdjoining(DIVISION_SIDE_LEFT, x, TRUE))
1450 success = FALSE;
1451 else
1452 division->ResizeAdjoining(DIVISION_SIDE_LEFT, x, FALSE);
1453
1454 break;
1455 }
1456 case DIVISION_SIDE_TOP:
1457 {
1458 if ((y <= y1) || (y >= y2) || (y >= dy2))
1459 success = FALSE;
1460 else if (!division->ResizeAdjoining(DIVISION_SIDE_TOP, y, TRUE))
1461 success = FALSE;
1462 else
1463 division->ResizeAdjoining(DIVISION_SIDE_TOP, y, FALSE);
1464
1465 break;
1466 }
1467 case DIVISION_SIDE_RIGHT:
1468 {
1469 if ((x <= x1) || (x >= x2) || (x <= dx1))
1470 success = FALSE;
1471 else if (!division->ResizeAdjoining(DIVISION_SIDE_RIGHT, x, TRUE))
1472 success = FALSE;
1473 else
1474 division->ResizeAdjoining(DIVISION_SIDE_RIGHT, x, FALSE);
1475
1476 break;
1477 }
1478 case DIVISION_SIDE_BOTTOM:
1479 {
1480 if ((y <= y1) || (y >= y2) || (y <= dy1))
1481 success = FALSE;
1482 else if (!division->ResizeAdjoining(DIVISION_SIDE_BOTTOM, y, TRUE))
1483 success = FALSE;
1484 else
1485 division->ResizeAdjoining(DIVISION_SIDE_BOTTOM, y, FALSE);
1486
1487 break;
1488 }
1489 }
1490 if (!success)
1491 {
1492 division->SetSize(originalW, originalH);
1493 division->Move(dc, originalX, originalY);
1494 }
1495 divisionParent->Draw(dc);
1496 division->GetEventHandler()->OnDrawControlPoints(dc);
1497 }
1498
1499 /* Resize adjoining divisions.
1500 *
1501 Behaviour should be as follows:
1502 If right edge moves, find all objects whose left edge
1503 adjoins this object, and move left edge accordingly.
1504 If left..., move ... right.
1505 If top..., move ... bottom.
1506 If bottom..., move top.
1507 If size goes to zero or end position is other side of start position,
1508 resize to original size and return.
1509 */
1510 bool wxDivisionShape::ResizeAdjoining(int side, double newPos, bool test)
1511 {
1512 wxCompositeShape *divisionParent = (wxCompositeShape *)GetParent();
1513 wxNode *node = divisionParent->GetDivisions().GetFirst();
1514 while (node)
1515 {
1516 wxDivisionShape *division = (wxDivisionShape *)node->GetData();
1517 switch (side)
1518 {
1519 case DIVISION_SIDE_LEFT:
1520 {
1521 if (division->m_rightSide == this)
1522 {
1523 bool success = division->AdjustRight(newPos, test);
1524 if (!success && test)
1525 return FALSE;
1526 }
1527 break;
1528 }
1529 case DIVISION_SIDE_TOP:
1530 {
1531 if (division->m_bottomSide == this)
1532 {
1533 bool success = division->AdjustBottom(newPos, test);
1534 if (!success && test)
1535 return FALSE;
1536 }
1537 break;
1538 }
1539 case DIVISION_SIDE_RIGHT:
1540 {
1541 if (division->m_leftSide == this)
1542 {
1543 bool success = division->AdjustLeft(newPos, test);
1544 if (!success && test)
1545 return FALSE;
1546 }
1547 break;
1548 }
1549 case DIVISION_SIDE_BOTTOM:
1550 {
1551 if (division->m_topSide == this)
1552 {
1553 bool success = division->AdjustTop(newPos, test);
1554 if (!success && test)
1555 return FALSE;
1556 }
1557 break;
1558 }
1559 default:
1560 break;
1561 }
1562 node = node->GetNext();
1563 }
1564
1565 return TRUE;
1566 }
1567
1568 /*
1569 * Popup menu for editing divisions
1570 *
1571 */
1572 class OGLPopupDivisionMenu : public wxMenu {
1573 public:
1574 OGLPopupDivisionMenu() : wxMenu() {
1575 Append(DIVISION_MENU_SPLIT_HORIZONTALLY, wxT("Split horizontally"));
1576 Append(DIVISION_MENU_SPLIT_VERTICALLY, wxT("Split vertically"));
1577 AppendSeparator();
1578 Append(DIVISION_MENU_EDIT_LEFT_EDGE, wxT("Edit left edge"));
1579 Append(DIVISION_MENU_EDIT_TOP_EDGE, wxT("Edit top edge"));
1580 }
1581
1582 void OnMenu(wxCommandEvent& event);
1583
1584 DECLARE_EVENT_TABLE()
1585 };
1586
1587 BEGIN_EVENT_TABLE(OGLPopupDivisionMenu, wxMenu)
1588 EVT_CUSTOM_RANGE(wxEVT_COMMAND_MENU_SELECTED,
1589 DIVISION_MENU_SPLIT_HORIZONTALLY,
1590 DIVISION_MENU_EDIT_BOTTOM_EDGE,
1591 OGLPopupDivisionMenu::OnMenu)
1592 END_EVENT_TABLE()
1593
1594
1595 void OGLPopupDivisionMenu::OnMenu(wxCommandEvent& event)
1596 {
1597 wxDivisionShape *division = (wxDivisionShape *)GetClientData();
1598 switch (event.GetInt())
1599 {
1600 case DIVISION_MENU_SPLIT_HORIZONTALLY:
1601 {
1602 division->Divide(wxHORIZONTAL);
1603 break;
1604 }
1605 case DIVISION_MENU_SPLIT_VERTICALLY:
1606 {
1607 division->Divide(wxVERTICAL);
1608 break;
1609 }
1610 case DIVISION_MENU_EDIT_LEFT_EDGE:
1611 {
1612 division->EditEdge(DIVISION_SIDE_LEFT);
1613 break;
1614 }
1615 case DIVISION_MENU_EDIT_TOP_EDGE:
1616 {
1617 division->EditEdge(DIVISION_SIDE_TOP);
1618 break;
1619 }
1620 default:
1621 break;
1622 }
1623 }
1624
1625 void wxDivisionShape::EditEdge(int WXUNUSED(side))
1626 {
1627 wxMessageBox(wxT("EditEdge() not implemented"), wxT("OGL"), wxOK);
1628
1629 #if 0
1630 wxBeginBusyCursor();
1631
1632 wxPen *currentPen = NULL;
1633 char **pColour = NULL;
1634 char **pStyle = NULL;
1635 if (side == DIVISION_SIDE_LEFT)
1636 {
1637 currentPen = m_leftSidePen;
1638 pColour = &m_leftSideColour;
1639 pStyle = &m_leftSideStyle;
1640 }
1641 else
1642 {
1643 currentPen = m_topSidePen;
1644 pColour = &m_topSideColour;
1645 pStyle = &m_topSideStyle;
1646 }
1647
1648 GraphicsForm *form = new GraphicsForm("Containers");
1649 int lineWidth = currentPen->GetWidth();
1650
1651 form->Add(wxMakeFormShort("Width", &lineWidth, wxFORM_DEFAULT, NULL, NULL, wxVERTICAL,
1652 150));
1653 form->Add(wxMakeFormString("Colour", pColour, wxFORM_CHOICE,
1654 new wxList(wxMakeConstraintStrings(
1655 "BLACK" ,
1656 "BLUE" ,
1657 "BROWN" ,
1658 "CORAL" ,
1659 "CYAN" ,
1660 "DARK GREY" ,
1661 "DARK GREEN" ,
1662 "DIM GREY" ,
1663 "GREY" ,
1664 "GREEN" ,
1665 "LIGHT BLUE" ,
1666 "LIGHT GREY" ,
1667 "MAGENTA" ,
1668 "MAROON" ,
1669 "NAVY" ,
1670 "ORANGE" ,
1671 "PURPLE" ,
1672 "RED" ,
1673 "TURQUOISE" ,
1674 "VIOLET" ,
1675 "WHITE" ,
1676 "YELLOW" ,
1677 NULL),
1678 NULL), NULL, wxVERTICAL, 150));
1679 form->Add(wxMakeFormString("Style", pStyle, wxFORM_CHOICE,
1680 new wxList(wxMakeConstraintStrings(
1681 "Solid" ,
1682 "Short Dash" ,
1683 "Long Dash" ,
1684 "Dot" ,
1685 "Dot Dash" ,
1686 NULL),
1687 NULL), NULL, wxVERTICAL, 100));
1688
1689 wxDialogBox *dialog = new wxDialogBox(m_canvas->GetParent(), "Division properties", 10, 10, 500, 500);
1690 if (GraphicsLabelFont)
1691 dialog->SetLabelFont(GraphicsLabelFont);
1692 if (GraphicsButtonFont)
1693 dialog->SetButtonFont(GraphicsButtonFont);
1694
1695 form->AssociatePanel(dialog);
1696 form->dialog = dialog;
1697
1698 dialog->Fit();
1699 dialog->Centre(wxBOTH);
1700
1701 wxEndBusyCursor();
1702 dialog->Show(TRUE);
1703
1704 int lineStyle = wxSOLID;
1705 if (*pStyle)
1706 {
1707 if (strcmp(*pStyle, "Solid") == 0)
1708 lineStyle = wxSOLID;
1709 else if (strcmp(*pStyle, "Dot") == 0)
1710 lineStyle = wxDOT;
1711 else if (strcmp(*pStyle, "Short Dash") == 0)
1712 lineStyle = wxSHORT_DASH;
1713 else if (strcmp(*pStyle, "Long Dash") == 0)
1714 lineStyle = wxLONG_DASH;
1715 else if (strcmp(*pStyle, "Dot Dash") == 0)
1716 lineStyle = wxDOT_DASH;
1717 }
1718
1719 wxPen *newPen = wxThePenList->FindOrCreatePen(*pColour, lineWidth, lineStyle);
1720 if (!pen)
1721 pen = wxBLACK_PEN;
1722 if (side == DIVISION_SIDE_LEFT)
1723 m_leftSidePen = newPen;
1724 else
1725 m_topSidePen = newPen;
1726
1727 // Need to draw whole image again
1728 wxCompositeShape *compositeParent = (wxCompositeShape *)GetParent();
1729 compositeParent->Draw(dc);
1730 #endif
1731 }
1732
1733 // Popup menu
1734 void wxDivisionShape::PopupMenu(double x, double y)
1735 {
1736 wxMenu* oglPopupDivisionMenu = new OGLPopupDivisionMenu;
1737
1738 oglPopupDivisionMenu->SetClientData((void *)this);
1739 if (m_leftSide)
1740 oglPopupDivisionMenu->Enable(DIVISION_MENU_EDIT_LEFT_EDGE, TRUE);
1741 else
1742 oglPopupDivisionMenu->Enable(DIVISION_MENU_EDIT_LEFT_EDGE, FALSE);
1743 if (m_topSide)
1744 oglPopupDivisionMenu->Enable(DIVISION_MENU_EDIT_TOP_EDGE, TRUE);
1745 else
1746 oglPopupDivisionMenu->Enable(DIVISION_MENU_EDIT_TOP_EDGE, FALSE);
1747
1748 int x1, y1;
1749 m_canvas->GetViewStart(&x1, &y1);
1750
1751 int unit_x, unit_y;
1752 m_canvas->GetScrollPixelsPerUnit(&unit_x, &unit_y);
1753
1754 wxClientDC dc(GetCanvas());
1755 GetCanvas()->PrepareDC(dc);
1756
1757 int mouse_x = (int)(dc.LogicalToDeviceX((long)(x - x1*unit_x)));
1758 int mouse_y = (int)(dc.LogicalToDeviceY((long)(y - y1*unit_y)));
1759
1760 m_canvas->PopupMenu(oglPopupDivisionMenu, mouse_x, mouse_y);
1761 delete oglPopupDivisionMenu;
1762 }
1763
1764 void wxDivisionShape::SetLeftSideColour(const wxString& colour)
1765 {
1766 m_leftSideColour = colour;
1767 }
1768
1769 void wxDivisionShape::SetTopSideColour(const wxString& colour)
1770 {
1771 m_topSideColour = colour;
1772 }
1773
1774 void wxDivisionShape::SetLeftSideStyle(const wxString& style)
1775 {
1776 m_leftSideStyle = style;
1777 }
1778
1779 void wxDivisionShape::SetTopSideStyle(const wxString& style)
1780 {
1781 m_topSideStyle = style;
1782 }
1783