Various bug fixes to OGL; wxStripExtension prototype added to filefn.h

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@437 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

docs/latex/wx/clasinfo.tex

@@ -10,8 +10,7 @@ No parent class.
 
 \wxheading{See also}
 
-\overview{Overview}{wxclassinfooverview}\\
+\helpref{Overview}{wxclassinfooverview}, \helpref{wxObject}{wxobject}
-\helpref{wxObject}{wxobject}
 
 \latexignore{\rtfignore{\wxheading{Members}}}
 

include/wx/filefn.h

@@ -73,6 +73,7 @@ void WXDLLEXPORT wxUnix2DosFilename(char *s);
 
 // Strip the extension, in situ
 void WXDLLEXPORT wxStripExtension(char *buffer);
+void WXDLLEXPORT wxStripExtension(wxString& buffer);
 
 // Get a temporary filename, opening and closing the file.
 char* WXDLLEXPORT wxGetTempFileName(const wxString& prefix, char *buf = NULL);

src/common/docmdi.cpp

@@ -102,6 +102,7 @@ wxDocMDIChildFrame::wxDocMDIChildFrame(wxDocument *doc, wxView *view, wxMDIParen
 
 wxDocMDIChildFrame::~wxDocMDIChildFrame(void)
 {
+	m_childView = NULL;
 }
 
 // Extend event processing to search the view's event table

src/common/docview.cpp

@@ -196,16 +196,28 @@ bool wxDocument::SaveAs(void)
   
   char *tmp = wxFileSelector("Save as", docTemplate->GetDirectory(), GetFilename(),
     docTemplate->GetDefaultExtension(), docTemplate->GetFileFilter(),
-    0, GetDocumentWindow());
+    wxSAVE|wxOVERWRITE_PROMPT, GetDocumentWindow());
     
   if (!tmp)
     return FALSE;
   else
   {
-    SetFilename(tmp);
+    wxString fileName(tmp);
-    SetTitle(wxFileNameFromPath(tmp));
+    wxString path("");
+    wxString name("");
+    wxString ext("");
+    wxSplitPath(fileName, & path, & name, & ext);
 
-    GetDocumentManager()->AddFileToHistory(tmp);
+    if (ext.IsEmpty() || ext == "")
+    {
+        fileName += ".";
+        fileName += docTemplate->GetDefaultExtension();
+    }
+
+    SetFilename(fileName);
+    SetTitle(wxFileNameFromPath(fileName));
+    
+    GetDocumentManager()->AddFileToHistory(fileName);
 
     // Notify the views that the filename has changed
     wxNode *node = m_documentViews.First();

utils/ogl/src/basic.cpp

@@ -81,6 +81,22 @@ wxShapeEvtHandler::~wxShapeEvtHandler()
 {
 }
 
+// Creates a copy of this event handler.
+wxShapeEvtHandler* wxShapeEvtHandler::CreateNewCopy()
+{
+  wxShapeEvtHandler* newObject = (wxShapeEvtHandler*) GetClassInfo()->CreateObject();
+
+  wxASSERT( (newObject != NULL) );
+  wxASSERT( (newObject->IsKindOf(CLASSINFO(wxShapeEvtHandler))) );
+
+  newObject->m_previousHandler = newObject;
+
+  CopyData(*newObject);
+
+  return newObject;
+}
+
+
 void wxShapeEvtHandler::OnDelete()
 {
   if (this != GetShape())
@@ -197,6 +213,26 @@ void wxShapeEvtHandler::OnEndDragRight(float x, float y, int keys, int attachmen
     m_previousHandler->OnEndDragRight(x, y, keys, attachment);
 }
 
+// Control points ('handles') redirect control to the actual shape, to make it easier
+// to override sizing behaviour.
+void wxShapeEvtHandler::OnSizingDragLeft(wxControlPoint* pt, bool draw, float x, float y, int keys, int attachment)
+{
+  if (m_previousHandler)
+    m_previousHandler->OnSizingDragLeft(pt, draw, x, y, keys, attachment);
+}
+
+void wxShapeEvtHandler::OnSizingBeginDragLeft(wxControlPoint* pt, float x, float y, int keys, int attachment)
+{
+  if (m_previousHandler)
+    m_previousHandler->OnSizingBeginDragLeft(pt, x, y, keys, attachment);
+}
+
+void wxShapeEvtHandler::OnSizingEndDragLeft(wxControlPoint* pt, float x, float y, int keys, int attachment)
+{
+  if (m_previousHandler)
+    m_previousHandler->OnSizingEndDragLeft(pt, x, y, keys, attachment);
+}
+
 void wxShapeEvtHandler::OnDrawOutline(wxDC& dc, float x, float y, float w, float h)
 {
   if (m_previousHandler)
@@ -220,7 +256,7 @@ IMPLEMENT_ABSTRACT_CLASS(wxShape, wxShapeEvtHandler)
 wxShape::wxShape(wxShapeCanvas *can)
 {
   m_eventHandler = this;
-  SetHandlerShape(this);
+  SetShape(this);
   m_id = 0;
   m_formatted = FALSE;
   m_canvas = can;
@@ -1876,7 +1912,7 @@ void wxShape::ReadRegions(wxExpr *clause)
       m_regionProportionX = propXExpr->RealValue();
       m_regionProportionY = propYExpr->RealValue();
 
-      formatMode = (formatExpr->IntegerValue() != 0);
+      formatMode = (int) formatExpr->IntegerValue();
       fontSize = (int)sizeExpr->IntegerValue();
       fontFamily = (int)familyExpr->IntegerValue();
       fontStyle = (int)styleExpr->IntegerValue();
@@ -2056,16 +2092,48 @@ void wxShape::Copy(wxShape& copy)
 }
 
 // Create and return a new, fully copied object.
-wxShape *wxShape::CreateNewCopy(wxShapeCanvas *theCanvas)
+wxShape *wxShape::CreateNewCopy(bool resetMapping, bool recompute)
 {
-  wxObjectCopyMapping.Clear();
+  if (resetMapping)
-  wxShape *newObject = PrivateCopy();
+    wxObjectCopyMapping.Clear();
-  if (theCanvas)
+
-    newObject->AddToCanvas(theCanvas);
+  wxShape* newObject = (wxShape*) GetClassInfo()->CreateObject();
-  newObject->Recompute();
+
+  wxASSERT( (newObject != NULL) );
+  wxASSERT( (newObject->IsKindOf(CLASSINFO(wxShape))) );
+
+  Copy(*newObject);
+
+  if (GetEventHandler() != this)
+  {
+    wxShapeEvtHandler* newHandler = GetEventHandler()->CreateNewCopy();
+    newObject->SetEventHandler(newHandler);
+    newObject->SetPreviousHandler(newObject);
+    newHandler->SetPreviousHandler(newHandler);
+    newHandler->SetShape(newObject);
+  }
+
+  if (recompute)
+    newObject->Recompute();
   return newObject;
 }
 
+// Does the copying for this object, including copying event
+// handler data if any. Calls the virtual Copy function.
+void wxShape::CopyWithHandler(wxShape& copy)
+{
+    Copy(copy);
+
+    if (GetEventHandler() != this)
+    {
+        wxASSERT( copy.GetEventHandler() != NULL );
+        wxASSERT( copy.GetEventHandler() != (&copy) );
+        wxASSERT( GetEventHandler()->GetClassInfo() == copy.GetEventHandler()->GetClassInfo() );
+        GetEventHandler()->CopyData(* (copy.GetEventHandler()));
+    }
+}
+
+
 // Default - make 6 control points
 void wxShape::MakeControlPoints()
 {

utils/ogl/src/basic.h

@@ -114,9 +114,12 @@ class wxShapeEvtHandler: public wxObject
   wxShapeEvtHandler(wxShapeEvtHandler *prev = NULL, wxShape *shape = NULL);
   virtual ~wxShapeEvtHandler();
 
-  inline void SetHandlerShape(wxShape *sh) { m_handlerShape = sh; }
+  inline void SetShape(wxShape *sh) { m_handlerShape = sh; }
   inline wxShape *GetShape() const { return m_handlerShape; }
 
+  inline void SetPreviousHandler(wxShapeEvtHandler* handler) { m_previousHandler = handler; }
+  inline wxShapeEvtHandler* GetPreviousHandler() const { return m_previousHandler; }
+
   // This is called when the _shape_ is deleted.
   virtual void OnDelete();
   virtual void OnDraw(wxDC& dc);
@@ -142,9 +145,22 @@ class wxShapeEvtHandler: public wxObject
   virtual void OnEraseControlPoints(wxDC& dc);
   virtual void OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
 
+  // Control points ('handles') redirect control to the actual shape, to make it easier
+  // to override sizing behaviour.
+  virtual void OnSizingDragLeft(wxControlPoint* pt, bool draw, float x, float y, int keys=0, int attachment = 0); // Erase if draw false
+  virtual void OnSizingBeginDragLeft(wxControlPoint* pt, float x, float y, int keys=0, int attachment = 0);
+  virtual void OnSizingEndDragLeft(wxControlPoint* pt, float x, float y, int keys=0, int attachment = 0);
+
   virtual void OnBeginSize(float WXUNUSED(w), float WXUNUSED(h)) { }
   virtual void OnEndSize(float WXUNUSED(w), float WXUNUSED(h)) { }
 
+  // Creates a copy of this event handler.
+  wxShapeEvtHandler *CreateNewCopy();
+
+  // Does the copy - override for new event handlers which might store
+  // app-specific data.
+  virtual void CopyData(wxShapeEvtHandler& copy) {};
+
  private:
   wxShapeEvtHandler*    m_previousHandler;
   wxShape*              m_handlerShape;
@@ -207,6 +223,12 @@ class wxShape: public wxShapeEvtHandler
   virtual void OnBeginSize(float WXUNUSED(w), float WXUNUSED(h)) { }
   virtual void OnEndSize(float WXUNUSED(w), float WXUNUSED(h)) { }
 
+  // Control points ('handles') redirect control to the actual shape, to make it easier
+  // to override sizing behaviour.
+  virtual void OnSizingDragLeft(wxControlPoint* pt, bool draw, float x, float y, int keys=0, int attachment = 0); // Erase if draw false
+  virtual void OnSizingBeginDragLeft(wxControlPoint* pt, float x, float y, int keys=0, int attachment = 0);
+  virtual void OnSizingEndDragLeft(wxControlPoint* pt, float x, float y, int keys=0, int attachment = 0);
+
   virtual void MakeControlPoints();
   virtual void DeleteControlPoints(wxDC *dc = NULL);
   virtual void ResetControlPoints();
@@ -309,7 +331,7 @@ class wxShape: public wxShapeEvtHandler
   virtual void NameRegions(const wxString& parentName = "");
 
   // Get list of regions
-  inline wxList& GetRegions() { return m_regions; }
+  inline wxList& GetRegions() const { return (wxList&) m_regions; }
 
   virtual void AddRegion(wxShapeRegion *region);
 
@@ -341,10 +363,6 @@ class wxShape: public wxShapeEvtHandler
   virtual void ReadRegions(wxExpr *clause);
 #endif
 
-  // Does the WHOLE copy calling PrivateCopy - don't redefine.
-  // If canvas is non-null, set the canvas too.
-  wxShape *CreateNewCopy(wxShapeCanvas *theCanvas = NULL);
-
   // Attachment code
   virtual bool GetAttachmentPosition(int attachment, float *x, float *y,
                                      int nth = 0, int no_arcs = 1, wxLineShape *line = NULL);
@@ -369,10 +387,15 @@ class wxShape: public wxShapeEvtHandler
   // Returns TRUE if image is a descendant of this image
   bool HasDescendant(wxShape *image);
 
+  // Creates a copy of this shape.
+  wxShape *CreateNewCopy(bool resetMapping = TRUE, bool recompute = TRUE);
+
   // Does the copying for this object
-  void Copy(wxShape& copy);
+  virtual void Copy(wxShape& copy);
-  // Returns a new instance, and does the copy for this class. Define for each class.
+
-  virtual wxShape *PrivateCopy() = 0;
+  // Does the copying for this object, including copying event
+  // handler data if any. Calls the virtual Copy function.
+  void CopyWithHandler(wxShape& copy);
 
   // Rotate about the given axis by the given amount in radians
   // (does nothing for most objects)
@@ -455,6 +478,12 @@ class wxPolygonShape: public wxShape
   void OnDraw(wxDC& dc);
   void OnDrawOutline(wxDC& dc, float x, float y, float w, float h);
 
+  // Control points ('handles') redirect control to the actual shape, to make it easier
+  // to override sizing behaviour.
+  virtual void OnSizingDragLeft(wxControlPoint* pt, bool draw, float x, float y, int keys=0, int attachment = 0);
+  virtual void OnSizingBeginDragLeft(wxControlPoint* pt, float x, float y, int keys=0, int attachment = 0);
+  virtual void OnSizingEndDragLeft(wxControlPoint* pt, float x, float y, int keys=0, int attachment = 0);
+
   // A polygon should have a control point at each vertex,
   // with the option of moving the control points individually
   // to change the shape.
@@ -485,8 +514,7 @@ class wxPolygonShape: public wxShape
                                      int nth = 0, int no_arcs = 1, wxLineShape *line = NULL);
   bool AttachmentIsValid(int attachment);
   // Does the copying for this object
-  void Copy(wxPolygonShape& copy);
+  void Copy(wxShape& copy);
-  wxShape *PrivateCopy();
 
   inline wxList *GetPoints() { return m_points; }
 
@@ -522,8 +550,7 @@ class wxRectangleShape: public wxShape
   bool GetAttachmentPosition(int attachment, float *x, float *y,
                                      int nth = 0, int no_arcs = 1, wxLineShape *line = NULL);
   // Does the copying for this object
-  void Copy(wxRectangleShape& copy);
+  void Copy(wxShape& copy);
-  wxShape *PrivateCopy();
 
   inline float GetWidth() const { return m_width; }
   inline float GetHeight() const { return m_height; }
@@ -547,8 +574,7 @@ class wxTextShape: public wxRectangleShape
 #endif
 
   // Does the copying for this object
-  void Copy(wxTextShape& copy);
+  void Copy(wxShape& copy);
-  wxShape *PrivateCopy();
 };
 
 class wxEllipseShape: public wxShape
@@ -576,8 +602,7 @@ class wxEllipseShape: public wxShape
                                      int nth = 0, int no_arcs = 1, wxLineShape *line = NULL);
 
   // Does the copying for this object
-  void Copy(wxEllipseShape& copy);
+  void Copy(wxShape& copy);
-  wxShape *PrivateCopy();
 
   inline float GetWidth() const { return m_width; }
   inline float GetHeight() const { return m_height; }
@@ -597,8 +622,7 @@ class wxCircleShape: public wxEllipseShape
                                  float x2, float y2,
                                  float *x3, float *y3);
   // Does the copying for this object
