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