New way to grey out disabled toolbar icons.

[wxWidgets.git] / utils / ogl / src / basic2.cpp

diff --git a/utils/ogl/src/basic2.cpp b/utils/ogl/src/basic2.cpp
index 98f65933f0cf553e118a66af23dbd545adcb6eff..ba46cca6fe0f141e6d9f130c509c2c527e828d9c 100644 (file)
--- a/utils/ogl/src/basic2.cpp
+++ b/utils/ogl/src/basic2.cpp
@@ -10,6 +10,7 @@
 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__
 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__

+#pragma implementation "basicp.h"

 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #endif
 
 // For compilers that support precompilation, includes "wx.h".


@@ -23,11 +24,9 @@
 #include <wx/wx.h>
 #endif
 
 #include <wx/wx.h>
 #endif
 

-#ifdef PROLOGIO

 #include <wx/wxexpr.h>
 #include <wx/wxexpr.h>

-#endif

 
 

-#if USE_IOSTREAMH
+#if wxUSE_IOSTREAMH

 #include <iostream.h>
 #else
 #include <iostream>
 #include <iostream.h>
 #else
 #include <iostream>


@@ -125,7 +124,7 @@ void wxPolygonShape::ClearPoints()
 
 
 // Width and height. Centre of object is centre of box.
 
 
 // Width and height. Centre of object is centre of box.