-  void Copy(wxCircleShape& copy);
+  void Copy(wxShape& copy);
-  wxShape *PrivateCopy();
 };
 
 #endif

utils/ogl/src/basic2.cpp

@@ -826,26 +826,30 @@ void wxPolygonShape::ReadPrologAttributes(wxExpr *clause)
 }
 #endif
 
-void wxPolygonShape::Copy(wxPolygonShape& copy)
+void wxPolygonShape::Copy(wxShape& copy)
 {
   wxShape::Copy(copy);
 
-  if (copy.m_points)
+  wxASSERT( copy.IsKindOf(CLASSINFO(wxPolygonShape)) );
-    delete copy.m_points;
 
-  copy.m_points = new wxList;
+  wxPolygonShape& polyCopy = (wxPolygonShape&) copy;
 
-  if (copy.m_originalPoints)
+  if (polyCopy.m_points)
-    delete copy.m_originalPoints;
+    delete polyCopy.m_points;
 
-  copy.m_originalPoints = new wxList;
+  polyCopy.m_points = new wxList;
+
+  if (polyCopy.m_originalPoints)
+    delete polyCopy.m_originalPoints;
+
+  polyCopy.m_originalPoints = new wxList;
 
   wxNode *node = m_points->First();
   while (node)
   {
     wxRealPoint *point = (wxRealPoint *)node->Data();
     wxRealPoint *new_point = new wxRealPoint(point->x, point->y);
-    copy.m_points->Append((wxObject*) new_point);
+    polyCopy.m_points->Append((wxObject*) new_point);
     node = node->Next();
   }
   node = m_originalPoints->First();
@@ -853,20 +857,13 @@ void wxPolygonShape::Copy(wxPolygonShape& copy)
   {
     wxRealPoint *point = (wxRealPoint *)node->Data();
     wxRealPoint *new_point = new wxRealPoint(point->x, point->y);
-    copy.m_originalPoints->Append((wxObject*) new_point);
+    polyCopy.m_originalPoints->Append((wxObject*) new_point);
     node = node->Next();
   }
-  copy.m_boundWidth = m_boundWidth;
+  polyCopy.m_boundWidth = m_boundWidth;
-  copy.m_boundHeight = m_boundHeight;
+  polyCopy.m_boundHeight = m_boundHeight;
-  copy.m_originalWidth = m_originalWidth;
+  polyCopy.m_originalWidth = m_originalWidth;
-  copy.m_originalHeight = m_originalHeight;
+  polyCopy.m_originalHeight = m_originalHeight;
-}
-
-wxShape *wxPolygonShape::PrivateCopy()
-{
-  wxPolygonShape *obj = new wxPolygonShape;
-  Copy(*obj);
-  return obj;
 }
 
 int wxPolygonShape::GetNumberOfAttachments()
@@ -1020,21 +1017,17 @@ void wxRectangleShape::ReadPrologAttributes(wxExpr *clause)
 }
 #endif
 
-void wxRectangleShape::Copy(wxRectangleShape& copy)
+void wxRectangleShape::Copy(wxShape& copy)
 {
   wxShape::Copy(copy);
-  copy.m_width = m_width;
-  copy.m_height = m_height;
-  copy.m_cornerRadius = m_cornerRadius;
-}
 
-wxShape *wxRectangleShape::PrivateCopy()
+  wxASSERT( copy.IsKindOf(CLASSINFO(wxRectangleShape)) );
-{
-  wxRectangleShape *obj = new wxRectangleShape(0.0, 0.0);
-  Copy(*obj);
-  return obj;
-}
 
