DECLARE_DYNAMIC_CLASS(wxDivisionControlPoint)
public:
wxDivisionControlPoint() {}
- wxDivisionControlPoint(wxShapeCanvas *the_canvas, wxShape *object, float size, float the_xoffset, float the_yoffset, int the_type);
+ wxDivisionControlPoint(wxShapeCanvas *the_canvas, wxShape *object, double size, double the_xoffset, double the_yoffset, int the_type);
~wxDivisionControlPoint();
- void OnDragLeft(bool draw, float x, float y, int keys=0, int attachment = 0);
- void OnBeginDragLeft(float x, float y, int keys=0, int attachment = 0);
- void OnEndDragLeft(float x, float y, int keys=0, int attachment = 0);
+ void OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
+ void OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
+ void OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
};
IMPLEMENT_DYNAMIC_CLASS(wxDivisionControlPoint, wxControlPoint)
void wxCompositeShape::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)
dc.SetBrush(m_shadowBrush);
- dc.SetPen(transparent_pen);
+ dc.SetPen(g_oglTransparentPen);
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
- 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));
}
}
wxShape::OnDrawContents(dc);
}
-bool wxCompositeShape::OnMovePre(wxDC& dc, float x, float y, float oldx, float oldy, bool display)
+bool wxCompositeShape::OnMovePre(wxDC& dc, double x, double y, double oldx, double oldy, bool display)
{
- float diffX = x - oldx;
- float diffY = y - oldy;
+ double diffX = x - oldx;
+ double diffY = y - oldy;
wxNode *node = m_children.First();
while (node)
{
}
}
-static float objectStartX = 0.0;
-static float objectStartY = 0.0;
+static double objectStartX = 0.0;
+static double objectStartY = 0.0;
-void wxCompositeShape::OnDragLeft(bool draw, float x, float y, int keys, int attachment)
+void wxCompositeShape::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
{
- float xx = x;
- float yy = y;
+ double xx = x;
+ double yy = y;
m_canvas->Snap(&xx, &yy);
- float offsetX = xx - objectStartX;
- float offsetY = yy - objectStartY;
+ double offsetX = xx - objectStartX;
+ double offsetY = yy - objectStartY;
wxClientDC dc(GetCanvas());
GetCanvas()->PrepareDC(dc);
// wxShape::OnDragLeft(draw, x, y, keys, attachment);
}
-void wxCompositeShape::OnBeginDragLeft(float x, float y, int keys, int attachment)
+void wxCompositeShape::OnBeginDragLeft(double x, double y, int keys, int attachment)
{
objectStartX = x;
objectStartY = y;
dc.SetBrush((* wxTRANSPARENT_BRUSH));
m_canvas->CaptureMouse();
- float xx = x;
- float yy = y;
+ double xx = x;
+ double yy = y;
m_canvas->Snap(&xx, &yy);
- float offsetX = xx - objectStartX;
- float offsetY = yy - objectStartY;
+ double offsetX = xx - objectStartX;
+ double offsetY = yy - objectStartY;
GetEventHandler()->OnDrawOutline(dc, GetX() + offsetX, GetY() + offsetY, GetWidth(), GetHeight());
// wxShape::OnBeginDragLeft(x, y, keys, attachment);
}
-void wxCompositeShape::OnEndDragLeft(float x, float y, int keys, int attachment)
+void wxCompositeShape::OnEndDragLeft(double x, double y, int keys, int attachment)
{
// wxShape::OnEndDragLeft(x, y, keys, attachment);
}
dc.SetLogicalFunction(wxCOPY);
- float xx = x;
- float yy = y;
+ double xx = x;
+ double yy = y;
m_canvas->Snap(&xx, &yy);
- float offsetX = xx - objectStartX;
- float offsetY = yy - objectStartY;
+ double offsetX = xx - objectStartX;
+ double offsetY = yy - objectStartY;
Move(dc, GetX() + offsetX, GetY() + offsetY);
if (m_canvas && !m_canvas->GetQuickEditMode()) m_canvas->Redraw(dc);
}
-void wxCompositeShape::OnRightClick(float x, float y, int keys, int attachment)
+void wxCompositeShape::OnRightClick(double x, double y, int keys, int attachment)
{
// If we get a ctrl-right click, this means send the message to
// the division, so we can invoke a user interface for dealing with regions.
wxDivisionShape *division = (wxDivisionShape *)node->Data();
wxNode *next = node->Next();
int attach = 0;
- float dist = 0.0;
+ double dist = 0.0;
if (division->HitTest(x, y, &attach, &dist))
{
division->GetEventHandler()->OnRightClick(x, y, keys, attach);
}
}
-void wxCompositeShape::SetSize(float w, float h, bool recursive)
+void wxCompositeShape::SetSize(double w, double h, bool recursive)
{
SetAttachmentSize(w, h);
- float xScale = (float)(w/(wxMax(1.0, GetWidth())));
- float yScale = (float)(h/(wxMax(1.0, GetHeight())));
+ double xScale = (double)(w/(wxMax(1.0, GetWidth())));
+ double yScale = (double)(h/(wxMax(1.0, GetHeight())));
m_width = w;
m_height = h;
wxClientDC dc(GetCanvas());
GetCanvas()->PrepareDC(dc);
- float xBound, yBound;
+ double xBound, yBound;
while (node)
{
wxShape *object = (wxShape *)node->Data();
// Scale the position first
- float newX = (float)(((object->GetX() - GetX())*xScale) + GetX());
- float newY = (float)(((object->GetY() - GetY())*yScale) + GetY());
+ double newX = (double)(((object->GetX() - GetX())*xScale) + GetX());
+ double newY = (double)(((object->GetY() - GetY())*yScale) + GetY());
object->Show(FALSE);
object->Move(dc, newX, newY);
object->Show(TRUE);
}
}
-void wxCompositeShape::Copy(wxCompositeShape& copy)
+void wxCompositeShape::Copy(wxShape& copy)
{
wxRectangleShape::Copy(copy);
- // Associate old and new copies for copying constraints and division geometry
- wxObjectCopyMapping.Append((long)this, ©);
+ wxASSERT( copy.IsKindOf(CLASSINFO(wxCompositeShape)) ) ;
+
+ wxCompositeShape& compositeCopy = (wxCompositeShape&) copy;
+
+ // Associate old and new copies for compositeCopying constraints and division geometry
+ oglObjectCopyMapping.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.m_children.Append(newObject);
+ newObject->SetParent(&compositeCopy);
+ 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);
+ oglObjectCopyMapping.Append((long)object, newObject);
node = node->Next();
}
{
OGLConstraint *constraint = (OGLConstraint *)node->Data();
- wxShape *newConstraining = (wxShape *)(wxObjectCopyMapping.Find((long)constraint->m_constrainingObject)->Data());
+ wxShape *newConstraining = (wxShape *)(oglObjectCopyMapping.Find((long)constraint->m_constrainingObject)->Data());
wxList newConstrainedList;
wxNode *node2 = constraint->m_constrainedObjects.First();
while (node2)
{
wxShape *constrainedObject = (wxShape *)node2->Data();
- wxShape *newConstrained = (wxShape *)(wxObjectCopyMapping.Find((long)constrainedObject)->Data());
+ wxShape *newConstrained = (wxShape *)(oglObjectCopyMapping.Find((long)constrainedObject)->Data());
newConstrainedList.Append(newConstrained);
node2 = node2->Next();
}
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)
{
wxDivisionShape *division = (wxDivisionShape *)node->Data();
- wxNode *node1 = wxObjectCopyMapping.Find((long)division);
+ wxNode *node1 = oglObjectCopyMapping.Find((long)division);
wxNode *leftNode = NULL;
wxNode *topNode = NULL;
wxNode *rightNode = NULL;
wxNode *bottomNode = NULL;
if (division->GetLeftSide())
- leftNode = wxObjectCopyMapping.Find((long)division->GetLeftSide());
+ leftNode = oglObjectCopyMapping.Find((long)division->GetLeftSide());
if (division->GetTopSide())
- topNode = wxObjectCopyMapping.Find((long)division->GetTopSide());
+ topNode = oglObjectCopyMapping.Find((long)division->GetTopSide());
if (division->GetRightSide())
- rightNode = wxObjectCopyMapping.Find((long)division->GetRightSide());
+ rightNode = oglObjectCopyMapping.Find((long)division->GetRightSide());
if (division->GetBottomSide())
- bottomNode = wxObjectCopyMapping.Find((long)division->GetBottomSide());
+ bottomNode = oglObjectCopyMapping.Find((long)division->GetBottomSide());
if (node1)
{
wxDivisionShape *newDivision = (wxDivisionShape *)node1->Data();
}
}
-wxShape *wxCompositeShape::PrivateCopy()
-{
- wxCompositeShape *obj = new wxCompositeShape;
- Copy(*obj);
- return obj;
-}
-
OGLConstraint *wxCompositeShape::AddConstraint(OGLConstraint *constraint)
{
m_constraints.Append(constraint);
void wxCompositeShape::CalculateSize()
{
- float maxX = (float) -999999.9;
- float maxY = (float) -999999.9;
- float minX = (float) 999999.9;
- float minY = (float) 999999.9;
+ double maxX = (double) -999999.9;
+ double maxY = (double) -999999.9;
+ double minX = (double) 999999.9;
+ double minY = (double) 999999.9;
- float w, h;
+ double w, h;
wxNode *node = m_children.First();
while (node)
{
object->GetBoundingBoxMax(&w, &h);
if ((object->GetX() + (w/2.0)) > maxX)
- maxX = (float)(object->GetX() + (w/2.0));
+ maxX = (double)(object->GetX() + (w/2.0));
if ((object->GetX() - (w/2.0)) < minX)
- minX = (float)(object->GetX() - (w/2.0));
+ minX = (double)(object->GetX() - (w/2.0));
if ((object->GetY() + (h/2.0)) > maxY)
- maxY = (float)(object->GetY() + (h/2.0));
+ maxY = (double)(object->GetY() + (h/2.0));
if ((object->GetY() - (h/2.0)) < minY)
- minY = (float)(object->GetY() - (h/2.0));
+ minY = (double)(object->GetY() - (h/2.0));
node = node->Next();
}
m_width = maxX - minX;
m_height = maxY - minY;
- m_xpos = (float)(m_width/2.0 + minX);
- m_ypos = (float)(m_height/2.0 + minY);
+ m_xpos = (double)(m_width/2.0 + minX);
+ m_ypos = (double)(m_height/2.0 + minY);
}
bool wxCompositeShape::Recompute()
break;
}
int cType = 0;
- float cXSpacing = 0.0;
- float cYSpacing = 0.0;
+ double cXSpacing = 0.0;
+ double cYSpacing = 0.0;
wxString cName("");
long cId = 0;
wxShape *m_constrainingObject = NULL;
dc.SetBrush(wxTRANSPARENT_BRUSH);
dc.SetBackgroundMode(wxTRANSPARENT);
- float x1 = (float)(GetX() - (GetWidth()/2.0));
- float y1 = (float)(GetY() - (GetHeight()/2.0));
- float x2 = (float)(GetX() + (GetWidth()/2.0));
- float y2 = (float)(GetY() + (GetHeight()/2.0));
+ double x1 = (double)(GetX() - (GetWidth()/2.0));
+ double y1 = (double)(GetY() - (GetHeight()/2.0));
+ double x2 = (double)(GetX() + (GetWidth()/2.0));
+ double y2 = (double)(GetY() + (GetHeight()/2.0));
// Should subtract 1 pixel if drawing under Windows
#ifdef __WXMSW__
- y2 -= (float)1.0;
+ y2 -= (double)1.0;
#endif
if (m_leftSide)
{
dc.SetPen(m_leftSidePen);
- dc.DrawLine(x1, y2, x1, y1);
+ dc.DrawLine(WXROUND(x1), WXROUND(y2), WXROUND(x1), WXROUND(y1));
}
if (m_topSide)
{
dc.SetPen(m_topSidePen);
- dc.DrawLine(x1, y1, x2, y1);
+ dc.DrawLine(WXROUND(x1), WXROUND(y1), WXROUND(x2), WXROUND(y1));
}
// For testing purposes, draw a rectangle so we know
wxCompositeShape::OnDrawContents(dc);
}
-bool wxDivisionShape::OnMovePre(wxDC& dc, float x, float y, float oldx, float oldy, bool display)
+bool wxDivisionShape::OnMovePre(wxDC& dc, double x, double y, double oldx, double oldy, bool display)
{
- float diffX = x - oldx;
- float diffY = y - oldy;
+ double diffX = x - oldx;
+ double diffY = y - oldy;
wxNode *node = m_children.First();
while (node)
{
return TRUE;
}
-void wxDivisionShape::OnDragLeft(bool draw, float x, float y, int keys, int attachment)
+void wxDivisionShape::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
{
if ((m_sensitivity & OP_DRAG_LEFT) != OP_DRAG_LEFT)
{
attachment = 0;
- float dist;
+ double dist;
if (m_parent)
{
m_parent->HitTest(x, y, &attachment, &dist);
wxShape::OnDragLeft(draw, x, y, keys, attachment);
}
-void wxDivisionShape::OnBeginDragLeft(float x, float y, int keys, int attachment)
+void wxDivisionShape::OnBeginDragLeft(double x, double y, int keys, int attachment)
{
if ((m_sensitivity & OP_DRAG_LEFT) != OP_DRAG_LEFT)
{
attachment = 0;
- float dist;
+ double dist;
if (m_parent)
{
m_parent->HitTest(x, y, &attachment, &dist);
wxShape::OnBeginDragLeft(x, y, keys, attachment);
}
-void wxDivisionShape::OnEndDragLeft(float x, float y, int keys, int attachment)
+void wxDivisionShape::OnEndDragLeft(double x, double y, int keys, int attachment)
{
m_canvas->ReleaseMouse();
if ((m_sensitivity & OP_DRAG_LEFT) != OP_DRAG_LEFT)
{
attachment = 0;
- float dist;
+ double dist;
if (m_parent)
{
m_parent->HitTest(x, y, &attachment, &dist);
if (m_canvas && !m_canvas->GetQuickEditMode()) m_canvas->Redraw(dc);
}
-void wxDivisionShape::SetSize(float w, float h, bool recursive)
+void wxDivisionShape::SetSize(double w, double h, bool recursive)
{
m_width = w;
m_height = h;
{
}
-void wxDivisionShape::Copy(wxDivisionShape& copy)
+void wxDivisionShape::Copy(wxShape& copy)
{
wxCompositeShape::Copy(copy);
- copy.m_leftSideStyle = m_leftSideStyle;
- copy.m_topSideStyle = m_topSideStyle;
- copy.m_leftSideColour = m_leftSideColour;
- copy.m_topSideColour = m_topSideColour;
+ wxASSERT( copy.IsKindOf(CLASSINFO(wxDivisionShape)) ) ;
- copy.m_leftSidePen = m_leftSidePen;
- copy.m_topSidePen = m_topSidePen;
- copy.m_handleSide = m_handleSide;
+ wxDivisionShape& divisionCopy = (wxDivisionShape&) copy;
- // Division geometry copying is handled at the wxCompositeShape level.
-}
+ divisionCopy.m_leftSideStyle = m_leftSideStyle;
+ divisionCopy.m_topSideStyle = m_topSideStyle;
+ divisionCopy.m_leftSideColour = m_leftSideColour;
+ divisionCopy.m_topSideColour = m_topSideColour;
-wxShape *wxDivisionShape::PrivateCopy()
-{
- wxDivisionShape *obj = new wxDivisionShape;
- Copy(*obj);
- return obj;
+ divisionCopy.m_leftSidePen = m_leftSidePen;
+ divisionCopy.m_topSidePen = m_topSidePen;
+ divisionCopy.m_handleSide = m_handleSide;
+
+ // Division geometry copying is handled at the wxCompositeShape level.
}
#ifdef PROLOGIO
#endif
// Experimental
-void wxDivisionShape::OnRightClick(float x, float y, int keys, int attachment)
+void wxDivisionShape::OnRightClick(double x, double y, int keys, int attachment)
{
if (keys & KEY_CTRL)
{
else
{
attachment = 0;
- float dist;
+ double dist;
if (m_parent)
{
m_parent->HitTest(x, y, &attachment, &dist);
bool wxDivisionShape::Divide(int direction)
{
// Calculate existing top-left, bottom-right
- float x1 = (float)(GetX() - (GetWidth()/2.0));
- float y1 = (float)(GetY() - (GetHeight()/2.0));
+ double x1 = (double)(GetX() - (GetWidth()/2.0));
+ double y1 = (double)(GetY() - (GetHeight()/2.0));
wxCompositeShape *compositeParent = (wxCompositeShape *)GetParent();
- float oldWidth = GetWidth();
- float oldHeight = GetHeight();
+ double oldWidth = GetWidth();
+ double oldHeight = GetHeight();
if (Selected())
Select(FALSE);
{
// Dividing vertically means notionally putting a horizontal line through it.
// Break existing piece into two.
- float newXPos1 = GetX();
- float newYPos1 = (float)(y1 + (GetHeight()/4.0));
- float newXPos2 = GetX();
- float newYPos2 = (float)(y1 + (3.0*GetHeight()/4.0));
+ double newXPos1 = GetX();
+ double newYPos1 = (double)(y1 + (GetHeight()/4.0));
+ double newXPos2 = GetX();
+ double newYPos2 = (double)(y1 + (3.0*GetHeight()/4.0));
wxDivisionShape *newDivision = compositeParent->OnCreateDivision();
newDivision->Show(TRUE);
m_handleSide = DIVISION_SIDE_BOTTOM;
newDivision->SetHandleSide(DIVISION_SIDE_TOP);
- SetSize(oldWidth, (float)(oldHeight/2.0));
+ SetSize(oldWidth, (double)(oldHeight/2.0));
Move(dc, newXPos1, newYPos1);
- newDivision->SetSize(oldWidth, (float)(oldHeight/2.0));
+ newDivision->SetSize(oldWidth, (double)(oldHeight/2.0));
newDivision->Move(dc, newXPos2, newYPos2);
}
else
{
// Dividing horizontally means notionally putting a vertical line through it.
// Break existing piece into two.
- float newXPos1 = (float)(x1 + (GetWidth()/4.0));
- float newYPos1 = GetY();
- float newXPos2 = (float)(x1 + (3.0*GetWidth()/4.0));
- float newYPos2 = GetY();
+ double newXPos1 = (double)(x1 + (GetWidth()/4.0));
+ double newYPos1 = GetY();
+ double newXPos2 = (double)(x1 + (3.0*GetWidth()/4.0));
+ double newYPos2 = GetY();
wxDivisionShape *newDivision = compositeParent->OnCreateDivision();
newDivision->Show(TRUE);
m_handleSide = DIVISION_SIDE_RIGHT;
newDivision->SetHandleSide(DIVISION_SIDE_LEFT);
- SetSize((float)(oldWidth/2.0), oldHeight);
+ SetSize((double)(oldWidth/2.0), oldHeight);
Move(dc, newXPos1, newYPos1);
- newDivision->SetSize((float)(oldWidth/2.0), oldHeight);
+ newDivision->SetSize((double)(oldWidth/2.0), oldHeight);
newDivision->Move(dc, newXPos2, newYPos2);
}
if (compositeParent->Selected())
void wxDivisionShape::MakeMandatoryControlPoints()
{
- float maxX, maxY;
+ double maxX, maxY;
GetBoundingBoxMax(&maxX, &maxY);
- float x, y;
+ double x, y;
int direction;
/*
if (m_leftSide)
{
- x = (float)(-maxX/2.0);
+ x = (double)(-maxX/2.0);
y = 0.0;
wxDivisionControlPoint *control = new wxDivisionControlPoint(m_canvas, this, CONTROL_POINT_SIZE, x, y,
CONTROL_POINT_HORIZONTAL);
if (m_topSide)
{
x = 0.0;
- y = (float)(-maxY/2.0);
+ y = (double)(-maxY/2.0);
wxDivisionControlPoint *control = new wxDivisionControlPoint(m_canvas, this, CONTROL_POINT_SIZE, x, y,
CONTROL_POINT_VERTICAL);
m_canvas->AddShape(control);
{
case DIVISION_SIDE_LEFT:
{
- x = (float)(-maxX/2.0);
+ x = (double)(-maxX/2.0);
y = 0.0;
direction = CONTROL_POINT_HORIZONTAL;
break;
case DIVISION_SIDE_TOP:
{
x = 0.0;
- y = (float)(-maxY/2.0);
+ y = (double)(-maxY/2.0);
direction = CONTROL_POINT_VERTICAL;
break;
}
case DIVISION_SIDE_RIGHT:
{
- x = (float)(maxX/2.0);
+ x = (double)(maxX/2.0);
y = 0.0;
direction = CONTROL_POINT_HORIZONTAL;
break;
case DIVISION_SIDE_BOTTOM:
{
x = 0.0;
- y = (float)(maxY/2.0);
+ y = (double)(maxY/2.0);
direction = CONTROL_POINT_VERTICAL;
break;
}
if (m_controlPoints.Number() < 1)
return;
- float maxX, maxY;
+ double maxX, maxY;
GetBoundingBoxMax(&maxX, &maxY);
/*
wxDivisionControlPoint *control = (wxDivisionControlPoint *)node->Data();
if (control->type == CONTROL_POINT_HORIZONTAL)
{
- control->xoffset = (float)(-maxX/2.0); control->m_yoffset = 0.0;
+ control->xoffset = (double)(-maxX/2.0); control->m_yoffset = 0.0;
}
else if (control->type == CONTROL_POINT_VERTICAL)
{
- control->xoffset = 0.0; control->m_yoffset = (float)(-maxY/2.0);
+ control->xoffset = 0.0; control->m_yoffset = (double)(-maxY/2.0);
}
node = node->Next();
}
if ((m_handleSide == DIVISION_SIDE_LEFT) && node)
{
wxDivisionControlPoint *control = (wxDivisionControlPoint *)node->Data();
- control->m_xoffset = (float)(-maxX/2.0); control->m_yoffset = 0.0;
+ control->m_xoffset = (double)(-maxX/2.0); control->m_yoffset = 0.0;
}
if ((m_handleSide == DIVISION_SIDE_TOP) && node)
{
wxDivisionControlPoint *control = (wxDivisionControlPoint *)node->Data();
- control->m_xoffset = 0.0; control->m_yoffset = (float)(-maxY/2.0);
+ control->m_xoffset = 0.0; control->m_yoffset = (double)(-maxY/2.0);
}
if ((m_handleSide == DIVISION_SIDE_RIGHT) && node)
{
wxDivisionControlPoint *control = (wxDivisionControlPoint *)node->Data();
- control->m_xoffset = (float)(maxX/2.0); control->m_yoffset = 0.0;
+ control->m_xoffset = (double)(maxX/2.0); control->m_yoffset = 0.0;
}
if ((m_handleSide == DIVISION_SIDE_BOTTOM) && node)
{
wxDivisionControlPoint *control = (wxDivisionControlPoint *)node->Data();
- control->m_xoffset = 0.0; control->m_yoffset = (float)(maxY/2.0);
+ control->m_xoffset = 0.0; control->m_yoffset = (double)(maxY/2.0);
}
}
// Adjust a side, returning FALSE if it's not physically possible.
-bool wxDivisionShape::AdjustLeft(float left, bool test)
+bool wxDivisionShape::AdjustLeft(double left, bool test)
{
- float x2 = (float)(GetX() + (GetWidth()/2.0));
+ double x2 = (double)(GetX() + (GetWidth()/2.0));
if (left >= x2)
return FALSE;
if (test)
return TRUE;
- float newW = x2 - left;
- float newX = (float)(left + newW/2.0);
+ double newW = x2 - left;
+ double newX = (double)(left + newW/2.0);
SetSize(newW, GetHeight());
wxClientDC dc(GetCanvas());
return TRUE;
}
-bool wxDivisionShape::AdjustTop(float top, bool test)
+bool wxDivisionShape::AdjustTop(double top, bool test)
{
- float y2 = (float)(GetY() + (GetHeight()/2.0));
+ double y2 = (double)(GetY() + (GetHeight()/2.0));
if (top >= y2)
return FALSE;
if (test)
return TRUE;
- float newH = y2 - top;
- float newY = (float)(top + newH/2.0);
+ double newH = y2 - top;
+ double newY = (double)(top + newH/2.0);
SetSize(GetWidth(), newH);
wxClientDC dc(GetCanvas());
return TRUE;
}
-bool wxDivisionShape::AdjustRight(float right, bool test)
+bool wxDivisionShape::AdjustRight(double right, bool test)
{
- float x1 = (float)(GetX() - (GetWidth()/2.0));
+ double x1 = (double)(GetX() - (GetWidth()/2.0));
if (right <= x1)
return FALSE;
if (test)
return TRUE;
- float newW = right - x1;
- float newX = (float)(x1 + newW/2.0);
+ double newW = right - x1;
+ double newX = (double)(x1 + newW/2.0);
SetSize(newW, GetHeight());
wxClientDC dc(GetCanvas());
return TRUE;
}
-bool wxDivisionShape::AdjustBottom(float bottom, bool test)
+bool wxDivisionShape::AdjustBottom(double bottom, bool test)
{
- float y1 = (float)(GetY() - (GetHeight()/2.0));
+ double y1 = (double)(GetY() - (GetHeight()/2.0));
if (bottom <= y1)
return FALSE;
if (test)
return TRUE;
- float newH = bottom - y1;
- float newY = (float)(y1 + newH/2.0);
+ double newH = bottom - y1;
+ double newY = (double)(y1 + newH/2.0);
SetSize(GetWidth(), newH);
wxClientDC dc(GetCanvas());
return TRUE;
}
-wxDivisionControlPoint::wxDivisionControlPoint(wxShapeCanvas *the_canvas, wxShape *object, float size, float the_xoffset, float the_yoffset, int the_type):
+wxDivisionControlPoint::wxDivisionControlPoint(wxShapeCanvas *the_canvas, wxShape *object, double size, double the_xoffset, double the_yoffset, int the_type):
wxControlPoint(the_canvas, object, size, the_xoffset, the_yoffset, the_type)
{
SetEraseObject(FALSE);
{
}
-static float originalX = 0.0;
-static float originalY = 0.0;
-static float originalW = 0.0;
-static float originalH = 0.0;
+static double originalX = 0.0;
+static double originalY = 0.0;
+static double originalW = 0.0;
+static double originalH = 0.0;
// Implement resizing of canvas object
-void wxDivisionControlPoint::OnDragLeft(bool draw, float x, float y, int keys, int attachment)
+void wxDivisionControlPoint::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
{
wxControlPoint::OnDragLeft(draw, x, y, keys, attachment);
}
-void wxDivisionControlPoint::OnBeginDragLeft(float x, float y, int keys, int attachment)
+void wxDivisionControlPoint::OnBeginDragLeft(double x, double y, int keys, int attachment)
{
wxDivisionShape *division = (wxDivisionShape *)m_shape;
originalX = division->GetX();
wxControlPoint::OnBeginDragLeft(x, y, keys, attachment);
}
-void wxDivisionControlPoint::OnEndDragLeft(float x, float y, int keys, int attachment)
+void wxDivisionControlPoint::OnEndDragLeft(double x, double y, int keys, int attachment)
{
wxControlPoint::OnEndDragLeft(x, y, keys, attachment);
wxCompositeShape *divisionParent = (wxCompositeShape *)division->GetParent();
// Need to check it's within the bounds of the parent composite.
- float x1 = (float)(divisionParent->GetX() - (divisionParent->GetWidth()/2.0));
- float y1 = (float)(divisionParent->GetY() - (divisionParent->GetHeight()/2.0));
- float x2 = (float)(divisionParent->GetX() + (divisionParent->GetWidth()/2.0));
- float y2 = (float)(divisionParent->GetY() + (divisionParent->GetHeight()/2.0));
+ double x1 = (double)(divisionParent->GetX() - (divisionParent->GetWidth()/2.0));
+ double y1 = (double)(divisionParent->GetY() - (divisionParent->GetHeight()/2.0));
+ double x2 = (double)(divisionParent->GetX() + (divisionParent->GetWidth()/2.0));
+ double y2 = (double)(divisionParent->GetY() + (divisionParent->GetHeight()/2.0));
// Need to check it has not made the division zero or negative width/height
- float dx1 = (float)(division->GetX() - (division->GetWidth()/2.0));
- float dy1 = (float)(division->GetY() - (division->GetHeight()/2.0));
- float dx2 = (float)(division->GetX() + (division->GetWidth()/2.0));
- float dy2 = (float)(division->GetY() + (division->GetHeight()/2.0));
+ double dx1 = (double)(division->GetX() - (division->GetWidth()/2.0));
+ double dy1 = (double)(division->GetY() - (division->GetHeight()/2.0));
+ double dx2 = (double)(division->GetX() + (division->GetWidth()/2.0));
+ double dy2 = (double)(division->GetY() + (division->GetHeight()/2.0));
bool success = TRUE;
switch (division->GetHandleSide())
If size goes to zero or end position is other side of start position,
resize to original size and return.
*/
-bool wxDivisionShape::ResizeAdjoining(int side, float newPos, bool test)
+bool wxDivisionShape::ResizeAdjoining(int side, double newPos, bool test)
{
wxCompositeShape *divisionParent = (wxCompositeShape *)GetParent();
wxNode *node = divisionParent->GetDivisions().First();
}
// Popup menu
-void wxDivisionShape::PopupMenu(float x, float y)
+void wxDivisionShape::PopupMenu(double x, double y)
{
oglPopupDivisionMenu->SetClientData((char *)this);
if (m_leftSide)
projects / wxWidgets.git / blobdiff