-void wxPolygonShape::GetBoundingBoxMin(float *width, float *height)
+void wxPolygonShape::GetBoundingBoxMin(double *width, double *height)

 {
   *width = m_boundWidth;
   *height = m_boundHeight;
 {
   *width = m_boundWidth;
   *height = m_boundHeight;


@@ -134,10 +133,10 @@ void wxPolygonShape::GetBoundingBoxMin(float *width, float *height)
 void wxPolygonShape::CalculateBoundingBox()
 {
   // Calculate bounding box at construction (and presumably resize) time
 void wxPolygonShape::CalculateBoundingBox()
 {
   // Calculate bounding box at construction (and presumably resize) time

-  float left = 10000;
-  float right = -10000;
-  float top = 10000;
-  float bottom = -10000;
+  double left = 10000;
+  double right = -10000;
+  double top = 10000;
+  double bottom = -10000;

 
   wxNode *node = m_points->First();
   while (node)
 
   wxNode *node = m_points->First();
   while (node)


@@ -162,10 +161,10 @@ void wxPolygonShape::CalculateBoundingBox()
 // box.
 void wxPolygonShape::CalculatePolygonCentre()
 {
 // box.
 void wxPolygonShape::CalculatePolygonCentre()
 {

-  float left = 10000;
-  float right = -10000;
-  float top = 10000;
-  float bottom = -10000;
+  double left = 10000;
+  double right = -10000;
+  double top = 10000;
+  double bottom = -10000;

 
   wxNode *node = m_points->First();
   while (node)
 
   wxNode *node = m_points->First();
   while (node)


@@ -179,11 +178,11 @@ void wxPolygonShape::CalculatePolygonCentre()
 
     node = node->Next();
   }
 
     node = node->Next();
   }

-  float bwidth = right - left;
-  float bheight = bottom - top;
-  
-  float newCentreX = (float)(left + (bwidth/2.0));
-  float newCentreY = (float)(top + (bheight/2.0));
+  double bwidth = right - left;
+  double bheight = bottom - top;
+
+  double newCentreX = (double)(left + (bwidth/2.0));
+  double newCentreY = (double)(top + (bheight/2.0));

 
   node = m_points->First();
   while (node)
 
   node = m_points->First();
   while (node)


@@ -197,22 +196,22 @@ void wxPolygonShape::CalculatePolygonCentre()
   m_ypos += newCentreY;
 }
 
   m_ypos += newCentreY;
 }
 

-bool PolylineHitTest(float n, float xvec[], float yvec[],
-                           float x1, float y1, float x2, float y2)
+bool PolylineHitTest(double n, double xvec[], double yvec[],
+                           double x1, double y1, double x2, double y2)

 {
   bool isAHit = FALSE;
   int i;
 {
   bool isAHit = FALSE;
   int i;

-  float lastx = xvec[0];
-  float lasty = yvec[0];
+  double lastx = xvec[0];
+  double lasty = yvec[0];

 
 

-  float min_ratio = 1.0;
-  float line_ratio;
-  float other_ratio;
+  double min_ratio = 1.0;
+  double line_ratio;
+  double other_ratio;

 
 //  char buf[300];
   for (i = 1; i < n; i++)
   {
 
 //  char buf[300];
   for (i = 1; i < n; i++)
   {

-    check_line_intersection(x1, y1, x2, y2, lastx, lasty, xvec[i], yvec[i],
+    oglCheckLineIntersection(x1, y1, x2, y2, lastx, lasty, xvec[i], yvec[i],

                             &line_ratio, &other_ratio);
     if (line_ratio != 1.0)
       isAHit = TRUE;
                             &line_ratio, &other_ratio);
     if (line_ratio != 1.0)
       isAHit = TRUE;


@@ -225,10 +224,10 @@ bool PolylineHitTest(float n, float xvec[], float yvec[],
       min_ratio = line_ratio;
   }
 
       min_ratio = line_ratio;
   }
 

-  // Do last (implicit) line if last and first floats are not identical
+  // Do last (implicit) line if last and first doubles are not identical

   if (!(xvec[0] == lastx && yvec[0] == lasty))
   {
   if (!(xvec[0] == lastx && yvec[0] == lasty))
   {

-    check_line_intersection(x1, y1, x2, y2, lastx, lasty, xvec[0], yvec[0],
+    oglCheckLineIntersection(x1, y1, x2, y2, lastx, lasty, xvec[0], yvec[0],

                             &line_ratio, &other_ratio);
     if (line_ratio != 1.0)
       isAHit = TRUE;
                             &line_ratio, &other_ratio);
     if (line_ratio != 1.0)
       isAHit = TRUE;


@@ -242,30 +241,30 @@ bool PolylineHitTest(float n, float xvec[], float yvec[],
   return isAHit;
 }
 
   return isAHit;
 }
 

-bool wxPolygonShape::HitTest(float x, float y, int *attachment, float *distance)
+bool wxPolygonShape::HitTest(double x, double y, int *attachment, double *distance)

 {
   // Imagine four lines radiating from this point. If all of these lines hit the polygon,
   // we're inside it, otherwise we're not. Obviously we'd need more radiating lines
   // to be sure of correct results for very strange (concave) shapes.
 {
   // Imagine four lines radiating from this point. If all of these lines hit the polygon,
   // we're inside it, otherwise we're not. Obviously we'd need more radiating lines
   // to be sure of correct results for very strange (concave) shapes.

-  float endPointsX[4];
-  float endPointsY[4];
+  double endPointsX[4];
+  double endPointsY[4];

   // North
   endPointsX[0] = x;
   // North
   endPointsX[0] = x;

-  endPointsY[0] = (float)(y - 1000.0);
+  endPointsY[0] = (double)(y - 1000.0);

   // East
   // East

-  endPointsX[1] = (float)(x + 1000.0);
+  endPointsX[1] = (double)(x + 1000.0);

   endPointsY[1] = y;
   // South
   endPointsX[2] = x;
   endPointsY[1] = y;
   // South
   endPointsX[2] = x;

-  endPointsY[2] = (float)(y + 1000.0);
+  endPointsY[2] = (double)(y + 1000.0);

   // West
   // West

-  endPointsX[3] = (float)(x - 1000.0);
+  endPointsX[3] = (double)(x - 1000.0);

   endPointsY[3] = y;
 
   // Store polygon points in an array
   int np = m_points->Number();
   endPointsY[3] = y;
 
   // Store polygon points in an array
   int np = m_points->Number();

-  float *xpoints = new float[np];
-  float *ypoints = new float[np];
+  double *xpoints = new double[np];
+  double *ypoints = new double[np];

   wxNode *node = m_points->First();
   int i = 0;
   while (node)
   wxNode *node = m_points->First();
   int i = 0;
   while (node)


@@ -303,14 +302,14 @@ bool wxPolygonShape::HitTest(float x, float y, int *attachment, float *distance)
 
   // If a hit, check the attachment points within the object.
   int n = GetNumberOfAttachments();
 
   // If a hit, check the attachment points within the object.
   int n = GetNumberOfAttachments();

-  float nearest = 999999.0;
+  double nearest = 999999.0;

 
   for (i = 0; i < n; i++)
   {
 
   for (i = 0; i < n; i++)
   {

-    float xp, yp;
-    if (GetAttachmentPosition(i, &xp, &yp))
+    double xp, yp;
+    if (GetAttachmentPositionEdge(i, &xp, &yp))

     {
     {

-      float l = (float)sqrt(((xp - x) * (xp - x)) +
+      double l = (double)sqrt(((xp - x) * (xp - x)) +

                  ((yp - y) * (yp - y)));
       if (l < nearest)
       {
                  ((yp - y) * (yp - y)));
       if (l < nearest)
       {


@@ -326,13 +325,13 @@ bool wxPolygonShape::HitTest(float x, float y, int *attachment, float *distance)
 
 // Really need to be able to reset the shape! Otherwise, if the
 // points ever go to zero, we've lost it, and can't resize.
 
 // Really need to be able to reset the shape! Otherwise, if the
 // points ever go to zero, we've lost it, and can't resize.

-void wxPolygonShape::SetSize(float new_width, float new_height, bool recursive)
+void wxPolygonShape::SetSize(double new_width, double new_height, bool recursive)

 {
   SetAttachmentSize(new_width, new_height);
   
   // Multiply all points by proportion of new size to old size
 {
   SetAttachmentSize(new_width, new_height);
   
   // Multiply all points by proportion of new size to old size

-  float x_proportion = (float)(fabs(new_width/m_originalWidth));
-  float y_proportion = (float)(fabs(new_height/m_originalHeight));
+  double x_proportion = (double)(fabs(new_width/m_originalWidth));
+  double y_proportion = (double)(fabs(new_height/m_originalHeight));

 
   wxNode *node = m_points->First();
   wxNode *original_node = m_originalPoints->First();
 
   wxNode *node = m_points->First();
   wxNode *original_node = m_originalPoints->First();


@@ -349,8 +348,8 @@ void wxPolygonShape::SetSize(float new_width, float new_height, bool recursive)
   }
 
 //  CalculateBoundingBox();
   }
 
 //  CalculateBoundingBox();

-  m_boundWidth = (float)fabs(new_width);
-  m_boundHeight = (float)fabs(new_height);
+  m_boundWidth = (double)fabs(new_width);
+  m_boundHeight = (double)fabs(new_height);

   SetDefaultRegionSize();
 }
 
   SetDefaultRegionSize();
 }
 


@@ -393,8 +392,8 @@ void wxPolygonShape::AddPolygonPoint(int pos)
   if (!node2) node2 = m_points->First();
   wxRealPoint *secondPoint = (wxRealPoint *)node2->Data();
 
   if (!node2) node2 = m_points->First();
   wxRealPoint *secondPoint = (wxRealPoint *)node2->Data();
 

-  float x = (float)((secondPoint->x - firstPoint->x)/2.0 + firstPoint->x);
-  float y = (float)((secondPoint->y - firstPoint->y)/2.0 + firstPoint->y);
+  double x = (double)((secondPoint->x - firstPoint->x)/2.0 + firstPoint->x);
+  double y = (double)((secondPoint->y - firstPoint->y)/2.0 + firstPoint->y);

   wxRealPoint *point = new wxRealPoint(x, y);
 
   if (pos >= (m_points->Number() - 1))
   wxRealPoint *point = new wxRealPoint(x, y);
 
   if (pos >= (m_points->Number() - 1))


@@ -429,17 +428,17 @@ void wxPolygonShape::DeletePolygonPoint(int pos)
 }
 
 // Assume (x1, y1) is centre of box (most generally, line end at box)
 }
 
 // Assume (x1, y1) is centre of box (most generally, line end at box)

-bool wxPolygonShape::GetPerimeterPoint(float x1, float y1,
-                                     float x2, float y2,
-                                     float *x3, float *y3)
+bool wxPolygonShape::GetPerimeterPoint(double x1, double y1,
+                                     double x2, double y2,
+                                     double *x3, double *y3)

 {
   int n = m_points->Number();
 
   // First check for situation where the line is vertical,
   // and we would want to connect to a point on that vertical --
 {
   int n = m_points->Number();
 
   // First check for situation where the line is vertical,
   // and we would want to connect to a point on that vertical --

-  // find_end_for_polyline can't cope with this (the arrow
+  // oglFindEndForPolyline can't cope with this (the arrow

   // gets drawn to the wrong place).
   // gets drawn to the wrong place).

-  if ((!m_attachmentMode) && (x1 == x2))
+  if ((m_attachmentMode == ATTACHMENT_MODE_NONE) && (x1 == x2))

   {
     // Look for the point we'd be connecting to. This is
     // a heuristic...
   {
     // Look for the point we'd be connecting to. This is
     // a heuristic...


@@ -466,8 +465,8 @@ bool wxPolygonShape::GetPerimeterPoint(float x1, float y1,
     }
   }
   
     }
   }
   

-  float *xpoints = new float[n];
-  float *ypoints = new float[n];
+  double *xpoints = new double[n];
+  double *ypoints = new double[n];

 
   wxNode *node = m_points->First();
   int i = 0;
 
   wxNode *node = m_points->First();
   int i = 0;


@@ -479,17 +478,12 @@ bool wxPolygonShape::GetPerimeterPoint(float x1, float y1,
     node = node->Next();
     i ++;
   }
     node = node->Next();
     i ++;
   }

-/*
-  wxRealPoint *point = (wxRealPoint *)m_points->First()->Data();
-  xpoints[i] = point->x + m_xpos;
-  ypoints[i] = point->y + m_ypos;
-*/

 
 

-  find_end_for_polyline(n, xpoints, ypoints, 
+  oglFindEndForPolyline(n, xpoints, ypoints, 

                         x1, y1, x2, y2, x3, y3);
 
                         x1, y1, x2, y2, x3, y3);
 

-  delete xpoints;
-  delete ypoints;
+  delete[] xpoints;
+  delete[] ypoints;

 
   return TRUE;
 }
 
   return TRUE;
 }


@@ -502,39 +496,39 @@ void wxPolygonShape::OnDraw(wxDC& dc)
     for (i = 0; i < n; i++)
     {
       wxRealPoint* point = (wxRealPoint*) m_points->Nth(i)->Data();
     for (i = 0; i < n; i++)
     {
       wxRealPoint* point = (wxRealPoint*) m_points->Nth(i)->Data();

-      intPoints[i].x = (int) point->x;
-      intPoints[i].y = (int) point->y;
+      intPoints[i].x = WXROUND(point->x);
+      intPoints[i].y = WXROUND(point->y);

     }
 
     if (m_shadowMode != SHADOW_NONE)
     {
       if (m_shadowBrush)
     }
 
     if (m_shadowMode != SHADOW_NONE)
     {
       if (m_shadowBrush)

-        dc.SetBrush(m_shadowBrush);
-      dc.SetPen(transparent_pen);
+        dc.SetBrush(* m_shadowBrush);
+      dc.SetPen(* g_oglTransparentPen);

 
 

-      dc.DrawPolygon(n, intPoints, m_xpos + m_shadowOffsetX, m_ypos + m_shadowOffsetY);
+      dc.DrawPolygon(n, intPoints, WXROUND(m_xpos + m_shadowOffsetX), WXROUND(m_ypos + m_shadowOffsetY));

     }
 
     if (m_pen)
     {
       if (m_pen->GetWidth() == 0)
     }
 
     if (m_pen)
     {
       if (m_pen->GetWidth() == 0)

-        dc.SetPen(transparent_pen);
+        dc.SetPen(* g_oglTransparentPen);

       else
       else

-        dc.SetPen(m_pen);
+        dc.SetPen(* m_pen);

     }
     if (m_brush)
     }
     if (m_brush)

-      dc.SetBrush(m_brush);
-    dc.DrawPolygon(n, intPoints, m_xpos, m_ypos);
+      dc.SetBrush(* m_brush);
+    dc.DrawPolygon(n, intPoints, WXROUND(m_xpos), WXROUND(m_ypos));

 
     delete[] intPoints;
 }
 
 
     delete[] intPoints;
 }
 

-void wxPolygonShape::OnDrawOutline(wxDC& dc, float x, float y, float w, float h)
+void wxPolygonShape::OnDrawOutline(wxDC& dc, double x, double y, double w, double h)

 {
 {

-  dc.SetBrush(wxTRANSPARENT_BRUSH);
+  dc.SetBrush(* wxTRANSPARENT_BRUSH);

   // Multiply all points by proportion of new size to old size
   // Multiply all points by proportion of new size to old size

-  float x_proportion = (float)(fabs(w/m_originalWidth));
-  float y_proportion = (float)(fabs(h/m_originalHeight));
+  double x_proportion = (double)(fabs(w/m_originalWidth));
+  double y_proportion = (double)(fabs(h/m_originalHeight));

 
   int n = m_originalPoints->Number();
   wxPoint *intPoints = new wxPoint[n];
 
   int n = m_originalPoints->Number();
   wxPoint *intPoints = new wxPoint[n];


@@ -542,10 +536,10 @@ void wxPolygonShape::OnDrawOutline(wxDC& dc, float x, float y, float w, float h)
   for (i = 0; i < n; i++)
   {
     wxRealPoint* point = (wxRealPoint*) m_originalPoints->Nth(i)->Data();
   for (i = 0; i < n; i++)
   {
     wxRealPoint* point = (wxRealPoint*) m_originalPoints->Nth(i)->Data();

-    intPoints[i].x = (int) (x_proportion * point->x);
-    intPoints[i].y = (int) (y_proportion * point->y);
+    intPoints[i].x = WXROUND(x_proportion * point->x);
+    intPoints[i].y = WXROUND(y_proportion * point->y);

   }
   }

-  dc.DrawPolygon(n, intPoints, x, y);
+  dc.DrawPolygon(n, intPoints, WXROUND(x), WXROUND(y));

   delete[] intPoints;
 }
 
   delete[] intPoints;
 }
 


@@ -562,62 +556,6 @@ void wxPolygonShape::MakeControlPoints()
     m_controlPoints.Append(control);
     node = node->Next();
   }
     m_controlPoints.Append(control);
     node = node->Next();
   }

-
-/*
-  float maxX, maxY, minX, minY;
-
-  GetBoundingBoxMax(&maxX, &maxY);
-  GetBoundingBoxMin(&minX, &minY);
-
-  float widthMin = (float)(minX + CONTROL_POINT_SIZE + 2);
-  float heightMin = (float)(minY + CONTROL_POINT_SIZE + 2);
-
-  // Offsets from main object
-  float top = (float)(- (heightMin / 2.0));
-  float bottom = (float)(heightMin / 2.0 + (maxY - minY));
-  float left = (float)(- (widthMin / 2.0));
-  float right = (float)(widthMin / 2.0 + (maxX - minX));
-
-  wxControlPoint *control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, left, top, 
-                                           CONTROL_POINT_DIAGONAL);
-  m_canvas->AddShape(control);
-  m_controlPoints.Append(control);
-
-  control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, 0, top, 
-                                           CONTROL_POINT_VERTICAL);
-  m_canvas->AddShape(control);
-  m_controlPoints.Append(control);
-
-  control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, right, top, 
-                                           CONTROL_POINT_DIAGONAL);
-  m_canvas->AddShape(control);
-  m_controlPoints.Append(control);
-
-  control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, right, 0, 
-                                           CONTROL_POINT_HORIZONTAL);
-  m_canvas->AddShape(control);
-  m_controlPoints.Append(control);
-
-  control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, right, bottom, 
-                                           CONTROL_POINT_DIAGONAL);
-  m_canvas->AddShape(control);
-  m_controlPoints.Append(control);
-
-  control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, 0, bottom, 
-                                           CONTROL_POINT_VERTICAL);
-  m_canvas->AddShape(control);
-  m_controlPoints.Append(control);
-
-  control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, left, bottom, 
-                                           CONTROL_POINT_DIAGONAL);
-  m_canvas->AddShape(control);
-  m_controlPoints.Append(control);
-
-  control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, left, 0, 
-                                           CONTROL_POINT_HORIZONTAL);
-  m_canvas->AddShape(control);
-  m_controlPoints.Append(control);
-*/

 }
 
 void wxPolygonShape::ResetControlPoints()
 }
 
 void wxPolygonShape::ResetControlPoints()


@@ -636,70 +574,26 @@ void wxPolygonShape::ResetControlPoints()
     node = node->Next();
     controlPointNode = controlPointNode->Next();
   }
     node = node->Next();
     controlPointNode = controlPointNode->Next();
   }

-/*
-
-  if (m_controlPoints.Number() < 1)
-    return;
-
-  float maxX, maxY, minX, minY;
-
-  GetBoundingBoxMax(&maxX, &maxY);
-  GetBoundingBoxMin(&minX, &minY);
-
-  float widthMin = (float)(minX + CONTROL_POINT_SIZE + 2);
-  float heightMin = (float)(minY + CONTROL_POINT_SIZE + 2);
-
-  // Offsets from main object
-  float top = (float)(- (heightMin / 2.0));
-  float bottom = (float)(heightMin / 2.0 + (maxY - minY));
-  float left = (float)(- (widthMin / 2.0));
-  float right = (float)(widthMin / 2.0 + (maxX - minX));
-
-  wxNode *node = m_controlPoints.First();
-  wxControlPoint *control = (wxControlPoint *)node->Data();
-  control->xoffset = left; control->yoffset = top;
-
-  node = node->Next(); control = (wxControlPoint *)node->Data();
-  control->xoffset = 0; control->yoffset = top;
-
-  node = node->Next(); control = (wxControlPoint *)node->Data();
-  control->xoffset = right; control->yoffset = top;
-
-  node = node->Next(); control = (wxControlPoint *)node->Data();
-  control->xoffset = right; control->yoffset = 0;
-
-  node = node->Next(); control = (wxControlPoint *)node->Data();
-  control->xoffset = right; control->yoffset = bottom;
-
-  node = node->Next(); control = (wxControlPoint *)node->Data();
-  control->xoffset = 0; control->yoffset = bottom;
-
-  node = node->Next(); control = (wxControlPoint *)node->Data();
-  control->xoffset = left; control->yoffset = bottom;
-
-  node = node->Next(); control = (wxControlPoint *)node->Data();
-  control->xoffset = left; control->yoffset = 0;
-*/

 }
 
 
 #ifdef PROLOGIO
 }
 
 
 #ifdef PROLOGIO