+  wxRectangleShape& rectCopy = (wxRectangleShape&) copy;
+  rectCopy.m_width = m_width;
+  rectCopy.m_height = m_height;
+  rectCopy.m_cornerRadius = m_cornerRadius;
+}
 
 int wxRectangleShape::GetNumberOfAttachments()
 {
@@ -1171,14 +1164,7 @@ void wxTextShape::OnDraw(wxDC& dc)
 {
 }
 
-wxShape *wxTextShape::PrivateCopy()
+void wxTextShape::Copy(wxShape& copy)
-{
-  wxTextShape *obj = new wxTextShape(0.0, 0.0);
-  Copy(*obj);
-  return obj;
-}
-
-void wxTextShape::Copy(wxTextShape& copy)
 {
   wxRectangleShape::Copy(copy);
 }
@@ -1276,19 +1262,16 @@ void wxEllipseShape::ReadPrologAttributes(wxExpr *clause)
 }
 #endif
 
-void wxEllipseShape::Copy(wxEllipseShape& copy)
+void wxEllipseShape::Copy(wxShape& copy)
 {
   wxShape::Copy(copy);
 
-  copy.m_width = m_width;
+  wxASSERT( copy.IsKindOf(CLASSINFO(wxEllipseShape)) );
-  copy.m_height = m_height;
-}
 
-wxShape *wxEllipseShape::PrivateCopy()
+  wxEllipseShape& ellipseCopy = (wxEllipseShape&) copy;
-{
+
-  wxEllipseShape *obj = new wxEllipseShape(0.0, 0.0);
+  ellipseCopy.m_width = m_width;
-  Copy(*obj);
+  ellipseCopy.m_height = m_height;
-  return obj;
 }
 
 int wxEllipseShape::GetNumberOfAttachments()
@@ -1368,14 +1351,7 @@ wxCircleShape::wxCircleShape(float diameter):wxEllipseShape(diameter, diameter)
 {
 }
 
-wxShape *wxCircleShape::PrivateCopy()
+void wxCircleShape::Copy(wxShape& copy)
-{
-  wxCircleShape *obj = new wxCircleShape(0.0);
-  Copy(*obj);
-  return obj;
-}
-
-void wxCircleShape::Copy(wxCircleShape& copy)
 {
   wxEllipseShape::Copy(copy);
 }
@@ -1394,6 +1370,15 @@ bool wxCircleShape::GetPerimeterPoint(float x1, float y1,
 
 // Control points
 
+float wxControlPoint::controlPointDragStartX = 0.0;
+float wxControlPoint::controlPointDragStartY = 0.0;
+float wxControlPoint::controlPointDragStartWidth = 0.0;
+float wxControlPoint::controlPointDragStartHeight = 0.0;
+float wxControlPoint::controlPointDragEndWidth = 0.0;
+float wxControlPoint::controlPointDragEndHeight = 0.0;
+float wxControlPoint::controlPointDragPosX = 0.0;
+float wxControlPoint::controlPointDragPosY = 0.0;
+
 IMPLEMENT_DYNAMIC_CLASS(wxControlPoint, wxRectangleShape)
 
 wxControlPoint::wxControlPoint(wxShapeCanvas *theCanvas, wxShape *object, float size, float the_xoffset, float the_yoffset, int the_type):wxRectangleShape(size, size)
@@ -1431,25 +1416,41 @@ void wxControlPoint::OnErase(wxDC& dc)
   wxRectangleShape::OnErase(dc);
 }
 
-/*
- * Store original top-left, bottom-right coordinates
- * in case we're doing non-vertical resizing.
- */
-static float controlPointDragStartX = 0.0;
-static float controlPointDragStartY = 0.0;
-static float controlPointDragStartWidth = 0.0;
-static float controlPointDragStartHeight = 0.0;
-static float controlPointDragEndWidth = 0.0;
-static float controlPointDragEndHeight = 0.0;
-static float controlPointDragPosX = 0.0;
-static float controlPointDragPosY = 0.0;
-
 // Implement resizing of canvas object
 void wxControlPoint::OnDragLeft(bool draw, float x, float y, int keys, int attachment)