-void wxPolygonShape::WritePrologAttributes(wxExpr *clause)
+void wxPolygonShape::WriteAttributes(wxExpr *clause)

 {
 {

-  wxShape::WritePrologAttributes(clause);
+  wxShape::WriteAttributes(clause);

 
   clause->AddAttributeValue("x", m_xpos);
   clause->AddAttributeValue("y", m_ypos);
 
   // Make a list of lists for the coordinates
 
   clause->AddAttributeValue("x", m_xpos);
   clause->AddAttributeValue("y", m_ypos);
 
   // Make a list of lists for the coordinates

-  wxExpr *list = new wxExpr(PrologList);
+  wxExpr *list = new wxExpr(wxExprList);

   wxNode *node = m_points->First();
   while (node)
   {
     wxRealPoint *point = (wxRealPoint *)node->Data();
   wxNode *node = m_points->First();
   while (node)
   {
     wxRealPoint *point = (wxRealPoint *)node->Data();

-    wxExpr *point_list = new wxExpr(PrologList);
-    wxExpr *x_expr = new wxExpr((float)point->x);
-    wxExpr *y_expr = new wxExpr((float)point->y);
+    wxExpr *point_list = new wxExpr(wxExprList);
+    wxExpr *x_expr = new wxExpr((double)point->x);
+    wxExpr *y_expr = new wxExpr((double)point->y);

 
     point_list->Append(x_expr);
     point_list->Append(y_expr);
 
     point_list->Append(x_expr);
     point_list->Append(y_expr);


@@ -710,14 +604,14 @@ void wxPolygonShape::WritePrologAttributes(wxExpr *clause)
   clause->AddAttributeValue("points", list);
 
   // Save the original (unscaled) points
   clause->AddAttributeValue("points", list);
 
   // Save the original (unscaled) points

-  list = new wxExpr(PrologList);
+  list = new wxExpr(wxExprList);

   node = m_originalPoints->First();
   while (node)
   {
     wxRealPoint *point = (wxRealPoint *)node->Data();
   node = m_originalPoints->First();
   while (node)
   {
     wxRealPoint *point = (wxRealPoint *)node->Data();

-    wxExpr *point_list = new wxExpr(PrologList);
-    wxExpr *x_expr = new wxExpr((float) point->x);
-    wxExpr *y_expr = new wxExpr((float) point->y);
+    wxExpr *point_list = new wxExpr(wxExprList);
+    wxExpr *x_expr = new wxExpr((double) point->x);
+    wxExpr *y_expr = new wxExpr((double) point->y);

     point_list->Append(x_expr);
     point_list->Append(y_expr);
     list->Append(point_list);
     point_list->Append(x_expr);
     point_list->Append(y_expr);
     list->Append(point_list);


@@ -727,9 +621,9 @@ void wxPolygonShape::WritePrologAttributes(wxExpr *clause)
   clause->AddAttributeValue("m_originalPoints", list);
 }
 
   clause->AddAttributeValue("m_originalPoints", list);
 }
 

-void wxPolygonShape::ReadPrologAttributes(wxExpr *clause)
+void wxPolygonShape::ReadAttributes(wxExpr *clause)

 {
 {

-  wxShape::ReadPrologAttributes(clause);
+  wxShape::ReadAttributes(clause);

 
   // Read a list of lists
   m_points = new wxList;
 
   // Read a list of lists
   m_points = new wxList;


@@ -739,8 +633,8 @@ void wxPolygonShape::ReadPrologAttributes(wxExpr *clause)
   clause->AssignAttributeValue("points", &points_list);
 
   // If no points_list, don't crash!! Assume a diamond instead.
   clause->AssignAttributeValue("points", &points_list);
 
   // If no points_list, don't crash!! Assume a diamond instead.

-  float the_height = 100.0;
-  float the_width = 100.0;
+  double the_height = 100.0;
+  double the_width = 100.0;

   if (!points_list)
   {
     wxRealPoint *point = new wxRealPoint(0.0, (-the_height/2));
   if (!points_list)
   {
     wxRealPoint *point = new wxRealPoint(0.0, (-the_height/2));


@@ -770,7 +664,7 @@ void wxPolygonShape::ReadPrologAttributes(wxExpr *clause)
       wxExpr *yexpr = xexpr->next;
       long y = yexpr->IntegerValue();
 
       wxExpr *yexpr = xexpr->next;
       long y = yexpr->IntegerValue();
 

-      wxRealPoint *point = new wxRealPoint((float)x, (float)y);
+      wxRealPoint *point = new wxRealPoint((double)x, (double)y);

       m_points->Append((wxObject*) point);
 
       node = node->next;
       m_points->Append((wxObject*) point);
 
       node = node->next;


@@ -804,10 +698,10 @@ void wxPolygonShape::ReadPrologAttributes(wxExpr *clause)
   else
   {
     wxExpr *node = points_list->value.first;
   else
   {
     wxExpr *node = points_list->value.first;

-    float min_x = 1000;
-    float min_y = 1000;
-    float max_x = -1000;
-    float max_y = -1000;
+    double min_x = 1000;
+    double min_y = 1000;
+    double max_x = -1000;
+    double max_y = -1000;

     while (node)
     {
       wxExpr *xexpr = node->value.first;
     while (node)
     {
       wxExpr *xexpr = node->value.first;


@@ -816,17 +710,17 @@ void wxPolygonShape::ReadPrologAttributes(wxExpr *clause)
       wxExpr *yexpr = xexpr->next;
       long y = yexpr->IntegerValue();
 
       wxExpr *yexpr = xexpr->next;
       long y = yexpr->IntegerValue();
 

-      wxRealPoint *point = new wxRealPoint((float)x, (float)y);
+      wxRealPoint *point = new wxRealPoint((double)x, (double)y);

       m_originalPoints->Append((wxObject*) point);
 
       if (x < min_x)
       m_originalPoints->Append((wxObject*) point);
 
       if (x < min_x)

-        min_x = (float)x;
+        min_x = (double)x;

       if (y < min_y)
       if (y < min_y)

-        min_y = (float)y;
+        min_y = (double)y;

       if (x > max_x)
       if (x > max_x)

-        max_x = (float)x;
+        max_x = (double)x;

       if (y > max_y)
       if (y > max_y)

-        max_y = (float)y;
+        max_y = (double)y;

 
       node = node->next;
     }
 
       node = node->next;
     }


@@ -873,7 +767,7 @@ void wxPolygonShape::Copy(wxShape& copy)
   polyCopy.m_originalHeight = m_originalHeight;
 }
 
   polyCopy.m_originalHeight = m_originalHeight;
 }
 

-int wxPolygonShape::GetNumberOfAttachments()
+int wxPolygonShape::GetNumberOfAttachments() const

 {
   int maxN = (m_points ? (m_points->Number() - 1) : 0);
   wxNode *node = m_attachmentPoints.First();
 {
   int maxN = (m_points ? (m_points->Number() - 1) : 0);
   wxNode *node = m_attachmentPoints.First();


@@ -887,10 +781,10 @@ int wxPolygonShape::GetNumberOfAttachments()
   return maxN+1;;
 }
 
   return maxN+1;;
 }
 

-bool wxPolygonShape::GetAttachmentPosition(int attachment, float *x, float *y,
+bool wxPolygonShape::GetAttachmentPosition(int attachment, double *x, double *y,

                                          int nth, int no_arcs, wxLineShape *line)
 {
                                          int nth, int no_arcs, wxLineShape *line)
 {

-  if (m_attachmentMode && m_points && attachment < m_points->Number())
+  if ((m_attachmentMode == ATTACHMENT_MODE_EDGE) && m_points && attachment < m_points->Number())

   {
     wxRealPoint *point = (wxRealPoint *)m_points->Nth(attachment)->Data();
     *x = point->x + m_xpos;
   {
     wxRealPoint *point = (wxRealPoint *)m_points->Nth(attachment)->Data();
     *x = point->x + m_xpos;


@@ -920,11 +814,58 @@ bool wxPolygonShape::AttachmentIsValid(int attachment)
   return FALSE;
 }
 
   return FALSE;
 }
 

+// Rotate about the given axis by the given amount in radians
+void wxPolygonShape::Rotate(double x, double y, double theta)
+{
+    double actualTheta = theta-m_rotation;
+
+    // Rotate attachment points
+    double sinTheta = (double)sin(actualTheta);
+    double cosTheta = (double)cos(actualTheta);
+    wxNode *node = m_attachmentPoints.First();
+    while (node)
+    {
+        wxAttachmentPoint *point = (wxAttachmentPoint *)node->Data();
+        double x1 = point->m_x;
+        double y1 = point->m_y;
+        point->m_x = x1*cosTheta - y1*sinTheta + x*(1.0 - cosTheta) + y*sinTheta;
+        point->m_y = x1*sinTheta + y1*cosTheta + y*(1.0 - cosTheta) + x*sinTheta;
+        node = node->Next();
+    }
+
+    node = m_points->First();
+    while (node)
+    {
+        wxRealPoint *point = (wxRealPoint *)node->Data();
+        double x1 = point->x;
+        double y1 = point->y;
+        point->x = x1*cosTheta - y1*sinTheta + x*(1.0 - cosTheta) + y*sinTheta;
+        point->y = x1*sinTheta + y1*cosTheta + y*(1.0 - cosTheta) + x*sinTheta;
+        node = node->Next();
+    }
+    node = m_originalPoints->First();
+    while (node)
+    {
+        wxRealPoint *point = (wxRealPoint *)node->Data();
+        double x1 = point->x;
+        double y1 = point->y;
+        point->x = x1*cosTheta - y1*sinTheta + x*(1.0 - cosTheta) + y*sinTheta;
+        point->y = x1*sinTheta + y1*cosTheta + y*(1.0 - cosTheta) + x*sinTheta;
+        node = node->Next();
+    }
+
+    m_rotation = theta;
+
+    CalculatePolygonCentre();
+    CalculateBoundingBox();
+    ResetControlPoints();
+}
+

 // Rectangle object
 
 IMPLEMENT_DYNAMIC_CLASS(wxRectangleShape, wxShape)
 
 // Rectangle object
 
 IMPLEMENT_DYNAMIC_CLASS(wxRectangleShape, wxShape)
 

-wxRectangleShape::wxRectangleShape(float w, float h)
+wxRectangleShape::wxRectangleShape(double w, double h)

 {
   m_width = w; m_height = h; m_cornerRadius = 0.0;
   SetDefaultRegionSize();
 {
   m_width = w; m_height = h; m_cornerRadius = 0.0;
   SetDefaultRegionSize();


@@ -932,73 +873,73 @@ wxRectangleShape::wxRectangleShape(float w, float h)
 
 void wxRectangleShape::OnDraw(wxDC& dc)
 {
 
 void wxRectangleShape::OnDraw(wxDC& dc)
 {

-    float x1 = (float)(m_xpos - m_width/2.0);
-    float y1 = (float)(m_ypos - m_height/2.0);
+    double x1 = (double)(m_xpos - m_width/2.0);
+    double y1 = (double)(m_ypos - m_height/2.0);

 
     if (m_shadowMode != SHADOW_NONE)
     {
       if (m_shadowBrush)
 
     if (m_shadowMode != SHADOW_NONE)
     {
       if (m_shadowBrush)

-        dc.SetBrush(m_shadowBrush);
-      dc.SetPen(transparent_pen);
+        dc.SetBrush(* m_shadowBrush);
+      dc.SetPen(* g_oglTransparentPen);

 
       if (m_cornerRadius != 0.0)
 
       if (m_cornerRadius != 0.0)

-        dc.DrawRoundedRectangle(x1 + m_shadowOffsetX, y1 + m_shadowOffsetY,
-                                 m_width, m_height, m_cornerRadius);
+        dc.DrawRoundedRectangle(WXROUND(x1 + m_shadowOffsetX), WXROUND(y1 + m_shadowOffsetY),
+                                 WXROUND(m_width), WXROUND(m_height), m_cornerRadius);

       else
       else

-        dc.DrawRectangle(x1 + m_shadowOffsetX, y1 + m_shadowOffsetY, m_width, m_height);
+        dc.DrawRectangle(WXROUND(x1 + m_shadowOffsetX), WXROUND(y1 + m_shadowOffsetY), WXROUND(m_width), WXROUND(m_height));

     }
 
     if (m_pen)
     {
       if (m_pen->GetWidth() == 0)
     }
 
     if (m_pen)
     {
       if (m_pen->GetWidth() == 0)

-        dc.SetPen(transparent_pen);
+        dc.SetPen(* g_oglTransparentPen);

       else
       else

-        dc.SetPen(m_pen);
+        dc.SetPen(* m_pen);

     }
     if (m_brush)
     }
     if (m_brush)

-      dc.SetBrush(m_brush);
+      dc.SetBrush(* m_brush);

 
     if (m_cornerRadius != 0.0)
 
     if (m_cornerRadius != 0.0)

-      dc.DrawRoundedRectangle(x1, y1, m_width, m_height, m_cornerRadius);
+      dc.DrawRoundedRectangle(WXROUND(x1), WXROUND(y1), WXROUND(m_width), WXROUND(m_height), m_cornerRadius);

     else
     else

-      dc.DrawRectangle(x1, y1, m_width, m_height);
+      dc.DrawRectangle(WXROUND(x1), WXROUND(y1), WXROUND(m_width), WXROUND(m_height));

 }
 
 }
 

-void wxRectangleShape::GetBoundingBoxMin(float *the_width, float *the_height)
+void wxRectangleShape::GetBoundingBoxMin(double *the_width, double *the_height)

 {
   *the_width = m_width;
   *the_height = m_height;
 }
 
 {
   *the_width = m_width;
   *the_height = m_height;
 }
 

-void wxRectangleShape::SetSize(float x, float y, bool recursive)
+void wxRectangleShape::SetSize(double x, double y, bool recursive)

 {
   SetAttachmentSize(x, y);
 {
   SetAttachmentSize(x, y);

-  m_width = (float)wxMax(x, 1.0);
-  m_height = (float)wxMax(y, 1.0);
+  m_width = (double)wxMax(x, 1.0);
+  m_height = (double)wxMax(y, 1.0);

   SetDefaultRegionSize();
 }
 
   SetDefaultRegionSize();
 }
 

-void wxRectangleShape::SetCornerRadius(float rad)
+void wxRectangleShape::SetCornerRadius(double rad)

 {
   m_cornerRadius = rad;
 }
 
 // Assume (x1, y1) is centre of box (most generally, line end at box)
 {
   m_cornerRadius = rad;
 }
 
 // Assume (x1, y1) is centre of box (most generally, line end at box)

-bool wxRectangleShape::GetPerimeterPoint(float x1, float y1,
-                                     float x2, float y2,
-                                     float *x3, float *y3)
+bool wxRectangleShape::GetPerimeterPoint(double x1, double y1,
+                                     double x2, double y2,
+                                     double *x3, double *y3)

 {
 {

-  float bound_x, bound_y;
+  double bound_x, bound_y;

   GetBoundingBoxMax(&bound_x, &bound_y);
   GetBoundingBoxMax(&bound_x, &bound_y);

-  find_end_for_box(bound_x, bound_y, m_xpos, m_ypos, x2, y2, x3, y3);
+  oglFindEndForBox(bound_x, bound_y, m_xpos, m_ypos, x2, y2, x3, y3);

 
   return TRUE;
 }
 
 #ifdef PROLOGIO
 
   return TRUE;
 }
 
 #ifdef PROLOGIO

-void wxRectangleShape::WritePrologAttributes(wxExpr *clause)
+void wxRectangleShape::WriteAttributes(wxExpr *clause)

 {
 {

-  wxShape::WritePrologAttributes(clause);
+  wxShape::WriteAttributes(clause);

   clause->AddAttributeValue("x", m_xpos);
   clause->AddAttributeValue("y", m_ypos);
 
   clause->AddAttributeValue("x", m_xpos);
   clause->AddAttributeValue("y", m_ypos);
 


@@ -1008,9 +949,9 @@ void wxRectangleShape::WritePrologAttributes(wxExpr *clause)
     clause->AddAttributeValue("corner", m_cornerRadius);
 }
 
     clause->AddAttributeValue("corner", m_cornerRadius);
 }
 

-void wxRectangleShape::ReadPrologAttributes(wxExpr *clause)
+void wxRectangleShape::ReadAttributes(wxExpr *clause)

 {
 {

-  wxShape::ReadPrologAttributes(clause);
+  wxShape::ReadAttributes(clause);

   clause->AssignAttributeValue("width", &m_width);
   clause->AssignAttributeValue("height", &m_height);
   clause->AssignAttributeValue("corner", &m_cornerRadius);
   clause->AssignAttributeValue("width", &m_width);
   clause->AssignAttributeValue("height", &m_height);
   clause->AssignAttributeValue("corner", &m_cornerRadius);


@@ -1036,133 +977,25 @@ void wxRectangleShape::Copy(wxShape& copy)
   rectCopy.m_cornerRadius = m_cornerRadius;
 }
 
   rectCopy.m_cornerRadius = m_cornerRadius;
 }
 

-int wxRectangleShape::GetNumberOfAttachments()
+int wxRectangleShape::GetNumberOfAttachments() const

 {
   return wxShape::GetNumberOfAttachments();
 }
 
 {
   return wxShape::GetNumberOfAttachments();
 }
 

+

 // There are 4 attachment points on a rectangle - 0 = top, 1 = right, 2 = bottom,
 // 3 = left.
 // There are 4 attachment points on a rectangle - 0 = top, 1 = right, 2 = bottom,
 // 3 = left.

-bool wxRectangleShape::GetAttachmentPosition(int attachment, float *x, float *y,
+bool wxRectangleShape::GetAttachmentPosition(int attachment, double *x, double *y,

                                          int nth, int no_arcs, wxLineShape *line)
 {
                                          int nth, int no_arcs, wxLineShape *line)
 {

-  if (m_attachmentMode)
-  {
-    float top = (float)(m_ypos + m_height/2.0);
-    float bottom = (float)(m_ypos - m_height/2.0);
-    float left = (float)(m_xpos - m_width/2.0);
-    float right = (float)(m_xpos + m_width/2.0);
-
-    bool isEnd = (line && line->IsEnd(this));
-
-    switch (attachment)
-    {
-      case 0:
-      {
-        if (m_spaceAttachments)
-        {
-          if (line && (line->GetAlignmentType(isEnd) == LINE_ALIGNMENT_TO_NEXT_HANDLE))
-          {
-            // Align line according to the next handle along
-            wxRealPoint *point = line->GetNextControlPoint(this);
-            if (point->x < left)
-              *x = left;
-            else if (point->x > right)
-              *x = right;
-            else
-              *x = point->x;
-          }
-          else
-            *x = left + (nth + 1)*m_width/(no_arcs + 1);
-        }
-        else *x = m_xpos;
-
-        *y = bottom;
-        break;
-      }
-      case 1:
-      {
-        *x = right;
-        if (m_spaceAttachments)
-        {
-          if (line && (line->GetAlignmentType(isEnd) == LINE_ALIGNMENT_TO_NEXT_HANDLE))
-          {
-            // Align line according to the next handle along
-            wxRealPoint *point = line->GetNextControlPoint(this);
-            if (point->y < bottom)
-              *y = bottom;
-            else if (point->y > top)
-              *y = top;
-            else
-              *y = point->y;
-          }
-          else
-            *y = bottom + (nth + 1)*m_height/(no_arcs + 1);
-        }
-        else *y = m_ypos;
-        break;
-      }
-      case 2:
-      {
-        if (m_spaceAttachments)
-        {
-          if (line && (line->GetAlignmentType(isEnd) == LINE_ALIGNMENT_TO_NEXT_HANDLE))
-          {
-            // Align line according to the next handle along
-            wxRealPoint *point = line->GetNextControlPoint(this);
-            if (point->x < left)
-              *x = left;
-            else if (point->x > right)
-              *x = right;
-            else
-              *x = point->x;
-          }
-          else
-            *x = left + (nth + 1)*m_width/(no_arcs + 1);
-        }
-        else *x = m_xpos;
-        *y = top;
-        break;
-      }
-      case 3:
-      {
-        *x = left;
-        if (m_spaceAttachments)
-        {
-          if (line && (line->GetAlignmentType(isEnd) == LINE_ALIGNMENT_TO_NEXT_HANDLE))
-          {
-            // Align line according to the next handle along
-            wxRealPoint *point = line->GetNextControlPoint(this);
-            if (point->y < bottom)
-              *y = bottom;
-            else if (point->y > top)
-              *y = top;
-            else
-              *y = point->y;
-          }
-          else
-            *y = bottom + (nth + 1)*m_height/(no_arcs + 1);
-        }
-        else *y = m_ypos;
-        break;
-      }
-      default:
-      {
-        return wxShape::GetAttachmentPosition(attachment, x, y, nth, no_arcs, line);
-        break;
-      }
-    }
-    return TRUE;
-  }
-  else
-  { *x = m_xpos; *y = m_ypos; return TRUE; }
+    return wxShape::GetAttachmentPosition(attachment, x, y, nth, no_arcs, line);

 }
 
 // Text object (no box)
 
 IMPLEMENT_DYNAMIC_CLASS(wxTextShape, wxRectangleShape)
 
 }
 
 // Text object (no box)
 
 IMPLEMENT_DYNAMIC_CLASS(wxTextShape, wxRectangleShape)
 

-wxTextShape::wxTextShape(float width, float height):
+wxTextShape::wxTextShape(double width, double height):

   wxRectangleShape(width, height)
 {
 }
   wxRectangleShape(width, height)
 {
 }


@@ -1177,9 +1010,9 @@ void wxTextShape::Copy(wxShape& copy)
 }
 
 #ifdef PROLOGIO
 }
 
 #ifdef PROLOGIO

-void wxTextShape::WritePrologAttributes(wxExpr *clause)
+void wxTextShape::WriteAttributes(wxExpr *clause)

 {
 {

-  wxRectangleShape::WritePrologAttributes(clause);
+  wxRectangleShape::WriteAttributes(clause);

 }
 #endif
 
 }
 #endif
 


@@ -1187,26 +1020,26 @@ void wxTextShape::WritePrologAttributes(wxExpr *clause)
 
 IMPLEMENT_DYNAMIC_CLASS(wxEllipseShape, wxShape)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxEllipseShape, wxShape)
 

-wxEllipseShape::wxEllipseShape(float w, float h)
+wxEllipseShape::wxEllipseShape(double w, double h)

 {
   m_width = w; m_height = h;
   SetDefaultRegionSize();
 }
 
 {
   m_width = w; m_height = h;
   SetDefaultRegionSize();
 }
 

-void wxEllipseShape::GetBoundingBoxMin(float *w, float *h)
+void wxEllipseShape::GetBoundingBoxMin(double *w, double *h)

 {
   *w = m_width; *h = m_height;
 }
 
 {
   *w = m_width; *h = m_height;
 }
 

-bool wxEllipseShape::GetPerimeterPoint(float x1, float y1,
-                                      float x2, float y2,
-                                      float *x3, float *y3)
+bool wxEllipseShape::GetPerimeterPoint(double x1, double y1,
+                                      double x2, double y2,
+                                      double *x3, double *y3)

 {
 {

-  float bound_x, bound_y;
+  double bound_x, bound_y;

   GetBoundingBoxMax(&bound_x, &bound_y);
 
   GetBoundingBoxMax(&bound_x, &bound_y);
 

-//  find_end_for_box(bound_x, bound_y, m_xpos, m_ypos, x2, y2, x3, y3);
-  draw_arc_to_ellipse(m_xpos, m_ypos, bound_x, bound_y, x2, y2, x1, y1, x3, y3);
+//  oglFindEndForBox(bound_x, bound_y, m_xpos, m_ypos, x2, y2, x3, y3);
+  oglDrawArcToEllipse(m_xpos, m_ypos, bound_x, bound_y, x2, y2, x1, y1, x3, y3);

 
   return TRUE;
 }
 
   return TRUE;
 }


@@ -1216,26 +1049,26 @@ void wxEllipseShape::OnDraw(wxDC& dc)
     if (m_shadowMode != SHADOW_NONE)
     {
       if (m_shadowBrush)
     if (m_shadowMode != SHADOW_NONE)
     {
       if (m_shadowBrush)

-        dc.SetBrush(m_shadowBrush);
-      dc.SetPen(transparent_pen);
-      dc.DrawEllipse((m_xpos - GetWidth()/2) + m_shadowOffsetX,
-                      (m_ypos - GetHeight()/2) + m_shadowOffsetY,
-                      GetWidth(), GetHeight());
+        dc.SetBrush(* m_shadowBrush);
+      dc.SetPen(* g_oglTransparentPen);
+      dc.DrawEllipse((long) ((m_xpos - GetWidth()/2) + m_shadowOffsetX),
+                      (long) ((m_ypos - GetHeight()/2) + m_shadowOffsetY),
+                      (long) GetWidth(), (long) GetHeight());

     }
 
     if (m_pen)
     {
       if (m_pen->GetWidth() == 0)
     }
 
     if (m_pen)
     {
       if (m_pen->GetWidth() == 0)

-        dc.SetPen(transparent_pen);
+        dc.SetPen(* g_oglTransparentPen);

       else
       else

-        dc.SetPen(m_pen);
+        dc.SetPen(* m_pen);

     }
     if (m_brush)
     }
     if (m_brush)

-      dc.SetBrush(m_brush);
-    dc.DrawEllipse((m_xpos - GetWidth()/2), (m_ypos - GetHeight()/2), GetWidth(), GetHeight());
+      dc.SetBrush(* m_brush);
+    dc.DrawEllipse((long) (m_xpos - GetWidth()/2), (long) (m_ypos - GetHeight()/2), (long) GetWidth(), (long) GetHeight());

 }
 
 }
 

-void wxEllipseShape::SetSize(float x, float y, bool recursive)
+void wxEllipseShape::SetSize(double x, double y, bool recursive)

 {
   SetAttachmentSize(x, y);
   m_width = x;
 {
   SetAttachmentSize(x, y);
   m_width = x;


@@ -1244,9 +1077,9 @@ void wxEllipseShape::SetSize(float x, float y, bool recursive)
 }
 
 #ifdef PROLOGIO
 }
 
 #ifdef PROLOGIO

-void wxEllipseShape::WritePrologAttributes(wxExpr *clause)
+void wxEllipseShape::WriteAttributes(wxExpr *clause)

 {
 {

-  wxShape::WritePrologAttributes(clause);
+  wxShape::WriteAttributes(clause);

   clause->AddAttributeValue("x", m_xpos);
   clause->AddAttributeValue("y", m_ypos);
 
   clause->AddAttributeValue("x", m_xpos);
   clause->AddAttributeValue("y", m_ypos);
 


@@ -1254,9 +1087,9 @@ void wxEllipseShape::WritePrologAttributes(wxExpr *clause)
   clause->AddAttributeValue("height", m_height);
 }
 
   clause->AddAttributeValue("height", m_height);
 }
 

-void wxEllipseShape::ReadPrologAttributes(wxExpr *clause)
+void wxEllipseShape::ReadAttributes(wxExpr *clause)

 {
 {

-  wxShape::ReadPrologAttributes(clause);
+  wxShape::ReadAttributes(clause);

   clause->AssignAttributeValue("width", &m_width);
   clause->AssignAttributeValue("height", &m_height);
 
   clause->AssignAttributeValue("width", &m_width);
   clause->AssignAttributeValue("height", &m_height);
 


@@ -1281,23 +1114,29 @@ void wxEllipseShape::Copy(wxShape& copy)
   ellipseCopy.m_height = m_height;
 }
 
   ellipseCopy.m_height = m_height;
 }
 

-int wxEllipseShape::GetNumberOfAttachments()
+int wxEllipseShape::GetNumberOfAttachments() const

 {
   return wxShape::GetNumberOfAttachments();
 }
 
 // There are 4 attachment points on an ellipse - 0 = top, 1 = right, 2 = bottom,
 // 3 = left.
 {
   return wxShape::GetNumberOfAttachments();
 }
 
 // There are 4 attachment points on an ellipse - 0 = top, 1 = right, 2 = bottom,
 // 3 = left.

-bool wxEllipseShape::GetAttachmentPosition(int attachment, float *x, float *y,
+bool wxEllipseShape::GetAttachmentPosition(int attachment, double *x, double *y,

                                          int nth, int no_arcs, wxLineShape *line)
 {
                                          int nth, int no_arcs, wxLineShape *line)
 {

-  if (m_attachmentMode)
+  if (m_attachmentMode == ATTACHMENT_MODE_BRANCHING)
+    return wxShape::GetAttachmentPosition(attachment, x, y, nth, no_arcs, line);
+
+  if (m_attachmentMode != ATTACHMENT_MODE_NONE)

   {
   {

-    float top = (float)(m_ypos + m_height/2.0);
-    float bottom = (float)(m_ypos - m_height/2.0);
-    float left = (float)(m_xpos - m_width/2.0);
-    float right = (float)(m_xpos + m_width/2.0);
-    switch (attachment)
+    double top = (double)(m_ypos + m_height/2.0);
+    double bottom = (double)(m_ypos - m_height/2.0);
+    double left = (double)(m_xpos - m_width/2.0);
+    double right = (double)(m_xpos + m_width/2.0);
+
+    int physicalAttachment = LogicalToPhysicalAttachment(attachment);
+
+    switch (physicalAttachment)

     {
       case 0:
       {
     {
       case 0:
       {


@@ -1308,7 +1147,7 @@ bool wxEllipseShape::GetAttachmentPosition(int attachment, float *x, float *y,
         // We now have the point on the bounding box: but get the point on the ellipse
         // by imagining a vertical line from (*x, m_ypos - m_height- 500) to (*x, m_ypos) intersecting
         // the ellipse.
         // We now have the point on the bounding box: but get the point on the ellipse
         // by imagining a vertical line from (*x, m_ypos - m_height- 500) to (*x, m_ypos) intersecting
         // the ellipse.

-        draw_arc_to_ellipse(m_xpos, m_ypos, m_width, m_height, *x, (float)(m_ypos-m_height-500), *x, m_ypos, x, y);
+        oglDrawArcToEllipse(m_xpos, m_ypos, m_width, m_height, *x, (double)(m_ypos-m_height-500), *x, m_ypos, x, y);

         break;
       }
       case 1:
         break;
       }
       case 1:


@@ -1317,7 +1156,7 @@ bool wxEllipseShape::GetAttachmentPosition(int attachment, float *x, float *y,
         if (m_spaceAttachments)
           *y = bottom + (nth + 1)*m_height/(no_arcs + 1);
         else *y = m_ypos;
         if (m_spaceAttachments)
           *y = bottom + (nth + 1)*m_height/(no_arcs + 1);
         else *y = m_ypos;

-        draw_arc_to_ellipse(m_xpos, m_ypos, m_width, m_height, (float)(m_xpos+m_width+500), *y, m_xpos, *y, x, y);
+        oglDrawArcToEllipse(m_xpos, m_ypos, m_width, m_height, (double)(m_xpos+m_width+500), *y, m_xpos, *y, x, y);

         break;
       }
       case 2:
         break;
       }
       case 2:


@@ -1326,7 +1165,7 @@ bool wxEllipseShape::GetAttachmentPosition(int attachment, float *x, float *y,
           *x = left + (nth + 1)*m_width/(no_arcs + 1);
         else *x = m_xpos;
         *y = bottom;
           *x = left + (nth + 1)*m_width/(no_arcs + 1);
         else *x = m_xpos;
         *y = bottom;

-        draw_arc_to_ellipse(m_xpos, m_ypos, m_width, m_height, *x, (float)(m_ypos+m_height+500), *x, m_ypos, x, y);
+        oglDrawArcToEllipse(m_xpos, m_ypos, m_width, m_height, *x, (double)(m_ypos+m_height+500), *x, m_ypos, x, y);

         break;
       }
       case 3:
         break;
       }
       case 3:


@@ -1335,7 +1174,7 @@ bool wxEllipseShape::GetAttachmentPosition(int attachment, float *x, float *y,
         if (m_spaceAttachments)
           *y = bottom + (nth + 1)*m_height/(no_arcs + 1);
         else *y = m_ypos;
         if (m_spaceAttachments)
           *y = bottom + (nth + 1)*m_height/(no_arcs + 1);
         else *y = m_ypos;

-        draw_arc_to_ellipse(m_xpos, m_ypos, m_width, m_height, (float)(m_xpos-m_width-500), *y, m_xpos, *y, x, y);
+        oglDrawArcToEllipse(m_xpos, m_ypos, m_width, m_height, (double)(m_xpos-m_width-500), *y, m_xpos, *y, x, y);

         break;
       }
       default:
         break;
       }
       default:


@@ -1354,8 +1193,9 @@ bool wxEllipseShape::GetAttachmentPosition(int attachment, float *x, float *y,
 // Circle object
 IMPLEMENT_DYNAMIC_CLASS(wxCircleShape, wxEllipseShape)
 
 // Circle object
 IMPLEMENT_DYNAMIC_CLASS(wxCircleShape, wxEllipseShape)
 

-wxCircleShape::wxCircleShape(float diameter):wxEllipseShape(diameter, diameter)
+wxCircleShape::wxCircleShape(double diameter):wxEllipseShape(diameter, diameter)

 {
 {

+    SetMaintainAspectRatio(TRUE);

 }
 
 void wxCircleShape::Copy(wxShape& copy)
 }
 
 void wxCircleShape::Copy(wxShape& copy)


@@ -1363,11 +1203,11 @@ void wxCircleShape::Copy(wxShape& copy)
   wxEllipseShape::Copy(copy);
 }
 
   wxEllipseShape::Copy(copy);
 }
 

-bool wxCircleShape::GetPerimeterPoint(float x1, float y1,
-                                      float x2, float y2,
-                                      float *x3, float *y3)
+bool wxCircleShape::GetPerimeterPoint(double x1, double y1,
+                                      double x2, double y2,
+                                      double *x3, double *y3)

 {
 {

-  find_end_for_circle(m_width/2, 
+  oglFindEndForCircle(m_width/2, 

                       m_xpos, m_ypos,  // Centre of circle
                       x2, y2,  // Other end of line
                       x3, y3);
                       m_xpos, m_ypos,  // Centre of circle
                       x2, y2,  // Other end of line
                       x3, y3);


@@ -1377,25 +1217,25 @@ bool wxCircleShape::GetPerimeterPoint(float x1, float y1,
 
 // Control points
 
 
 // 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;
+double wxControlPoint::sm_controlPointDragStartX = 0.0;
+double wxControlPoint::sm_controlPointDragStartY = 0.0;
+double wxControlPoint::sm_controlPointDragStartWidth = 0.0;
+double wxControlPoint::sm_controlPointDragStartHeight = 0.0;
+double wxControlPoint::sm_controlPointDragEndWidth = 0.0;
+double wxControlPoint::sm_controlPointDragEndHeight = 0.0;
+double wxControlPoint::sm_controlPointDragPosX = 0.0;
+double wxControlPoint::sm_controlPointDragPosY = 0.0;

 
 IMPLEMENT_DYNAMIC_CLASS(wxControlPoint, wxRectangleShape)
 
 
 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)
+wxControlPoint::wxControlPoint(wxShapeCanvas *theCanvas, wxShape *object, double size, double the_xoffset, double the_yoffset, int the_type):wxRectangleShape(size, size)

 {
   m_canvas = theCanvas;
   m_shape = object;
   m_xoffset = the_xoffset;
   m_yoffset = the_yoffset;
   m_type = the_type;
 {
   m_canvas = theCanvas;
   m_shape = object;
   m_xoffset = the_xoffset;
   m_yoffset = the_yoffset;
   m_type = the_type;

-  SetPen(black_foreground_pen);
+  SetPen(g_oglBlackForegroundPen);

   SetBrush(wxBLACK_BRUSH);
   m_oldCursor = NULL;
   m_visible = TRUE;
   SetBrush(wxBLACK_BRUSH);
   m_oldCursor = NULL;
   m_visible = TRUE;


@@ -1424,27 +1264,27 @@ void wxControlPoint::OnErase(wxDC& dc)
 }
 
 // Implement resizing of canvas object
 }
 
 // Implement resizing of canvas object

-void wxControlPoint::OnDragLeft(bool draw, float x, float y, int keys, int attachment)
+void wxControlPoint::OnDragLeft(bool draw, double x, double y, int keys, int attachment)

 {
     m_shape->GetEventHandler()->OnSizingDragLeft(this, draw, x, y, keys, attachment);
 }
 
 {
     m_shape->GetEventHandler()->OnSizingDragLeft(this, draw, x, y, keys, attachment);
 }
 

-void wxControlPoint::OnBeginDragLeft(float x, float y, int keys, int attachment)
+void wxControlPoint::OnBeginDragLeft(double x, double y, int keys, int attachment)

 {
     m_shape->GetEventHandler()->OnSizingBeginDragLeft(this, x, y, keys, attachment);
 }
 
 {
     m_shape->GetEventHandler()->OnSizingBeginDragLeft(this, x, y, keys, attachment);
 }
 

-void wxControlPoint::OnEndDragLeft(float x, float y, int keys, int attachment)
+void wxControlPoint::OnEndDragLeft(double x, double y, int keys, int attachment)

 {
     m_shape->GetEventHandler()->OnSizingEndDragLeft(this, x, y, keys, attachment);
 }
 
 {
     m_shape->GetEventHandler()->OnSizingEndDragLeft(this, x, y, keys, attachment);
 }
 

-int wxControlPoint::GetNumberOfAttachments()
+int wxControlPoint::GetNumberOfAttachments() const

 {
   return 1;
 }
 
 {
   return 1;
 }
 

-bool wxControlPoint::GetAttachmentPosition(int attachment, float *x, float *y,
+bool wxControlPoint::GetAttachmentPosition(int attachment, double *x, double *y,

                                          int nth, int no_arcs, wxLineShape *line)
 {
   *x = m_xpos; *y = m_ypos;
                                          int nth, int no_arcs, wxLineShape *line)
 {
   *x = m_xpos; *y = m_ypos;


@@ -1453,10 +1293,10 @@ bool wxControlPoint::GetAttachmentPosition(int attachment, float *x, float *y,
 
 // Control points ('handles') redirect control to the actual shape, to make it easier
 // to override sizing behaviour.
 
 // 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)
+void wxShape::OnSizingDragLeft(wxControlPoint* pt, bool draw, double x, double y, int keys, int attachment)

 {
 {

-  float bound_x;
-  float bound_y;
+  double bound_x;
+  double bound_y;

   this->GetBoundingBoxMin(&bound_x, &bound_y);
 
   wxClientDC dc(GetCanvas());
   this->GetBoundingBoxMin(&bound_x, &bound_y);
 
   wxClientDC dc(GetCanvas());


@@ -1471,14 +1311,28 @@ void wxShape::OnSizingDragLeft(wxControlPoint* pt, bool draw, float x, float y,
   if (this->GetCentreResize())
   {
     // Maintain the same centre point.
   if (this->GetCentreResize())
   {
     // Maintain the same centre point.

-    float new_width = (float)(2.0*fabs(x - this->GetX()));
-    float new_height = (float)(2.0*fabs(y - this->GetY()));
+    double new_width = (double)(2.0*fabs(x - this->GetX()));
+    double new_height = (double)(2.0*fabs(y - this->GetY()));

 
     // Constrain sizing according to what control point you're dragging
     if (pt->m_type == CONTROL_POINT_HORIZONTAL)
 
     // Constrain sizing according to what control point you're dragging
     if (pt->m_type == CONTROL_POINT_HORIZONTAL)

-      new_height = bound_y;
+    {
+        if (GetMaintainAspectRatio())
+        {
+            new_height = bound_y*(new_width/bound_x);
+        }
+        else
+            new_height = bound_y;
+    }

     else if (pt->m_type == CONTROL_POINT_VERTICAL)
     else if (pt->m_type == CONTROL_POINT_VERTICAL)

-      new_width = bound_x;
+    {
+        if (GetMaintainAspectRatio())
+        {
+            new_width = bound_x*(new_height/bound_y);
+        }
+        else
+            new_width = bound_x;
+    }

     else if (pt->m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
       new_height = bound_y*(new_width/bound_x);
 
     else if (pt->m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
       new_height = bound_y*(new_width/bound_x);
 


@@ -1488,8 +1342,8 @@ void wxShape::OnSizingDragLeft(wxControlPoint* pt, bool draw, float x, float y,
     if (this->GetFixedHeight())
       new_height = bound_y;
 
     if (this->GetFixedHeight())
       new_height = bound_y;
 

-    pt->controlPointDragEndWidth = new_width;
-    pt->controlPointDragEndHeight = new_height;
+    pt->sm_controlPointDragEndWidth = new_width;
+    pt->sm_controlPointDragEndHeight = new_height;

 
     this->GetEventHandler()->OnDrawOutline(dc, this->GetX(), this->GetY(),
                                 new_width, new_height);
 
     this->GetEventHandler()->OnDrawOutline(dc, this->GetX(), this->GetY(),
                                 new_width, new_height);


@@ -1497,81 +1351,92 @@ void wxShape::OnSizingDragLeft(wxControlPoint* pt, bool draw, float x, float y,
   else
   {
     // Don't maintain the same centre point!
   else
   {
     // Don't maintain the same centre point!

-    float newX1 = wxMin(pt->controlPointDragStartX, x);
-    float newY1 = wxMin(pt->controlPointDragStartY, y);
-    float newX2 = wxMax(pt->controlPointDragStartX, x);
-    float newY2 = wxMax(pt->controlPointDragStartY, y);
+    double newX1 = wxMin(pt->sm_controlPointDragStartX, x);
+    double newY1 = wxMin(pt->sm_controlPointDragStartY, y);
+    double newX2 = wxMax(pt->sm_controlPointDragStartX, x);
+    double newY2 = wxMax(pt->sm_controlPointDragStartY, y);

     if (pt->m_type == CONTROL_POINT_HORIZONTAL)
     {
     if (pt->m_type == CONTROL_POINT_HORIZONTAL)
     {

-      newY1 = pt->controlPointDragStartY;
-      newY2 = newY1 + pt->controlPointDragStartHeight;
+      newY1 = pt->sm_controlPointDragStartY;
+      newY2 = newY1 + pt->sm_controlPointDragStartHeight;

     }
     else if (pt->m_type == CONTROL_POINT_VERTICAL)
     {
     }
     else if (pt->m_type == CONTROL_POINT_VERTICAL)
     {

-      newX1 = pt->controlPointDragStartX;
-      newX2 = newX1 + pt->controlPointDragStartWidth;
+      newX1 = pt->sm_controlPointDragStartX;
+      newX2 = newX1 + pt->sm_controlPointDragStartWidth;

     }
     }

-    else if (pt->m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
+    else if (pt->m_type == CONTROL_POINT_DIAGONAL && ((keys & KEY_SHIFT) || GetMaintainAspectRatio()))

     {
     {

-      float newH = (float)((newX2 - newX1)*(pt->controlPointDragStartHeight/pt->controlPointDragStartWidth));
-      if (GetY() > pt->controlPointDragStartY)
-        newY2 = (float)(newY1 + newH);
+      double newH = (double)((newX2 - newX1)*(pt->sm_controlPointDragStartHeight/pt->sm_controlPointDragStartWidth));
+      if (GetY() > pt->sm_controlPointDragStartY)
+        newY2 = (double)(newY1 + newH);

       else
       else

-        newY1 = (float)(newY2 - newH);
+        newY1 = (double)(newY2 - newH);
+    }
+    double newWidth = (double)(newX2 - newX1);
+    double newHeight = (double)(newY2 - newY1);
+
+    if (pt->m_type == CONTROL_POINT_VERTICAL && GetMaintainAspectRatio())
+    {
+        newWidth = bound_x * (newHeight/bound_y) ;
+    }
+
+    if (pt->m_type == CONTROL_POINT_HORIZONTAL && GetMaintainAspectRatio())
+    {
+        newHeight = bound_y * (newWidth/bound_x) ;

     }
     }

-    float newWidth = (float)(newX2 - newX1);
-    float newHeight = (float)(newY2 - newY1);

 
 

-    pt->controlPointDragPosX = (float)(newX1 + (newWidth/2.0));
-    pt->controlPointDragPosY = (float)(newY1 + (newHeight/2.0));
+    pt->sm_controlPointDragPosX = (double)(newX1 + (newWidth/2.0));
+    pt->sm_controlPointDragPosY = (double)(newY1 + (newHeight/2.0));

     if (this->GetFixedWidth())
       newWidth = bound_x;
      
     if (this->GetFixedHeight())
       newHeight = bound_y;
 
     if (this->GetFixedWidth())
       newWidth = bound_x;
      
     if (this->GetFixedHeight())
       newHeight = bound_y;
 

-    pt->controlPointDragEndWidth = newWidth;
-    pt->controlPointDragEndHeight = newHeight;
-    this->GetEventHandler()->OnDrawOutline(dc, pt->controlPointDragPosX, pt->controlPointDragPosY, newWidth, newHeight);
+    pt->sm_controlPointDragEndWidth = newWidth;
+    pt->sm_controlPointDragEndHeight = newHeight;
+    this->GetEventHandler()->OnDrawOutline(dc, pt->sm_controlPointDragPosX, pt->sm_controlPointDragPosY, newWidth, newHeight);

   }
 }
 
   }
 }
 

-void wxShape::OnSizingBeginDragLeft(wxControlPoint* pt, float x, float y, int keys, int attachment)
+void wxShape::OnSizingBeginDragLeft(wxControlPoint* pt, double x, double y, int keys, int attachment)

 {
   m_canvas->CaptureMouse();
 
   wxClientDC dc(GetCanvas());
   GetCanvas()->PrepareDC(dc);
 {
   m_canvas->CaptureMouse();
 
   wxClientDC dc(GetCanvas());
   GetCanvas()->PrepareDC(dc);

-
+/*

   if (pt->m_eraseObject)
     this->Erase(dc);
   if (pt->m_eraseObject)
     this->Erase(dc);

+*/

 
   dc.SetLogicalFunction(wxXOR);
 
 
   dc.SetLogicalFunction(wxXOR);
 

-  float bound_x;
-  float bound_y;
+  double bound_x;
+  double 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 (pt->GetX() < this->GetX())
   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 (pt->GetX() < this->GetX())

-    pt->controlPointDragStartX = (float)(this->GetX() + (bound_x/2.0));
+    pt->sm_controlPointDragStartX = (double)(this->GetX() + (bound_x/2.0));

   else
   else

-    pt->controlPointDragStartX = (float)(this->GetX() - (bound_x/2.0));
+    pt->sm_controlPointDragStartX = (double)(this->GetX() - (bound_x/2.0));

 
   if (pt->GetY() < this->GetY())
 
   if (pt->GetY() < this->GetY())

-    pt->controlPointDragStartY = (float)(this->GetY() + (bound_y/2.0));
+    pt->sm_controlPointDragStartY = (double)(this->GetY() + (bound_y/2.0));

   else
   else

-    pt->controlPointDragStartY = (float)(this->GetY() - (bound_y/2.0));
+    pt->sm_controlPointDragStartY = (double)(this->GetY() - (bound_y/2.0));

 
   if (pt->m_type == CONTROL_POINT_HORIZONTAL)
 
   if (pt->m_type == CONTROL_POINT_HORIZONTAL)

-    pt->controlPointDragStartY = (float)(this->GetY() - (bound_y/2.0));
+    pt->sm_controlPointDragStartY = (double)(this->GetY() - (bound_y/2.0));

   else if (pt->m_type == CONTROL_POINT_VERTICAL)
   else if (pt->m_type == CONTROL_POINT_VERTICAL)

-    pt->controlPointDragStartX = (float)(this->GetX() - (bound_x/2.0));
+    pt->sm_controlPointDragStartX = (double)(this->GetX() - (bound_x/2.0));

 
   // We may require the old width and height.
 
   // We may require the old width and height.

-  pt->controlPointDragStartWidth = bound_x;
-  pt->controlPointDragStartHeight = bound_y;
+  pt->sm_controlPointDragStartWidth = bound_x;
+  pt->sm_controlPointDragStartHeight = bound_y;

 
   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
   dc.SetPen(dottedPen);
 
   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
   dc.SetPen(dottedPen);


@@ -1579,14 +1444,28 @@ void wxShape::OnSizingBeginDragLeft(wxControlPoint* pt, float x, float y, int ke
 
   if (this->GetCentreResize())
   {
 
   if (this->GetCentreResize())
   {

-    float new_width = (float)(2.0*fabs(x - this->GetX()));
-    float new_height = (float)(2.0*fabs(y - this->GetY()));
+    double new_width = (double)(2.0*fabs(x - this->GetX()));
+    double new_height = (double)(2.0*fabs(y - this->GetY()));

 
     // Constrain sizing according to what control point you're dragging
     if (pt->m_type == CONTROL_POINT_HORIZONTAL)
 
     // Constrain sizing according to what control point you're dragging
     if (pt->m_type == CONTROL_POINT_HORIZONTAL)

-      new_height = bound_y;
+    {
+        if (GetMaintainAspectRatio())
+        {
+            new_height = bound_y*(new_width/bound_x);
+        }
+        else
+            new_height = bound_y;
+    }

     else if (pt->m_type == CONTROL_POINT_VERTICAL)
     else if (pt->m_type == CONTROL_POINT_VERTICAL)

-      new_width = bound_x;
+    {
+        if (GetMaintainAspectRatio())
+        {
+            new_width = bound_x*(new_height/bound_y);
+        }
+        else
+            new_width = bound_x;
+    }

     else if (pt->m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
       new_height = bound_y*(new_width/bound_x);
 
     else if (pt->m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
       new_height = bound_y*(new_width/bound_x);
 


@@ -1596,54 +1475,64 @@ void wxShape::OnSizingBeginDragLeft(wxControlPoint* pt, float x, float y, int ke
     if (this->GetFixedHeight())
       new_height = bound_y;
 
     if (this->GetFixedHeight())
       new_height = bound_y;
 

-    pt->controlPointDragEndWidth = new_width;
-    pt->controlPointDragEndHeight = new_height;
+    pt->sm_controlPointDragEndWidth = new_width;
+    pt->sm_controlPointDragEndHeight = new_height;

     this->GetEventHandler()->OnDrawOutline(dc, this->GetX(), this->GetY(),
                                 new_width, new_height);
   }
   else
   {
     // Don't maintain the same centre point!
     this->GetEventHandler()->OnDrawOutline(dc, this->GetX(), this->GetY(),
                                 new_width, new_height);
   }
   else
   {
     // Don't maintain the same centre point!

-    float newX1 = wxMin(pt->controlPointDragStartX, x);
-    float newY1 = wxMin(pt->controlPointDragStartY, y);
-    float newX2 = wxMax(pt->controlPointDragStartX, x);
-    float newY2 = wxMax(pt->controlPointDragStartY, y);
+    double newX1 = wxMin(pt->sm_controlPointDragStartX, x);
+    double newY1 = wxMin(pt->sm_controlPointDragStartY, y);
+    double newX2 = wxMax(pt->sm_controlPointDragStartX, x);
+    double newY2 = wxMax(pt->sm_controlPointDragStartY, y);

     if (pt->m_type == CONTROL_POINT_HORIZONTAL)
     {
     if (pt->m_type == CONTROL_POINT_HORIZONTAL)
     {

-      newY1 = pt->controlPointDragStartY;
-      newY2 = newY1 + pt->controlPointDragStartHeight;
+      newY1 = pt->sm_controlPointDragStartY;
+      newY2 = newY1 + pt->sm_controlPointDragStartHeight;

     }
     else if (pt->m_type == CONTROL_POINT_VERTICAL)
     {
     }
     else if (pt->m_type == CONTROL_POINT_VERTICAL)
     {

-      newX1 = pt->controlPointDragStartX;
-      newX2 = newX1 + pt->controlPointDragStartWidth;
+      newX1 = pt->sm_controlPointDragStartX;
+      newX2 = newX1 + pt->sm_controlPointDragStartWidth;

     }
     }

-    else if (pt->m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
+    else if (pt->m_type == CONTROL_POINT_DIAGONAL && ((keys & KEY_SHIFT) || GetMaintainAspectRatio()))

     {
     {

-      float newH = (float)((newX2 - newX1)*(pt->controlPointDragStartHeight/pt->controlPointDragStartWidth));
-      if (pt->GetY() > pt->controlPointDragStartY)
-        newY2 = (float)(newY1 + newH);
+      double newH = (double)((newX2 - newX1)*(pt->sm_controlPointDragStartHeight/pt->sm_controlPointDragStartWidth));
+      if (pt->GetY() > pt->sm_controlPointDragStartY)
+        newY2 = (double)(newY1 + newH);

       else
       else

-        newY1 = (float)(newY2 - newH);
+        newY1 = (double)(newY2 - newH);
+    }
+    double newWidth = (double)(newX2 - newX1);
+    double newHeight = (double)(newY2 - newY1);
+
+    if (pt->m_type == CONTROL_POINT_VERTICAL && GetMaintainAspectRatio())
+    {
+        newWidth = bound_x * (newHeight/bound_y) ;

     }
     }

-    float newWidth = (float)(newX2 - newX1);
-    float newHeight = (float)(newY2 - newY1);

 
 

-    pt->controlPointDragPosX = (float)(newX1 + (newWidth/2.0));
-    pt->controlPointDragPosY = (float)(newY1 + (newHeight/2.0));
+    if (pt->m_type == CONTROL_POINT_HORIZONTAL && GetMaintainAspectRatio())
+    {
+        newHeight = bound_y * (newWidth/bound_x) ;
+    }
+
+    pt->sm_controlPointDragPosX = (double)(newX1 + (newWidth/2.0));
+    pt->sm_controlPointDragPosY = (double)(newY1 + (newHeight/2.0));

     if (this->GetFixedWidth())
       newWidth = bound_x;
 
     if (this->GetFixedHeight())
       newHeight = bound_y;
 
     if (this->GetFixedWidth())
       newWidth = bound_x;
 
     if (this->GetFixedHeight())
       newHeight = bound_y;
 

-    pt->controlPointDragEndWidth = newWidth;
-    pt->controlPointDragEndHeight = newHeight;
-    this->GetEventHandler()->OnDrawOutline(dc, pt->controlPointDragPosX, pt->controlPointDragPosY, newWidth, newHeight);
+    pt->sm_controlPointDragEndWidth = newWidth;
+    pt->sm_controlPointDragEndHeight = newHeight;
+    this->GetEventHandler()->OnDrawOutline(dc, pt->sm_controlPointDragPosX, pt->sm_controlPointDragPosY, newWidth, newHeight);

   }
 }
 
   }
 }
 

-void wxShape::OnSizingEndDragLeft(wxControlPoint* pt, float x, float y, int keys, int attachment)
+void wxShape::OnSizingEndDragLeft(wxControlPoint* pt, double x, double y, int keys, int attachment)

 {
   wxClientDC dc(GetCanvas());
   GetCanvas()->PrepareDC(dc);
 {
   wxClientDC dc(GetCanvas());
   GetCanvas()->PrepareDC(dc);


@@ -1653,10 +1542,13 @@ void wxShape::OnSizingEndDragLeft(wxControlPoint* pt, float x, float y, int keys
   this->Recompute();
   this->ResetControlPoints();
 
   this->Recompute();
   this->ResetControlPoints();
 

+  this->Erase(dc);
+/*

   if (!pt->m_eraseObject)
     this->Show(FALSE);
   if (!pt->m_eraseObject)
     this->Show(FALSE);

+*/

 
 

-  this->SetSize(pt->controlPointDragEndWidth, pt->controlPointDragEndHeight);
+  this->SetSize(pt->sm_controlPointDragEndWidth, pt->sm_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
 
   // 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


@@ -1668,16 +1560,18 @@ void wxShape::OnSizingEndDragLeft(wxControlPoint* pt, float x, float y, int keys
   if (theObject->GetCentreResize())
     theObject->Move(dc, theObject->GetX(), theObject->GetY());
   else
   if (theObject->GetCentreResize())
     theObject->Move(dc, theObject->GetX(), theObject->GetY());
   else

-    theObject->Move(dc, pt->controlPointDragPosX, pt->controlPointDragPosY);
+    theObject->Move(dc, pt->sm_controlPointDragPosX, pt->sm_controlPointDragPosY);

 
 

+/*

   if (!eraseIt)
     theObject->Show(TRUE);
   if (!eraseIt)
     theObject->Show(TRUE);

+*/

     
   // Recursively redraw links if we have a composite.
   if (theObject->GetChildren().Number() > 0)
     theObject->DrawLinks(dc, -1, TRUE);
     
     
   // Recursively redraw links if we have a composite.
   if (theObject->GetChildren().Number() > 0)
     theObject->DrawLinks(dc, -1, TRUE);
     

-  float width, height;
+  double width, height;

   theObject->GetBoundingBoxMax(&width, &height);
   theObject->GetEventHandler()->OnEndSize(width, height);
 
   theObject->GetBoundingBoxMax(&width, &height);
   theObject->GetEventHandler()->OnEndSize(width, height);
 


@@ -1690,8 +1584,8 @@ void wxShape::OnSizingEndDragLeft(wxControlPoint* pt, float x, float y, int keys
 
 IMPLEMENT_DYNAMIC_CLASS(wxPolygonControlPoint, wxControlPoint)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxPolygonControlPoint, wxControlPoint)
 

-wxPolygonControlPoint::wxPolygonControlPoint(wxShapeCanvas *theCanvas, wxShape *object, float size,
-  wxRealPoint *vertex, float the_xoffset, float the_yoffset):
+wxPolygonControlPoint::wxPolygonControlPoint(wxShapeCanvas *theCanvas, wxShape *object, double size,
+  wxRealPoint *vertex, double the_xoffset, double the_yoffset):

   wxControlPoint(theCanvas, object, size, the_xoffset, the_yoffset, 0)
 {
   m_polygonVertex = vertex;
   wxControlPoint(theCanvas, object, size, the_xoffset, the_yoffset, 0)
 {
   m_polygonVertex = vertex;


@@ -1703,39 +1597,39 @@ wxPolygonControlPoint::~wxPolygonControlPoint()
 }
 
 // Calculate what new size would be, at end of resize
 }
 
 // Calculate what new size would be, at end of resize

-void wxPolygonControlPoint::CalculateNewSize(float x, float y)
+void wxPolygonControlPoint::CalculateNewSize(double x, double y)

 {
 {

-  float bound_x;
-  float bound_y;
+  double bound_x;
+  double bound_y;

   GetShape()->GetBoundingBoxMin(&bound_x, &bound_y);
 
   GetShape()->GetBoundingBoxMin(&bound_x, &bound_y);
 

-  float dist = (float)sqrt((x - m_shape->GetX())*(x - m_shape->GetX()) +
+  double dist = (double)sqrt((x - m_shape->GetX())*(x - m_shape->GetX()) +

                     (y - m_shape->GetY())*(y - m_shape->GetY()));
 
                     (y - m_shape->GetY())*(y - m_shape->GetY()));
 

-  m_newSize.x = (float)(dist/this->m_originalDistance)*this->m_originalSize.x;
-  m_newSize.y = (float)(dist/this->m_originalDistance)*this->m_originalSize.y;
+  m_newSize.x = (double)(dist/this->m_originalDistance)*this->m_originalSize.x;
+  m_newSize.y = (double)(dist/this->m_originalDistance)*this->m_originalSize.y;

 }
 
 
 // Implement resizing polygon or moving the vertex.
 }
 
 
 // Implement resizing polygon or moving the vertex.

-void wxPolygonControlPoint::OnDragLeft(bool draw, float x, float y, int keys, int attachment)
+void wxPolygonControlPoint::OnDragLeft(bool draw, double x, double y, int keys, int attachment)

 {
     m_shape->GetEventHandler()->OnSizingDragLeft(this, draw, x, y, keys, attachment);
 }
 
 {
     m_shape->GetEventHandler()->OnSizingDragLeft(this, draw, x, y, keys, attachment);
 }
 

-void wxPolygonControlPoint::OnBeginDragLeft(float x, float y, int keys, int attachment)
+void wxPolygonControlPoint::OnBeginDragLeft(double x, double y, int keys, int attachment)

 {
     m_shape->GetEventHandler()->OnSizingBeginDragLeft(this, x, y, keys, attachment);
 }
 
 {
     m_shape->GetEventHandler()->OnSizingBeginDragLeft(this, x, y, keys, attachment);
 }
 

-void wxPolygonControlPoint::OnEndDragLeft(float x, float y, int keys, int attachment)
+void wxPolygonControlPoint::OnEndDragLeft(double x, double 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.
 {
     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)
+void wxPolygonShape::OnSizingDragLeft(wxControlPoint* pt, bool draw, double x, double y, int keys, int attachment)

 {
   wxPolygonControlPoint* ppt = (wxPolygonControlPoint*) pt;
 
 {
   wxPolygonControlPoint* ppt = (wxPolygonControlPoint*) pt;
 


@@ -1772,7 +1666,7 @@ void wxPolygonShape::OnSizingDragLeft(wxControlPoint* pt, bool draw, float x, fl
        ppt->GetNewSize().x, ppt->GetNewSize().y);
 }
 
        ppt->GetNewSize().x, ppt->GetNewSize().y);
 }
 

-void wxPolygonShape::OnSizingBeginDragLeft(wxControlPoint* pt, float x, float y, int keys, int attachment)
+void wxPolygonShape::OnSizingBeginDragLeft(wxControlPoint* pt, double x, double y, int keys, int attachment)

 {
   wxPolygonControlPoint* ppt = (wxPolygonControlPoint*) pt;
 
 {
   wxPolygonControlPoint* ppt = (wxPolygonControlPoint*) pt;
 


@@ -1783,17 +1677,17 @@ void wxPolygonShape::OnSizingBeginDragLeft(wxControlPoint* pt, float x, float y,
 
   dc.SetLogicalFunction(wxXOR);
 
 
   dc.SetLogicalFunction(wxXOR);
 

-  float bound_x;
-  float bound_y;
+  double bound_x;
+  double bound_y;

   this->GetBoundingBoxMin(&bound_x, &bound_y);
 
   this->GetBoundingBoxMin(&bound_x, &bound_y);
 

-  float dist = (float)sqrt((x - this->GetX())*(x - this->GetX()) +
+  double dist = (double)sqrt((x - this->GetX())*(x - this->GetX()) +

                     (y - this->GetY())*(y - this->GetY()));
   ppt->m_originalDistance = dist;
   ppt->m_originalSize.x = bound_x;
   ppt->m_originalSize.y = bound_y;
 
                     (y - this->GetY())*(y - this->GetY()));
   ppt->m_originalDistance = dist;
   ppt->m_originalSize.x = bound_x;
   ppt->m_originalSize.y = bound_y;
 

-  if (ppt->m_originalDistance == 0.0) ppt->m_originalDistance = (float) 0.0001;
+  if (ppt->m_originalDistance == 0.0) ppt->m_originalDistance = (double) 0.0001;

 
   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
   dc.SetPen(dottedPen);
 
   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
   dc.SetPen(dottedPen);


@@ -1825,7 +1719,7 @@ void wxPolygonShape::OnSizingBeginDragLeft(wxControlPoint* pt, float x, float y,
   m_canvas->CaptureMouse();
 }
 
   m_canvas->CaptureMouse();
 }
 

-void wxPolygonShape::OnSizingEndDragLeft(wxControlPoint* pt, float x, float y, int keys, int attachment)
+void wxPolygonShape::OnSizingEndDragLeft(wxControlPoint* pt, double x, double y, int keys, int attachment)

 {
   wxPolygonControlPoint* ppt = (wxPolygonControlPoint*) pt;
 
 {
   wxPolygonControlPoint* ppt = (wxPolygonControlPoint*) pt;
 


@@ -1940,25 +1834,25 @@ void wxShapeRegion::SetFont(wxFont *f)
   m_font = f;
 }
 
   m_font = f;
 }
 

-void wxShapeRegion::SetMinSize(float w, float h)
+void wxShapeRegion::SetMinSize(double w, double h)

 {
   m_minWidth = w;
   m_minHeight = h;
 }
 
 {
   m_minWidth = w;
   m_minHeight = h;
 }
 

-void wxShapeRegion::SetSize(float w, float h)
+void wxShapeRegion::SetSize(double w, double h)

 {
   m_width = w;
   m_height = h;
 }
 
 {
   m_width = w;
   m_height = h;
 }
 

-void wxShapeRegion::SetPosition(float xp, float yp)
+void wxShapeRegion::SetPosition(double xp, double yp)

 {
   m_x = xp;
   m_y = yp;
 }
 
 {
   m_x = xp;
   m_y = yp;
 }
 

-void wxShapeRegion::SetProportions(float xp, float yp)
+void wxShapeRegion::SetProportions(double xp, double yp)

 {
   m_regionProportionX = xp;
   m_regionProportionY = yp;
 {
   m_regionProportionX = xp;
   m_regionProportionY = yp;