+{
+    m_shape->GetEventHandler()->OnSizingDragLeft(this, draw, x, y, keys, attachment);
+}
+
+void wxControlPoint::OnBeginDragLeft(float x, float y, int keys, int attachment)
+{
+    m_shape->GetEventHandler()->OnSizingBeginDragLeft(this, x, y, keys, attachment);
+}
+
+void wxControlPoint::OnEndDragLeft(float x, float y, int keys, int attachment)
+{
+    m_shape->GetEventHandler()->OnSizingEndDragLeft(this, x, y, keys, attachment);
+}
+
+int wxControlPoint::GetNumberOfAttachments()
+{
+  return 1;
+}
+
+bool wxControlPoint::GetAttachmentPosition(int attachment, float *x, float *y,
+                                         int nth, int no_arcs, wxLineShape *line)
+{
+  *x = m_xpos; *y = m_ypos;
+  return TRUE;
+}
+
+// Control points ('handles') redirect control to the actual shape, to make it easier
+// to override sizing behaviour.
+void wxShape::OnSizingDragLeft(wxControlPoint* pt, bool draw, float x, float y, int keys, int attachment)
 {
   float bound_x;
   float bound_y;
-  m_shape->GetBoundingBoxMin(&bound_x, &bound_y);
+  this->GetBoundingBoxMin(&bound_x, &bound_y);
 
   wxClientDC dc(GetCanvas());
   GetCanvas()->PrepareDC(dc);
@@ -1460,58 +1461,53 @@ void wxControlPoint::OnDragLeft(bool draw, float x, float y, int keys, int attac
   dc.SetPen(dottedPen);
   dc.SetBrush((* wxTRANSPARENT_BRUSH));
 
-  if (m_shape->GetCentreResize())
+  if (this->GetCentreResize())
   {
     // Maintain the same centre point.
-    float new_width = (float)(2.0*fabs(x - m_shape->GetX()));
+    float new_width = (float)(2.0*fabs(x - this->GetX()));
-    float new_height = (float)(2.0*fabs(y - m_shape->GetY()));
+    float new_height = (float)(2.0*fabs(y - this->GetY()));
 
     // Constrain sizing according to what control point you're dragging
-    if (m_type == CONTROL_POINT_HORIZONTAL)
+    if (pt->m_type == CONTROL_POINT_HORIZONTAL)
       new_height = bound_y;
-    else if (m_type == CONTROL_POINT_VERTICAL)
+    else if (pt->m_type == CONTROL_POINT_VERTICAL)
       new_width = bound_x;
-    else if (m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
+    else if (pt->m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
       new_height = bound_y*(new_width/bound_x);
 
-//    m_shape->OnBeginSize(m_shape->m_fixedWidth ? bound_x : new_width,
+    if (this->GetFixedWidth())
-//                               m_shape->m_fixedHeight ? bound_y : new_height);
-
-//    m_shape->SetSize(m_shape->m_fixedWidth ? bound_x : new_width,
-//                           m_shape->m_fixedHeight ? bound_y : new_height);
-    if (m_shape->GetFixedWidth())
       new_width = bound_x;
       
-    if (m_shape->GetFixedHeight())
+    if (this->GetFixedHeight())
       new_height = bound_y;
 
-    controlPointDragEndWidth = new_width;
+    pt->controlPointDragEndWidth = new_width;
-    controlPointDragEndHeight = new_height;
+    pt->controlPointDragEndHeight = new_height;
 
-    m_shape->GetEventHandler()->OnDrawOutline(dc, m_shape->GetX(), m_shape->GetY(),
+    this->GetEventHandler()->OnDrawOutline(dc, this->GetX(), this->GetY(),
                                 new_width, new_height);
   }
   else
   {
     // Don't maintain the same centre point!
-    float newX1 = wxMin(controlPointDragStartX, x);
+    float newX1 = wxMin(pt->controlPointDragStartX, x);
-    float newY1 = wxMin(controlPointDragStartY, y);
+    float newY1 = wxMin(pt->controlPointDragStartY, y);
-    float newX2 = wxMax(controlPointDragStartX, x);
+    float newX2 = wxMax(pt->controlPointDragStartX, x);
-    float newY2 = wxMax(controlPointDragStartY, y);
+    float newY2 = wxMax(pt->controlPointDragStartY, y);
-    if (m_type == CONTROL_POINT_HORIZONTAL)
+    if (pt->m_type == CONTROL_POINT_HORIZONTAL)
     {
-      newY1 = controlPointDragStartY;
+      newY1 = pt->controlPointDragStartY;
-      newY2 = newY1 + controlPointDragStartHeight;
+      newY2 = newY1 + pt->controlPointDragStartHeight;
     }
-    else if (m_type == CONTROL_POINT_VERTICAL)
+    else if (pt->m_type == CONTROL_POINT_VERTICAL)
     {
-      newX1 = controlPointDragStartX;
+      newX1 = pt->controlPointDragStartX;
-      newX2 = newX1 + controlPointDragStartWidth;
+      newX2 = newX1 + pt->controlPointDragStartWidth;
     }
-    else if (m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
+    else if (pt->m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
     {
-      float newH = (float)((newX2 - newX1)*(controlPointDragStartHeight/controlPointDragStartWidth));
+      float newH = (float)((newX2 - newX1)*(pt->controlPointDragStartHeight/pt->controlPointDragStartWidth));
-      if (GetY() > controlPointDragStartY)
+      if (GetY() > pt->controlPointDragStartY)
         newY2 = (float)(newY1 + newH);
       else
         newY1 = (float)(newY2 - newH);
@@ -1519,114 +1515,106 @@ void wxControlPoint::OnDragLeft(bool draw, float x, float y, int keys, int attac
     float newWidth = (float)(newX2 - newX1);
     float newHeight = (float)(newY2 - newY1);
 
-//    m_shape->OnBeginSize(newWidth,
+    pt->controlPointDragPosX = (float)(newX1 + (newWidth/2.0));
-//                               newHeight);
+    pt->controlPointDragPosY = (float)(newY1 + (newHeight/2.0));
-    
+    if (this->GetFixedWidth())
-//    m_shape->SetSize(newWidth,
-//                           newHeight);
-    controlPointDragPosX = (float)(newX1 + (newWidth/2.0));
-    controlPointDragPosY = (float)(newY1 + (newHeight/2.0));
-    if (m_shape->GetFixedWidth())
       newWidth = bound_x;
      
-    if (m_shape->GetFixedHeight())
+    if (this->GetFixedHeight())
       newHeight = bound_y;
 
-    controlPointDragEndWidth = newWidth;
+    pt->controlPointDragEndWidth = newWidth;
-    controlPointDragEndHeight = newHeight;
+    pt->controlPointDragEndHeight = newHeight;
-    m_shape->GetEventHandler()->OnDrawOutline(dc, controlPointDragPosX, controlPointDragPosY, newWidth, newHeight);
+    this->GetEventHandler()->OnDrawOutline(dc, pt->controlPointDragPosX, pt->controlPointDragPosY, newWidth, newHeight);
   }
 }
 
-void wxControlPoint::OnBeginDragLeft(float x, float y, int keys, int attachment)
+void wxShape::OnSizingBeginDragLeft(wxControlPoint* pt, float x, float y, int keys, int attachment)
 {
   m_canvas->CaptureMouse();
 
   wxClientDC dc(GetCanvas());
   GetCanvas()->PrepareDC(dc);
 
-  if (m_eraseObject)
+  if (pt->m_eraseObject)
-    m_shape->Erase(dc);
+    this->Erase(dc);
 
   dc.SetLogicalFunction(wxXOR);
 
   float bound_x;
   float bound_y;
-  m_shape->GetBoundingBoxMin(&bound_x, &bound_y);
+  this->GetBoundingBoxMin(&bound_x, &bound_y);
 
   // Choose the 'opposite corner' of the object as the stationary
   // point in case this is non-centring resizing.
-  if (GetX() < m_shape->GetX())
+  if (pt->GetX() < this->GetX())
-    controlPointDragStartX = (float)(m_shape->GetX() + (bound_x/2.0));
+    pt->controlPointDragStartX = (float)(this->GetX() + (bound_x/2.0));
   else
-    controlPointDragStartX = (float)(m_shape->GetX() - (bound_x/2.0));
+    pt->controlPointDragStartX = (float)(this->GetX() - (bound_x/2.0));
 
-  if (GetY() < m_shape->GetY())
+  if (pt->GetY() < this->GetY())
-    controlPointDragStartY = (float)(m_shape->GetY() + (bound_y/2.0));
+    pt->controlPointDragStartY = (float)(this->GetY() + (bound_y/2.0));
   else
-    controlPointDragStartY = (float)(m_shape->GetY() - (bound_y/2.0));
+    pt->controlPointDragStartY = (float)(this->GetY() - (bound_y/2.0));
 
-  if (m_type == CONTROL_POINT_HORIZONTAL)
+  if (pt->m_type == CONTROL_POINT_HORIZONTAL)
-    controlPointDragStartY = (float)(m_shape->GetY() - (bound_y/2.0));
+    pt->controlPointDragStartY = (float)(this->GetY() - (bound_y/2.0));
-  else if (m_type == CONTROL_POINT_VERTICAL)
+  else if (pt->m_type == CONTROL_POINT_VERTICAL)
-    controlPointDragStartX = (float)(m_shape->GetX() - (bound_x/2.0));
+    pt->controlPointDragStartX = (float)(this->GetX() - (bound_x/2.0));
 
   // We may require the old width and height.
-  controlPointDragStartWidth = bound_x;
+  pt->controlPointDragStartWidth = bound_x;
-  controlPointDragStartHeight = bound_y;
+  pt->controlPointDragStartHeight = bound_y;
 
   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
   dc.SetPen(dottedPen);
   dc.SetBrush((* wxTRANSPARENT_BRUSH));
 
-  if (m_shape->GetCentreResize())
+  if (this->GetCentreResize())
   {
-    float new_width = (float)(2.0*fabs(x - m_shape->GetX()));
+    float new_width = (float)(2.0*fabs(x - this->GetX()));
-    float new_height = (float)(2.0*fabs(y - m_shape->GetY()));
+    float new_height = (float)(2.0*fabs(y - this->GetY()));
 
     // Constrain sizing according to what control point you're dragging
-    if (m_type == CONTROL_POINT_HORIZONTAL)
+    if (pt->m_type == CONTROL_POINT_HORIZONTAL)
       new_height = bound_y;
-    else if (m_type == CONTROL_POINT_VERTICAL)
+    else if (pt->m_type == CONTROL_POINT_VERTICAL)
       new_width = bound_x;
-    else if (m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
+    else if (pt->m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
       new_height = bound_y*(new_width/bound_x);
 
-    // Non-recursive SetSize for speed
+    if (this->GetFixedWidth())
-//    m_shape->SetSize(new_width, new_height, FALSE);
-
-    if (m_shape->GetFixedWidth())
       new_width = bound_x;
       
-    if (m_shape->GetFixedHeight())
+    if (this->GetFixedHeight())
       new_height = bound_y;
 
-    controlPointDragEndWidth = new_width;
+    pt->controlPointDragEndWidth = new_width;
-    controlPointDragEndHeight = new_height;
+    pt->controlPointDragEndHeight = new_height;
-    m_shape->GetEventHandler()->OnDrawOutline(dc, m_shape->GetX(), m_shape->GetY(),
+    this->GetEventHandler()->OnDrawOutline(dc, this->GetX(), this->GetY(),
                                 new_width, new_height);
   }
   else
   {
     // Don't maintain the same centre point!
-    float newX1 = wxMin(controlPointDragStartX, x);
+    float newX1 = wxMin(pt->controlPointDragStartX, x);
-    float newY1 = wxMin(controlPointDragStartY, y);
+    float newY1 = wxMin(pt->controlPointDragStartY, y);
-    float newX2 = wxMax(controlPointDragStartX, x);
+    float newX2 = wxMax(pt->controlPointDragStartX, x);
-    float newY2 = wxMax(controlPointDragStartY, y);
+    float newY2 = wxMax(pt->controlPointDragStartY, y);
-    if (m_type == CONTROL_POINT_HORIZONTAL)
+    if (pt->m_type == CONTROL_POINT_HORIZONTAL)
     {
-      newY1 = controlPointDragStartY;
+      newY1 = pt->controlPointDragStartY;
-      newY2 = newY1 + controlPointDragStartHeight;
+      newY2 = newY1 + pt->controlPointDragStartHeight;
     }
-    else if (m_type == CONTROL_POINT_VERTICAL)
+    else if (pt->m_type == CONTROL_POINT_VERTICAL)
     {
-      newX1 = controlPointDragStartX;
+      newX1 = pt->controlPointDragStartX;
-      newX2 = newX1 + controlPointDragStartWidth;
+      newX2 = newX1 + pt->controlPointDragStartWidth;
     }
-    else if (m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
+    else if (pt->m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
     {
-      float newH = (float)((newX2 - newX1)*(controlPointDragStartHeight/controlPointDragStartWidth));
+      float newH = (float)((newX2 - newX1)*(pt->controlPointDragStartHeight/pt->controlPointDragStartWidth));
-      if (GetY() > controlPointDragStartY)
+      if (pt->GetY() > pt->controlPointDragStartY)
         newY2 = (float)(newY1 + newH);
       else
         newY1 = (float)(newY2 - newH);
@@ -1634,51 +1622,46 @@ void wxControlPoint::OnBeginDragLeft(float x, float y, int keys, int attachment)
     float newWidth = (float)(newX2 - newX1);
     float newHeight = (float)(newY2 - newY1);
 
-//    m_shape->OnBeginSize(newWidth,
+    pt->controlPointDragPosX = (float)(newX1 + (newWidth/2.0));
-//                               newHeight);
+    pt->controlPointDragPosY = (float)(newY1 + (newHeight/2.0));
-    
+    if (this->GetFixedWidth())
-//    m_shape->SetSize(newWidth,
-//                           newHeight);
-    controlPointDragPosX = (float)(newX1 + (newWidth/2.0));
-    controlPointDragPosY = (float)(newY1 + (newHeight/2.0));
-    if (m_shape->GetFixedWidth())
       newWidth = bound_x;
 
-    if (m_shape->GetFixedHeight())
+    if (this->GetFixedHeight())
       newHeight = bound_y;
 
-    controlPointDragEndWidth = newWidth;
+    pt->controlPointDragEndWidth = newWidth;
-    controlPointDragEndHeight = newHeight;
+    pt->controlPointDragEndHeight = newHeight;
-    m_shape->GetEventHandler()->OnDrawOutline(dc, controlPointDragPosX, controlPointDragPosY, newWidth, newHeight);
+    this->GetEventHandler()->OnDrawOutline(dc, pt->controlPointDragPosX, pt->controlPointDragPosY, newWidth, newHeight);
   }
 }
 
-void wxControlPoint::OnEndDragLeft(float x, float y, int keys, int attachment)
+void wxShape::OnSizingEndDragLeft(wxControlPoint* pt, float x, float y, int keys, int attachment)
 {
   wxClientDC dc(GetCanvas());
   GetCanvas()->PrepareDC(dc);
 
   m_canvas->ReleaseMouse();
   dc.SetLogicalFunction(wxCOPY);
-  m_shape->Recompute();
+  this->Recompute();
-  m_shape->ResetControlPoints();
+  this->ResetControlPoints();
 
-  if (!m_eraseObject)
+  if (!pt->m_eraseObject)
-    m_shape->Show(FALSE);
+    this->Show(FALSE);
 
-  m_shape->SetSize(controlPointDragEndWidth, controlPointDragEndHeight);
+  this->SetSize(pt->controlPointDragEndWidth, pt->controlPointDragEndHeight);
 
   // The next operation could destroy this control point (it does for label objects,
   // via formatting the text), so save all values we're going to use, or
   // we'll be accessing garbage.
-  wxShape *theObject = m_shape;
+  wxShape *theObject = this;
   wxShapeCanvas *theCanvas = m_canvas;
-  bool eraseIt = m_eraseObject;
+  bool eraseIt = pt->m_eraseObject;
 
   if (theObject->GetCentreResize())
     theObject->Move(dc, theObject->GetX(), theObject->GetY());
   else
-    theObject->Move(dc, controlPointDragPosX, controlPointDragPosY);
+    theObject->Move(dc, pt->controlPointDragPosX, pt->controlPointDragPosY);
 
   if (!eraseIt)
     theObject->Show(TRUE);
@@ -1694,17 +1677,6 @@ void wxControlPoint::OnEndDragLeft(float x, float y, int keys, int attachment)
   if (!theCanvas->GetQuickEditMode() && eraseIt) theCanvas->Redraw(dc);
 }
 
-int wxControlPoint::GetNumberOfAttachments()
-{
-  return 1;
-}
-
-bool wxControlPoint::GetAttachmentPosition(int attachment, float *x, float *y,
-                                         int nth, int no_arcs, wxLineShape *line)
-{
-  *x = m_xpos; *y = m_ypos;
-  return TRUE;
-}
 
 
 // Polygon control points
@@ -1716,6 +1688,7 @@ wxPolygonControlPoint::wxPolygonControlPoint(wxShapeCanvas *theCanvas, wxShape *
   wxControlPoint(theCanvas, object, size, the_xoffset, the_yoffset, 0)
 {
   m_polygonVertex = vertex;
+  m_originalDistance = 0.0;
 }
 
 wxPolygonControlPoint::~wxPolygonControlPoint()
@@ -1725,71 +1698,92 @@ wxPolygonControlPoint::~wxPolygonControlPoint()
 // Implement resizing polygon or moving the vertex.
 void wxPolygonControlPoint::OnDragLeft(bool draw, float x, float y, int keys, int attachment)
 {
-  wxClientDC dc(GetCanvas());
+    m_shape->GetEventHandler()->OnSizingDragLeft(this, draw, x, y, keys, attachment);
-  GetCanvas()->PrepareDC(dc);
-
-  dc.SetLogicalFunction(wxXOR);
-
-  wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
-  dc.SetPen(dottedPen);
-  dc.SetBrush((* wxTRANSPARENT_BRUSH));
-
-  float bound_x;
-  float bound_y;
-  m_shape->GetBoundingBoxMin(&bound_x, &bound_y);
-/*
-  float new_width = (float)(2.0*fabs(x - m_shape->GetX()));
-  float new_height = (float)(2.0*fabs(y - m_shape->GetY()));
-*/
-  float dist = (float)sqrt((x - m_shape->GetX())*(x - m_shape->GetX()) +
-                    (y - m_shape->GetY())*(y - m_shape->GetY()));
-
-  if (keys & KEY_CTRL)
-  {
-    m_canvas->Snap(&x, &y);
-
-    // Move point
-    m_polygonVertex->x = x - m_shape->GetX();
-    m_polygonVertex->y = y - m_shape->GetY();
-    m_xpos = x;
-    m_xpos = y;
-    ((wxPolygonShape *)m_shape)->CalculateBoundingBox();
-    ((wxPolygonShape *)m_shape)->CalculatePolygonCentre();
-  }
-  else
-  {
-    float new_width = (float)(dist/m_originalDistance)*m_originalSize.x;
-    float new_height = (float)(dist/m_originalDistance)*m_originalSize.y;
-
-    // Non-recursive SetSize for speed
-    m_shape->SetSize(new_width, new_height, FALSE);
-  }
-  float w, h;
-  m_shape->GetBoundingBoxMax(&w, &h);
-  m_shape->GetEventHandler()->OnDrawOutline(dc, m_shape->GetX(), m_shape->GetY(), w, h);
 }
 
 void wxPolygonControlPoint::OnBeginDragLeft(float x, float y, int keys, int attachment)
 {
+    m_shape->GetEventHandler()->OnSizingBeginDragLeft(this, x, y, keys, attachment);
+}
+
+void wxPolygonControlPoint::OnEndDragLeft(float x, float y, int keys, int attachment)
+{
+    m_shape->GetEventHandler()->OnSizingEndDragLeft(this, x, y, keys, attachment);
+}
+
+// Control points ('handles') redirect control to the actual shape, to make it easier
+// to override sizing behaviour.
+void wxPolygonShape::OnSizingDragLeft(wxControlPoint* pt, bool draw, float x, float y, int keys, int attachment)
+{
+  wxPolygonControlPoint* ppt = (wxPolygonControlPoint*) pt;
+
   wxClientDC dc(GetCanvas());
   GetCanvas()->PrepareDC(dc);
 
-  m_shape->Erase(dc);
+  dc.SetLogicalFunction(wxXOR);
+
+  wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
+  dc.SetPen(dottedPen);
+  dc.SetBrush((* wxTRANSPARENT_BRUSH));
+
+  float bound_x;
+  float bound_y;
+  this->GetBoundingBoxMin(&bound_x, &bound_y);
+/*
+  float new_width = (float)(2.0*fabs(x - this->GetX()));
+  float new_height = (float)(2.0*fabs(y - this->GetY()));
+*/
+  float dist = (float)sqrt((x - this->GetX())*(x - this->GetX()) +
+                    (y - this->GetY())*(y - this->GetY()));
+
+  if (keys & KEY_CTRL)
+  {
+    m_canvas->Snap(&x, &y);
+
+    // Move point
+    ppt->m_polygonVertex->x = x - this->GetX();
+    ppt->m_polygonVertex->y = y - this->GetY();
+    ppt->SetX(x);
+    ppt->SetY(y);
+    ((wxPolygonShape *)this)->CalculateBoundingBox();
+    ((wxPolygonShape *)this)->CalculatePolygonCentre();
+  }
+  else
+  {
+    float new_width = (float)(dist/ppt->m_originalDistance)*ppt->m_originalSize.x;
+    float new_height = (float)(dist/ppt->m_originalDistance)*ppt->m_originalSize.y;
+
+    // Non-recursive SetSize for speed
+    this->SetSize(new_width, new_height, FALSE);
+  }
+  float w, h;
+  this->GetBoundingBoxMax(&w, &h);
+  this->GetEventHandler()->OnDrawOutline(dc, this->GetX(), this->GetY(), w, h);
+}
+
+void wxPolygonShape::OnSizingBeginDragLeft(wxControlPoint* pt, float x, float y, int keys, int attachment)
+{
+  wxPolygonControlPoint* ppt = (wxPolygonControlPoint*) pt;
+
+  wxClientDC dc(GetCanvas());
+  GetCanvas()->PrepareDC(dc);
+
+  this->Erase(dc);
 
   dc.SetLogicalFunction(wxXOR);
 
   float bound_x;
   float bound_y;
-  m_shape->GetBoundingBoxMin(&bound_x, &bound_y);
+  this->GetBoundingBoxMin(&bound_x, &bound_y);
 
-  float dist = (float)sqrt((x - m_shape->GetX())*(x - m_shape->GetX()) +
+  float dist = (float)sqrt((x - this->GetX())*(x - this->GetX()) +
-                    (y - m_shape->GetY())*(y - m_shape->GetY()));
+                    (y - this->GetY())*(y - this->GetY()));
 
-  m_originalDistance = dist;
+  ppt->m_originalDistance = dist;
-  m_originalSize.x = bound_x;
+  ppt->m_originalSize.x = bound_x;
-  m_originalSize.y = bound_y;
+  ppt->m_originalSize.y = bound_y;
 
-  if (m_originalDistance == 0.0) m_originalDistance = (float) 0.0001;
+  if (ppt->m_originalDistance == 0.0) ppt->m_originalDistance = (float) 0.0001;
 
   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
   dc.SetPen(dottedPen);
@@ -1800,30 +1794,30 @@ void wxPolygonControlPoint::OnBeginDragLeft(float x, float y, int keys, int atta
     m_canvas->Snap(&x, &y);
 
     // Move point
-    m_polygonVertex->x = x - m_shape->GetX();
+    ppt->m_polygonVertex->x = x - this->GetX();
-    m_polygonVertex->y = y - m_shape->GetY();
+    ppt->m_polygonVertex->y = y - this->GetY();
-    m_xpos = x;
+    ppt->SetX(x);
-    m_xpos = y;
+    ppt->SetY(y);
-    ((wxPolygonShape *)m_shape)->CalculateBoundingBox();
+    ((wxPolygonShape *)this)->CalculateBoundingBox();
-    ((wxPolygonShape *)m_shape)->CalculatePolygonCentre();
+    ((wxPolygonShape *)this)->CalculatePolygonCentre();
   }
   else
   {
-    float new_width = (float)(dist/m_originalDistance)*m_originalSize.x;
+    float new_width = (float)(dist/ppt->m_originalDistance)*ppt->m_originalSize.x;
-    float new_height = (float)(dist/m_originalDistance)*m_originalSize.y;
+    float new_height = (float)(dist/ppt->m_originalDistance)*ppt->m_originalSize.y;
 
     // Non-recursive SetSize for speed
-    m_shape->SetSize(new_width, new_height, FALSE);
+    this->SetSize(new_width, new_height, FALSE);
   }
 
   float w, h;
-  m_shape->GetBoundingBoxMax(&w, &h);
+  this->GetBoundingBoxMax(&w, &h);
-  m_shape->GetEventHandler()->OnDrawOutline(dc, m_shape->GetX(), m_shape->GetY(), w, h);
+  this->GetEventHandler()->OnDrawOutline(dc, this->GetX(), this->GetY(), w, h);
 
   m_canvas->CaptureMouse();
 }
 
-void wxPolygonControlPoint::OnEndDragLeft(float x, float y, int keys, int attachment)
+void wxPolygonShape::OnSizingEndDragLeft(wxControlPoint* pt, float x, float y, int keys, int attachment)
 {
   wxClientDC dc(GetCanvas());
   GetCanvas()->PrepareDC(dc);
@@ -1834,20 +1828,19 @@ void wxPolygonControlPoint::OnEndDragLeft(float x, float y, int keys, int attach
   // If we're changing shape, must reset the original points
   if (keys & KEY_CTRL)
   {
-    ((wxPolygonShape *)m_shape)->CalculateBoundingBox();
+    ((wxPolygonShape *)this)->CalculateBoundingBox();
-    ((wxPolygonShape *)m_shape)->UpdateOriginalPoints();
+    ((wxPolygonShape *)this)->UpdateOriginalPoints();
   }
 
-  ((wxPolygonShape *)m_shape)->CalculateBoundingBox();
+  ((wxPolygonShape *)this)->CalculateBoundingBox();
-  ((wxPolygonShape *)m_shape)->CalculatePolygonCentre();
+  ((wxPolygonShape *)this)->CalculatePolygonCentre();
 
-  m_shape->Recompute();
+  this->Recompute();
-  m_shape->ResetControlPoints();
+  this->ResetControlPoints();
-  m_shape->Move(dc, m_shape->GetX(), m_shape->GetY());
+  this->Move(dc, this->GetX(), this->GetY());
   if (!m_canvas->GetQuickEditMode()) m_canvas->Redraw(dc);
 }
 
-
 /*
  * Object region
  *

utils/ogl/src/basicp.h

@@ -40,10 +40,14 @@ protected:
    float        m_y;
 };
 
+class wxShape;
 class wxControlPoint: public wxRectangleShape
 {
  DECLARE_DYNAMIC_CLASS(wxControlPoint)
 
+ friend class wxShapeEvtHandler;
+ friend class wxShape;
+
  public:
   wxControlPoint(wxShapeCanvas *the_canvas = NULL, wxShape *object = NULL, float size = 0.0, float the_xoffset = 0.0,
     float the_yoffset = 0.0, int the_type = 0);
@@ -70,12 +74,25 @@ public:
   wxCursor*     m_oldCursor;
   bool          m_eraseObject; // If TRUE, erases object before dragging handle.
 
+/*
+ * Store original top-left, bottom-right coordinates
+ * in case we're doing non-vertical resizing.
+ */
+  static float controlPointDragStartX;
+  static float controlPointDragStartY;
+  static float controlPointDragStartWidth;
+  static float controlPointDragStartHeight;
+  static float controlPointDragEndWidth;
+  static float controlPointDragEndHeight;
+  static float controlPointDragPosX;
+  static float controlPointDragPosY;
 };
 
+class wxPolygonShape;
 class wxPolygonControlPoint: public wxControlPoint
 {
  DECLARE_DYNAMIC_CLASS(wxPolygonControlPoint)
-
+  friend class wxPolygonShape;
  public:
   wxPolygonControlPoint(wxShapeCanvas *the_canvas = NULL, wxShape *object = NULL, float size = 0.0, wxRealPoint *vertex = NULL,
     float the_xoffset = 0.0, float the_yoffset = 0.0);

utils/ogl/src/bitmap.cpp

@@ -101,19 +101,16 @@ void wxBitmapShape::ReadPrologAttributes(wxExpr *clause)
 #endif
 
 // Does the copying for this object
-void wxBitmapShape::Copy(wxBitmapShape& copy)
+void wxBitmapShape::Copy(wxShape& copy)
 {
   wxRectangleShape::Copy(copy);
-  copy.m_bitmap = m_bitmap;
-  copy.SetFilename(m_filename);
-}
 
-// Returns a new instance, and does the copy for this class. Define for each class.
+  wxASSERT( copy.IsKindOf(CLASSINFO(wxBitmapShape)) ) ;
-wxShape *wxBitmapShape::PrivateCopy()
+
-{
+  wxBitmapShape& bitmapCopy = (wxBitmapShape&) copy;
-  wxBitmapShape *obj = new wxBitmapShape;
+
-  Copy(*obj);
+  bitmapCopy.m_bitmap = m_bitmap;
-  return obj;
+  bitmapCopy.SetFilename(m_filename);
 }
 
 void wxBitmapShape::SetBitmap(const wxBitmap& bm)

utils/ogl/src/bitmap.h

@@ -35,10 +35,7 @@ class wxBitmapShape: public wxRectangleShape
 #endif
 
   // Does the copying for this object
-  void Copy(wxBitmapShape& copy);
+  void Copy(wxShape& copy);
-
-  // Returns a new instance, and does the copy for this class. Define for each class.
-  wxShape *PrivateCopy();
 
   void SetSize(float w, float h, bool recursive = TRUE);
   inline wxBitmap& GetBitmap() const { return (wxBitmap&) m_bitmap; }

utils/ogl/src/composit.cpp

@@ -360,28 +360,32 @@ void wxCompositeShape::RemoveChildFromConstraints(wxShape *child)
   }
 }
 
-void wxCompositeShape::Copy(wxCompositeShape& copy)
+void wxCompositeShape::Copy(wxShape& copy)
 {
   wxRectangleShape::Copy(copy);
 
-  // Associate old and new copies for copying constraints and division geometry
+  wxASSERT( copy.IsKindOf(CLASSINFO(wxCompositeShape)) ) ;
-  wxObjectCopyMapping.Append((long)this, &copy);
+
+  wxCompositeShape& compositeCopy = (wxCompositeShape&) copy;
+
+  // Associate old and new copies for compositeCopying constraints and division geometry
+  wxObjectCopyMapping.Append((long)this, &compositeCopy);
 
   // Copy the children
   wxNode *node = m_children.First();
   while (node)
   {
     wxShape *object = (wxShape *)node->Data();
-    wxShape *newObject = object->PrivateCopy();
+    wxShape *newObject = object->CreateNewCopy(FALSE, FALSE);
     if (newObject->GetId() == 0)
       newObject->SetId(NewId());
       
-    newObject->SetParent(&copy);
+    newObject->SetParent(&compositeCopy);
-    copy.m_children.Append(newObject);
+    compositeCopy.m_children.Append(newObject);
 
     // Some m_children may be divisions
     if (m_divisions.Member(object))
-      copy.m_divisions.Append(newObject);
+      compositeCopy.m_divisions.Append(newObject);
 
     wxObjectCopyMapping.Append((long)object, newObject);
 
@@ -414,12 +418,12 @@ void wxCompositeShape::Copy(wxCompositeShape& copy)
       newConstraint->m_constraintName = constraint->m_constraintName;
     }
     newConstraint->SetSpacing(constraint->m_xSpacing, constraint->m_ySpacing);
-    copy.m_constraints.Append(newConstraint);
+    compositeCopy.m_constraints.Append(newConstraint);
 
     node = node->Next();
   }
 
-  // Now copy the division geometry
+  // Now compositeCopy the division geometry
   node = m_divisions.First();
   while (node)
   {
@@ -453,13 +457,6 @@ void wxCompositeShape::Copy(wxCompositeShape& copy)
   }
 }
 
-wxShape *wxCompositeShape::PrivateCopy()
-{
-  wxCompositeShape *obj = new wxCompositeShape;
-  Copy(*obj);
-  return obj;
-}
-
 OGLConstraint *wxCompositeShape::AddConstraint(OGLConstraint *constraint)
 {
   m_constraints.Append(constraint);
@@ -971,29 +968,26 @@ void wxDivisionShape::CalculateSize()
 {
 }
 
-void wxDivisionShape::Copy(wxDivisionShape& copy)
+void wxDivisionShape::Copy(wxShape& copy)
 {
   wxCompositeShape::Copy(copy);
 
-  copy.m_leftSideStyle = m_leftSideStyle;
+  wxASSERT( copy.IsKindOf(CLASSINFO(wxDivisionShape)) ) ;
-  copy.m_topSideStyle = m_topSideStyle;
-  copy.m_leftSideColour = m_leftSideColour;
-  copy.m_topSideColour = m_topSideColour;
 
-  copy.m_leftSidePen = m_leftSidePen;
+  wxDivisionShape& divisionCopy = (wxDivisionShape&) copy;
-  copy.m_topSidePen = m_topSidePen;
+
-  copy.m_handleSide = m_handleSide;
+  divisionCopy.m_leftSideStyle = m_leftSideStyle;
+  divisionCopy.m_topSideStyle = m_topSideStyle;
+  divisionCopy.m_leftSideColour = m_leftSideColour;
+  divisionCopy.m_topSideColour = m_topSideColour;
+
+  divisionCopy.m_leftSidePen = m_leftSidePen;
+  divisionCopy.m_topSidePen = m_topSidePen;
+  divisionCopy.m_handleSide = m_handleSide;
 
   // Division geometry copying is handled at the wxCompositeShape level.
 }
 
-wxShape *wxDivisionShape::PrivateCopy()
-{
-  wxDivisionShape *obj = new wxDivisionShape;
-  Copy(*obj);
-  return obj;
-}
-
 #ifdef PROLOGIO
 void wxDivisionShape::WritePrologAttributes(wxExpr *clause)
 {

utils/ogl/src/composit.h

@@ -85,8 +85,7 @@ public:
   void ReadConstraints(wxExpr *clause, wxExprDatabase *database);
 #endif
   // Does the copying for this object
-  void Copy(wxCompositeShape& copy);
+  void Copy(wxShape& copy);
-  wxShape *PrivateCopy();
 
   virtual wxDivisionShape *OnCreateDivision();
 
@@ -160,8 +159,7 @@ class wxDivisionShape: public wxCompositeShape
   void ReadPrologAttributes(wxExpr *clause);
 #endif
   // Does the copying for this object
-  void Copy(wxDivisionShape& copy);
+  void Copy(wxShape& copy);
-  wxShape *PrivateCopy();
 
   // Divide horizontally (wxHORIZONTAL) or vertically (wxVERTICAL)
   bool Divide(int direction);

utils/ogl/src/divided.cpp

@@ -336,18 +336,11 @@ bool wxDividedShape::AttachmentIsValid(int attachment)
     return FALSE;
 }
 
-void wxDividedShape::Copy(wxDividedShape& copy)
+void wxDividedShape::Copy(wxShape& copy)
 {
   wxRectangleShape::Copy(copy);
 }
 
-wxShape *wxDividedShape::PrivateCopy()
-{
-  wxDividedShape *obj = new wxDividedShape(m_width, m_height);
-  Copy(*obj);
-  return obj;
-}
-
 // Region operations
 
 void wxDividedShape::MakeControlPoints()

utils/ogl/src/divided.h

@@ -52,8 +52,7 @@ class wxDividedShape: public wxRectangleShape
   void ReadPrologAttributes(wxExpr *clause);
 #endif
 
-  void Copy(wxDividedShape &copy);
+  void Copy(wxShape &copy);
-  wxShape *PrivateCopy();
 
   // Set all region sizes according to proportions and
   // this object total size

utils/ogl/src/drawn.cpp

@@ -162,19 +162,16 @@ void wxDrawnShape::ReadPrologAttributes(wxExpr *clause)
 #endif
 
 // Does the copying for this object
-void wxDrawnShape::Copy(wxDrawnShape& copy)
+void wxDrawnShape::Copy(wxShape& copy)
 {
   wxRectangleShape::Copy(copy);
-  m_metafile.Copy(copy.m_metafile);
-  copy.m_saveToFile = m_saveToFile;
-}
 
-// Returns a new instance, and does the copy for this class. Define for each class.
+  wxASSERT( copy.IsKindOf(CLASSINFO(wxDrawnShape)) ) ;
-wxShape *wxDrawnShape::PrivateCopy()
+
-{
+  wxDrawnShape& drawnCopy = (wxDrawnShape&) copy;
-  wxDrawnShape *obj = new wxDrawnShape;
+
-  Copy(*obj);
+  m_metafile.Copy(drawnCopy.m_metafile);
-  return obj;
+  drawnCopy.m_saveToFile = m_saveToFile;
 }
 
 bool wxDrawnShape::LoadFromMetaFile(char *filename)

utils/ogl/src/drawn.h

@@ -86,10 +86,7 @@ class wxDrawnShape: public wxRectangleShape
 #endif
 
   // Does the copying for this object
-  void Copy(wxDrawnShape& copy);
+  void Copy(wxShape& copy);
-
-  // Returns a new instance, and does the copy for this class. Define for each class.
-  wxShape *PrivateCopy();
 
   void Scale(float sx, float sy);
   void Translate(float x, float y);

utils/ogl/src/lines.cpp

@@ -1589,66 +1589,63 @@ void wxLineShape::ReadPrologAttributes(wxExpr *clause)
 }
 #endif
 
-void wxLineShape::Copy(wxLineShape& copy)
+void wxLineShape::Copy(wxShape& copy)
 {
   wxShape::Copy(copy);
 
-  copy.m_isSpline = m_isSpline;
+  wxASSERT( copy.IsKindOf(CLASSINFO(wxLineShape)) );
-  copy.m_alignmentStart = m_alignmentStart;
+
-  copy.m_alignmentEnd = m_alignmentEnd;
+  wxLineShape& lineCopy = (wxLineShape&) copy;
-  copy.m_maintainStraightLines = m_maintainStraightLines;
+
-  copy.m_lineOrientations.Clear();
+  lineCopy.m_isSpline = m_isSpline;
+  lineCopy.m_alignmentStart = m_alignmentStart;
+  lineCopy.m_alignmentEnd = m_alignmentEnd;
+  lineCopy.m_maintainStraightLines = m_maintainStraightLines;
+  lineCopy.m_lineOrientations.Clear();
   wxNode *node = m_lineOrientations.First();
   while (node)
   {
-    copy.m_lineOrientations.Append(node->Data());
+    lineCopy.m_lineOrientations.Append(node->Data());
     node = node->Next();
   }
 
-  if (copy.m_lineControlPoints)
+  if (lineCopy.m_lineControlPoints)
   {
-    ClearPointList(*copy.m_lineControlPoints);
+    ClearPointList(*lineCopy.m_lineControlPoints);
-    delete copy.m_lineControlPoints;
+    delete lineCopy.m_lineControlPoints;
   }
 
-  copy.m_lineControlPoints = new wxList;
+  lineCopy.m_lineControlPoints = new wxList;
 
   node = m_lineControlPoints->First();
   while (node)
   {
     wxRealPoint *point = (wxRealPoint *)node->Data();
     wxRealPoint *new_point = new wxRealPoint(point->x, point->y);
-    copy.m_lineControlPoints->Append((wxObject*) new_point);
+    lineCopy.m_lineControlPoints->Append((wxObject*) new_point);
     node = node->Next();
   }
 
 /*
-  copy.start_style = start_style;
+  lineCopy.start_style = start_style;
-  copy.end_style = end_style;
+  lineCopy.end_style = end_style;
-  copy.middle_style = middle_style;
+  lineCopy.middle_style = middle_style;
 
-  copy.arrow_length = arrow_length;
+  lineCopy.arrow_length = arrow_length;
-  copy.arrow_width = arrow_width;
+  lineCopy.arrow_width = arrow_width;
 */
 
   // Copy new OGL stuff
-  copy.ClearArrowsAtPosition(-1);
+  lineCopy.ClearArrowsAtPosition(-1);
   node = m_arcArrows.First();
   while (node)
   {
     wxArrowHead *arrow = (wxArrowHead *)node->Data();
-    copy.m_arcArrows.Append(new wxArrowHead(*arrow));
+    lineCopy.m_arcArrows.Append(new wxArrowHead(*arrow));
     node = node->Next();
   }
 }
 
-wxShape *wxLineShape::PrivateCopy()
-{
-  wxLineShape *line = new wxLineShape;
-  Copy(*line);
-  return line;
-}
-
 // Override select, to create/delete temporary label-moving objects
 void wxLineShape::Select(bool select, wxDC* dc)
 {
@@ -1725,6 +1722,25 @@ void wxLineControlPoint::OnDraw(wxDC& dc)
 // Implement movement of Line point
 void wxLineControlPoint::OnDragLeft(bool draw, float x, float y, int keys, int attachment)
 {
+    m_shape->GetEventHandler()->OnSizingDragLeft(this, draw, x, y, keys, attachment);
+}
+
+void wxLineControlPoint::OnBeginDragLeft(float x, float y, int keys, int attachment)
+{
+    m_shape->GetEventHandler()->OnSizingBeginDragLeft(this, x, y, keys, attachment);
+}
+  
+void wxLineControlPoint::OnEndDragLeft(float x, float y, int keys, int attachment)
+{
+    m_shape->GetEventHandler()->OnSizingEndDragLeft(this, x, y, keys, attachment);
+}
+
+// Control points ('handles') redirect control to the actual shape, to make it easier
+// to override sizing behaviour.
+void wxLineShape::OnSizingDragLeft(wxControlPoint* pt, bool draw, float x, float y, int keys, int attachment)
+{
+  wxLineControlPoint* lpt = (wxLineControlPoint*) pt;
+
   wxClientDC dc(GetCanvas());
   GetCanvas()->PrepareDC(dc);
 
@@ -1734,14 +1750,14 @@ void wxLineControlPoint::OnDragLeft(bool draw, float x, float y, int keys, int a
   dc.SetPen(dottedPen);
   dc.SetBrush((* wxTRANSPARENT_BRUSH));
 
-  if (m_type == CONTROL_POINT_LINE)
+  if (lpt->m_type == CONTROL_POINT_LINE)
   {
     m_canvas->Snap(&x, &y);
 
-    m_xpos = x; m_ypos = y;
+    lpt->SetX(x); lpt->SetY(y);
-    m_point->x = x; m_point->y = y;
+    lpt->m_point->x = x; lpt->m_point->y = y;
 
-    wxLineShape *lineShape = (wxLineShape *)m_shape;
+    wxLineShape *lineShape = (wxLineShape *)this;
 
     wxPen *old_pen = lineShape->GetPen();
     wxBrush *old_brush = lineShape->GetBrush();
@@ -1756,24 +1772,26 @@ void wxLineControlPoint::OnDragLeft(bool draw, float x, float y, int keys, int a
     lineShape->SetBrush(old_brush);
   }
 
-  if (m_type == CONTROL_POINT_ENDPOINT_FROM || m_type == CONTROL_POINT_ENDPOINT_TO)
+  if (lpt->m_type == CONTROL_POINT_ENDPOINT_FROM || lpt->m_type == CONTROL_POINT_ENDPOINT_TO)
   {
-    m_xpos = x; m_ypos = y;
+    lpt->SetX(x); lpt->SetY(y);
   }
 
 }
 
-void wxLineControlPoint::OnBeginDragLeft(float x, float y, int keys, int attachment)
+void wxLineShape::OnSizingBeginDragLeft(wxControlPoint* pt, float x, float y, int keys, int attachment)
 {
+  wxLineControlPoint* lpt = (wxLineControlPoint*) pt;
+
   wxClientDC dc(GetCanvas());
   GetCanvas()->PrepareDC(dc);
 
-  wxLineShape *lineShape = (wxLineShape *)m_shape;
+  wxLineShape *lineShape = (wxLineShape *)this;
-  if (m_type == CONTROL_POINT_LINE)
+  if (lpt->m_type == CONTROL_POINT_LINE)
   {
     m_canvas->Snap(&x, &y);
 
-    m_shape->Erase(dc);
+    this->Erase(dc);
 
     // Redraw start and end objects because we've left holes
     // when erasing the line
@@ -1782,11 +1800,11 @@ void wxLineControlPoint::OnBeginDragLeft(float x, float y, int keys, int attachm
     lineShape->GetTo()->OnDraw(dc);
     lineShape->GetTo()->OnDrawContents(dc);
 
-    m_shape->SetDisableLabel(TRUE);
+    this->SetDisableLabel(TRUE);
     dc.SetLogicalFunction(wxXOR);
 
-    m_xpos = x; m_ypos = y;
+    lpt->m_xpos = x; lpt->m_ypos = y;
-    m_point->x = x; m_point->y = y;
+    lpt->m_point->x = x; lpt->m_point->y = y;
 
     wxPen *old_pen = lineShape->GetPen();
     wxBrush *old_brush = lineShape->GetBrush();
@@ -1801,11 +1819,11 @@ void wxLineControlPoint::OnBeginDragLeft(float x, float y, int keys, int attachm
     lineShape->SetBrush(old_brush);
   }
 
-  if (m_type == CONTROL_POINT_ENDPOINT_FROM || m_type == CONTROL_POINT_ENDPOINT_TO)
+  if (lpt->m_type == CONTROL_POINT_ENDPOINT_FROM || lpt->m_type == CONTROL_POINT_ENDPOINT_TO)
   {
-    Erase(dc);
+    lpt->Erase(dc);
     lineShape->OnDraw(dc);
-    if (m_type == CONTROL_POINT_ENDPOINT_FROM)
+    if (lpt->m_type == CONTROL_POINT_ENDPOINT_FROM)
     {
       lineShape->GetFrom()->OnDraw(dc);
       lineShape->GetFrom()->OnDrawContents(dc);
@@ -1816,35 +1834,37 @@ void wxLineControlPoint::OnBeginDragLeft(float x, float y, int keys, int attachm
       lineShape->GetTo()->OnDrawContents(dc);
     }
     m_canvas->SetCursor(GraphicsBullseyeCursor);
-    m_oldCursor = wxSTANDARD_CURSOR;
+    lpt->m_oldCursor = wxSTANDARD_CURSOR;
   }
 }
 
-void wxLineControlPoint::OnEndDragLeft(float x, float y, int keys, int attachment)
+void wxLineShape::OnSizingEndDragLeft(wxControlPoint* pt, float x, float y, int keys, int attachment)
 {
+  wxLineControlPoint* lpt = (wxLineControlPoint*) pt;
+
   wxClientDC dc(GetCanvas());
   GetCanvas()->PrepareDC(dc);
 
-  m_shape->SetDisableLabel(FALSE);
+  this->SetDisableLabel(FALSE);
-  wxLineShape *lineShape = (wxLineShape *)m_shape;
+  wxLineShape *lineShape = (wxLineShape *)this;
 
-  if (m_type == CONTROL_POINT_LINE)
+  if (lpt->m_type == CONTROL_POINT_LINE)
   {
     m_canvas->Snap(&x, &y);
 
     dc.SetLogicalFunction(wxCOPY);
-    m_xpos = x; m_ypos = y;
+    lpt->m_xpos = x; lpt->m_ypos = y;
-    m_point->x = x; m_point->y = y;
+    lpt->m_point->x = x; lpt->m_point->y = y;
 
     lineShape->GetEventHandler()->OnMoveLink(dc);
   }
-  if (m_type == CONTROL_POINT_ENDPOINT_FROM)
+  if (lpt->m_type == CONTROL_POINT_ENDPOINT_FROM)
   {
-    if (m_oldCursor)
+    if (lpt->m_oldCursor)
-      m_canvas->SetCursor(m_oldCursor);
+      m_canvas->SetCursor(lpt->m_oldCursor);
-    m_shape->Erase(dc);
+    this->Erase(dc);
 
-    m_xpos = x; m_ypos = y;
+    lpt->m_xpos = x; lpt->m_ypos = y;
 
     if (lineShape->GetFrom())
     {
@@ -1852,12 +1872,12 @@ void wxLineControlPoint::OnEndDragLeft(float x, float y, int keys, int attachmen
       lineShape->GetFrom()->MoveLinks(dc);
     }
   }
-  if (m_type == CONTROL_POINT_ENDPOINT_TO)
+  if (lpt->m_type == CONTROL_POINT_ENDPOINT_TO)
   {
-    if (m_oldCursor)
+    if (lpt->m_oldCursor)
-      m_canvas->SetCursor(m_oldCursor);
+      m_canvas->SetCursor(lpt->m_oldCursor);
 
-    m_xpos = x; m_ypos = y;
+    lpt->m_xpos = x; lpt->m_ypos = y;
 
     if (lineShape->GetTo())
     {
@@ -1867,7 +1887,7 @@ void wxLineControlPoint::OnEndDragLeft(float x, float y, int keys, int attachmen
   }
   int i = 0;
   for (i = 0; i < lineShape->GetLineControlPoints()->Number(); i++)
-    if (((wxRealPoint *)(lineShape->GetLineControlPoints()->Nth(i)->Data())) == m_point)
+    if (((wxRealPoint *)(lineShape->GetLineControlPoints()->Nth(i)->Data())) == lpt->m_point)
       break;
 
   // N.B. in OnMoveControlPoint, an event handler in Hardy could have deselected

utils/ogl/src/lines.h

@@ -161,6 +161,12 @@ class wxLineShape: public wxShape
   void OnBeginDragLeft(float x, float y, int keys=0, int attachment = 0);
   void OnEndDragLeft(float x, float y, int keys=0, int attachment = 0);
 
+  // Control points ('handles') redirect control to the actual shape, to make it easier
+  // to override sizing behaviour.
+  virtual void OnSizingDragLeft(wxControlPoint* pt, bool draw, float x, float y, int keys=0, int attachment = 0);
+  virtual void OnSizingBeginDragLeft(wxControlPoint* pt, float x, float y, int keys=0, int attachment = 0);
+  virtual void OnSizingEndDragLeft(wxControlPoint* pt, float x, float y, int keys=0, int attachment = 0);
+
   // Override select, to create/delete temporary label-moving objects
   void Select(bool select = TRUE, wxDC* dc = NULL);
 
@@ -192,8 +198,7 @@ class wxLineShape: public wxShape
   virtual bool Draggable() const { return FALSE; }
 
   // Does the copying for this object
-  void Copy(wxLineShape& copy);
+  void Copy(wxShape& copy);
-  wxShape *PrivateCopy();
 
   // New OGL stuff
   wxArrowHead *AddArrow(WXTYPE type, int end = ARROW_POSITION_END,

utils/ogl/src/linesp.h

@@ -16,10 +16,11 @@
 #pragma interface "linesp.h"
 #endif
 
+class wxLineShape;
 class wxLineControlPoint: public wxControlPoint
 {
   DECLARE_DYNAMIC_CLASS(wxLineControlPoint)
-
+  friend class wxLineShape;
  public:
 
   wxLineControlPoint(wxShapeCanvas *the_canvas = NULL, wxShape *object = NULL, float size = 0.0,