[wxWidgets.git] / contrib / src / ogl / constrnt.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        constrnt.cpp
// Purpose:     OGL Constraint classes
// Author:      Julian Smart
// Modified by:
// Created:     12/07/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "constrnt.h"
#endif

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

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif

#include <wx/wxexpr.h>

#include <wx/ogl/basic.h>
#include <wx/ogl/constrnt.h>
#include <wx/ogl/canvas.h>

wxList *wxOGLConstraintTypes = NULL;

/*
 * Constraint type
 *
 */

IMPLEMENT_DYNAMIC_CLASS(wxOGLConstraintType, wxObject)

wxOGLConstraintType::wxOGLConstraintType(int theType, const wxString& theName, const wxString& thePhrase)
{
  m_type = theType;
  m_name = theName;
  m_phrase = thePhrase;
}

wxOGLConstraintType::~wxOGLConstraintType()
{
}

void OGLInitializeConstraintTypes()
{
    if (!wxOGLConstraintTypes)
        return;

    wxOGLConstraintTypes = new wxList(wxKEY_INTEGER);

    wxOGLConstraintTypes->Append(gyCONSTRAINT_CENTRED_VERTICALLY,
        new wxOGLConstraintType(gyCONSTRAINT_CENTRED_VERTICALLY, "Centre vertically", "centred vertically w.r.t."));

    wxOGLConstraintTypes->Append(gyCONSTRAINT_CENTRED_HORIZONTALLY,
        new wxOGLConstraintType(gyCONSTRAINT_CENTRED_HORIZONTALLY, "Centre horizontally", "centred horizontally w.r.t."));

    wxOGLConstraintTypes->Append(gyCONSTRAINT_CENTRED_BOTH,
        new wxOGLConstraintType(gyCONSTRAINT_CENTRED_BOTH, "Centre", "centred w.r.t."));

    wxOGLConstraintTypes->Append(gyCONSTRAINT_LEFT_OF,
        new wxOGLConstraintType(gyCONSTRAINT_LEFT_OF, "Left of", "left of"));

    wxOGLConstraintTypes->Append(gyCONSTRAINT_RIGHT_OF,
        new wxOGLConstraintType(gyCONSTRAINT_RIGHT_OF, "Right of", "right of"));

    wxOGLConstraintTypes->Append(gyCONSTRAINT_ABOVE,
        new wxOGLConstraintType(gyCONSTRAINT_ABOVE, "Above", "above"));

    wxOGLConstraintTypes->Append(gyCONSTRAINT_BELOW,
        new wxOGLConstraintType(gyCONSTRAINT_BELOW, "Below", "below"));

    // Alignment
    wxOGLConstraintTypes->Append(gyCONSTRAINT_ALIGNED_TOP,
        new wxOGLConstraintType(gyCONSTRAINT_ALIGNED_TOP, "Top-aligned", "aligned to the top of"));

    wxOGLConstraintTypes->Append(gyCONSTRAINT_ALIGNED_BOTTOM,
        new wxOGLConstraintType(gyCONSTRAINT_ALIGNED_BOTTOM, "Bottom-aligned", "aligned to the bottom of"));

    wxOGLConstraintTypes->Append(gyCONSTRAINT_ALIGNED_LEFT,
        new wxOGLConstraintType(gyCONSTRAINT_ALIGNED_LEFT, "Left-aligned", "aligned to the left of"));

    wxOGLConstraintTypes->Append(gyCONSTRAINT_ALIGNED_RIGHT,
        new wxOGLConstraintType(gyCONSTRAINT_ALIGNED_RIGHT, "Right-aligned", "aligned to the right of"));

    // Mid-alignment
    wxOGLConstraintTypes->Append(gyCONSTRAINT_MIDALIGNED_TOP,
        new wxOGLConstraintType(gyCONSTRAINT_MIDALIGNED_TOP, "Top-midaligned", "centred on the top of"));

    wxOGLConstraintTypes->Append(gyCONSTRAINT_MIDALIGNED_BOTTOM,
        new wxOGLConstraintType(gyCONSTRAINT_MIDALIGNED_BOTTOM, "Bottom-midaligned", "centred on the bottom of"));

    wxOGLConstraintTypes->Append(gyCONSTRAINT_MIDALIGNED_LEFT,
        new wxOGLConstraintType(gyCONSTRAINT_MIDALIGNED_LEFT, "Left-midaligned", "centred on the left of"));

    wxOGLConstraintTypes->Append(gyCONSTRAINT_MIDALIGNED_RIGHT,
        new wxOGLConstraintType(gyCONSTRAINT_MIDALIGNED_RIGHT, "Right-midaligned", "centred on the right of"));
}

void OGLCleanUpConstraintTypes()
{
    if (!wxOGLConstraintTypes)
        return;

    wxNode* node = wxOGLConstraintTypes->First();
    while (node)
    {
        wxOGLConstraintType* ct = (wxOGLConstraintType*) node->Data();
        delete ct;
        node = node->Next();
    }
    delete wxOGLConstraintTypes;
    wxOGLConstraintTypes = NULL;
}

/*
 * Constraint Stuff
 *
 */

IMPLEMENT_DYNAMIC_CLASS(wxOGLConstraint, wxObject)

wxOGLConstraint::wxOGLConstraint(int type, wxShape *constraining, wxList& constrained)
{
  m_xSpacing = 0.0;
  m_ySpacing = 0.0;

  m_constraintType = type;
  m_constrainingObject = constraining;

  m_constraintId = 0;
  m_constraintName = "noname";

  wxNode *node = constrained.First();
  while (node)
  {
    m_constrainedObjects.Append(node->Data());
    node = node->Next();
  }
}

wxOGLConstraint::~wxOGLConstraint()
{
}

bool wxOGLConstraint::Equals(double a, double b)
{
  double marg = 0.5;

  bool eq = ((b <= a + marg) && (b >= a - marg));
  return eq;
}

// Return TRUE if anything changed
bool wxOGLConstraint::Evaluate()
{
  double maxWidth, maxHeight, minWidth, minHeight, x, y;
  m_constrainingObject->GetBoundingBoxMax(&maxWidth, &maxHeight);
  m_constrainingObject->GetBoundingBoxMin(&minWidth, &minHeight);
  x = m_constrainingObject->GetX();
  y = m_constrainingObject->GetY();

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

  switch (m_constraintType)
  {
    case gyCONSTRAINT_CENTRED_VERTICALLY:
    {
      int n = m_constrainedObjects.Number();
      double totalObjectHeight = 0.0;
      wxNode *node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();

        double width2, height2;
        constrainedObject->GetBoundingBoxMax(&width2, &height2);
        totalObjectHeight += height2;
        node = node->Next();
      }
      double startY;
      double spacingY;
      // Check if within the constraining object...
      if ((totalObjectHeight + (n + 1)*m_ySpacing) <= minHeight)
      {
        spacingY = (double)((minHeight - totalObjectHeight)/(n + 1));
        startY = (double)(y - (minHeight/2.0));
      }
      // Otherwise, use default spacing
      else
      {
        spacingY = m_ySpacing;
        startY = (double)(y - ((totalObjectHeight + (n+1)*spacingY)/2.0));
      }

      // Now position the objects
      bool changed = FALSE;
      node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();
        double width2, height2;
        constrainedObject->GetBoundingBoxMax(&width2, &height2);
        startY += (double)(spacingY + (height2/2.0));
        if (!Equals(startY, constrainedObject->GetY()))
        {
          constrainedObject->Move(dc, constrainedObject->GetX(), startY, FALSE);
          changed = TRUE;
        }
        startY += (double)(height2/2.0);
        node = node->Next();
      }
      return changed;
    }
    case gyCONSTRAINT_CENTRED_HORIZONTALLY:
    {
      int n = m_constrainedObjects.Number();
      double totalObjectWidth = 0.0;
      wxNode *node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();

        double width2, height2;
        constrainedObject->GetBoundingBoxMax(&width2, &height2);
        totalObjectWidth += width2;
        node = node->Next();
      }
      double startX;
      double spacingX;
      // Check if within the constraining object...
      if ((totalObjectWidth + (n + 1)*m_xSpacing) <= minWidth)
      {
        spacingX = (double)((minWidth - totalObjectWidth)/(n + 1));
        startX = (double)(x - (minWidth/2.0));
      }
      // Otherwise, use default spacing
      else
      {
        spacingX = m_xSpacing;
        startX = (double)(x - ((totalObjectWidth + (n+1)*spacingX)/2.0));
      }

      // Now position the objects
      bool changed = FALSE;
      node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();
        double width2, height2;
        constrainedObject->GetBoundingBoxMax(&width2, &height2);
        startX += (double)(spacingX + (width2/2.0));
        if (!Equals(startX, constrainedObject->GetX()))
        {
          constrainedObject->Move(dc, startX, constrainedObject->GetY(), FALSE);
          changed = TRUE;
        }
        startX += (double)(width2/2.0);
        node = node->Next();
      }
      return changed;
    }
    case gyCONSTRAINT_CENTRED_BOTH:
    {
      int n = m_constrainedObjects.Number();
      double totalObjectWidth = 0.0;
      double totalObjectHeight = 0.0;
      wxNode *node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();

        double width2, height2;
        constrainedObject->GetBoundingBoxMax(&width2, &height2);
        totalObjectWidth += width2;
        totalObjectHeight += height2;
        node = node->Next();
      }
      double startX;
      double spacingX;
      double startY;
      double spacingY;

      // Check if within the constraining object...
      if ((totalObjectWidth + (n + 1)*m_xSpacing) <= minWidth)
      {
        spacingX = (double)((minWidth - totalObjectWidth)/(n + 1));
        startX = (double)(x - (minWidth/2.0));
      }
      // Otherwise, use default spacing
      else
      {
        spacingX = m_xSpacing;
        startX = (double)(x - ((totalObjectWidth + (n+1)*spacingX)/2.0));
      }

      // Check if within the constraining object...
      if ((totalObjectHeight + (n + 1)*m_ySpacing) <= minHeight)
      {
        spacingY = (double)((minHeight - totalObjectHeight)/(n + 1));
        startY = (double)(y - (minHeight/2.0));
      }
      // Otherwise, use default spacing
      else
      {
        spacingY = m_ySpacing;
        startY = (double)(y - ((totalObjectHeight + (n+1)*spacingY)/2.0));
      }

      // Now position the objects
      bool changed = FALSE;
      node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();
        double width2, height2;
        constrainedObject->GetBoundingBoxMax(&width2, &height2);
        startX += (double)(spacingX + (width2/2.0));
        startY += (double)(spacingY + (height2/2.0));

        if ((!Equals(startX, constrainedObject->GetX())) || (!Equals(startY, constrainedObject->GetY())))
	    {
          constrainedObject->Move(dc, startX, startY, FALSE);
          changed = TRUE;
	    }

        startX += (double)(width2/2.0);
        startY += (double)(height2/2.0);

        node = node->Next();
      }
      return changed;
    }
    case gyCONSTRAINT_LEFT_OF:
    {
      bool changed = FALSE;

      wxNode *node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();

        double width2, height2;
        constrainedObject->GetBoundingBoxMax(&width2, &height2);

        double x3 = (double)(x - (minWidth/2.0) - (width2/2.0) - m_xSpacing);
        if (!Equals(x3, constrainedObject->GetX()))
	    {
          changed = TRUE;
          constrainedObject->Move(dc, x3, constrainedObject->GetY(), FALSE);
	    }

        node = node->Next();
      }
      return changed;
    }
    case gyCONSTRAINT_RIGHT_OF:
    {
      bool changed = FALSE;

      wxNode *node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();

        double width2, height2;
        constrainedObject->GetBoundingBoxMax(&width2, &height2);

        double x3 = (double)(x + (minWidth/2.0) + (width2/2.0) + m_xSpacing);
        if (!Equals(x3, constrainedObject->GetX()))
	    {
          changed = TRUE;
          constrainedObject->Move(dc, x3, constrainedObject->GetY(), FALSE);
	    }

        node = node->Next();
      }
      return changed;

      return FALSE;
    }
    case gyCONSTRAINT_ABOVE:
    {
      bool changed = FALSE;

      wxNode *node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();

        double width2, height2;
        constrainedObject->GetBoundingBoxMax(&width2, &height2);

        double y3 = (double)(y - (minHeight/2.0) - (height2/2.0) - m_ySpacing);
        if (!Equals(y3, constrainedObject->GetY()))
	    {
          changed = TRUE;
          constrainedObject->Move(dc, constrainedObject->GetX(), y3, FALSE);
	    }

        node = node->Next();
      }
      return changed;
    }
    case gyCONSTRAINT_BELOW:
    {
      bool changed = FALSE;

      wxNode *node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();

        double width2, height2;
        constrainedObject->GetBoundingBoxMax(&width2, &height2);

        double y3 = (double)(y + (minHeight/2.0) + (height2/2.0) + m_ySpacing);
        if (!Equals(y3, constrainedObject->GetY()))
	    {
          changed = TRUE;
          constrainedObject->Move(dc, constrainedObject->GetX(), y3, FALSE);
	    }

        node = node->Next();
      }
      return changed;
    }
    case gyCONSTRAINT_ALIGNED_LEFT:
    {
      bool changed = FALSE;

      wxNode *node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();

        double width2, height2;
        constrainedObject->GetBoundingBoxMax(&width2, &height2);

        double x3 = (double)(x - (minWidth/2.0) + (width2/2.0) + m_xSpacing);
        if (!Equals(x3, constrainedObject->GetX()))
	    {
          changed = TRUE;
          constrainedObject->Move(dc, x3, constrainedObject->GetY(), FALSE);
	    }

        node = node->Next();
      }
      return changed;
    }
    case gyCONSTRAINT_ALIGNED_RIGHT:
    {
      bool changed = FALSE;

      wxNode *node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();

        double width2, height2;
        constrainedObject->GetBoundingBoxMax(&width2, &height2);

        double x3 = (double)(x + (minWidth/2.0) - (width2/2.0) - m_xSpacing);
        if (!Equals(x3, constrainedObject->GetX()))
	    {
          changed = TRUE;
          constrainedObject->Move(dc, x3, constrainedObject->GetY(), FALSE);
	    }

        node = node->Next();
      }
      return changed;

      return FALSE;
    }
    case gyCONSTRAINT_ALIGNED_TOP:
    {
      bool changed = FALSE;

      wxNode *node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();

        double width2, height2;
        constrainedObject->GetBoundingBoxMax(&width2, &height2);

        double y3 = (double)(y - (minHeight/2.0) + (height2/2.0) + m_ySpacing);
        if (!Equals(y3, constrainedObject->GetY()))
	    {
          changed = TRUE;
          constrainedObject->Move(dc, constrainedObject->GetX(), y3, FALSE);
	    }

        node = node->Next();
      }
      return changed;
    }
    case gyCONSTRAINT_ALIGNED_BOTTOM:
    {
      bool changed = FALSE;

      wxNode *node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();

        double width2, height2;
        constrainedObject->GetBoundingBoxMax(&width2, &height2);

        double y3 = (double)(y + (minHeight/2.0) - (height2/2.0) - m_ySpacing);
        if (!Equals(y3, constrainedObject->GetY()))
	    {
          changed = TRUE;
          constrainedObject->Move(dc, constrainedObject->GetX(), y3, FALSE);
	    }

        node = node->Next();
      }
      return changed;
    }
    case gyCONSTRAINT_MIDALIGNED_LEFT:
    {
      bool changed = FALSE;

      wxNode *node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();

        double x3 = (double)(x - (minWidth/2.0));
        if (!Equals(x3, constrainedObject->GetX()))
	    {
          changed = TRUE;
          constrainedObject->Move(dc, x3, constrainedObject->GetY(), FALSE);
	    }

        node = node->Next();
      }
      return changed;
    }
    case gyCONSTRAINT_MIDALIGNED_RIGHT:
    {
      bool changed = FALSE;

      wxNode *node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();

        double x3 = (double)(x + (minWidth/2.0));
        if (!Equals(x3, constrainedObject->GetX()))
	    {
          changed = TRUE;
          constrainedObject->Move(dc, x3, constrainedObject->GetY(), FALSE);
	    }

        node = node->Next();
      }
      return changed;

      return FALSE;
    }
    case gyCONSTRAINT_MIDALIGNED_TOP:
    {
      bool changed = FALSE;

      wxNode *node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();

        double y3 = (double)(y - (minHeight/2.0));
        if (!Equals(y3, constrainedObject->GetY()))
	    {
          changed = TRUE;
          constrainedObject->Move(dc, constrainedObject->GetX(), y3, FALSE);
	    }

        node = node->Next();
      }
      return changed;
    }
    case gyCONSTRAINT_MIDALIGNED_BOTTOM:
    {
      bool changed = FALSE;

      wxNode *node = m_constrainedObjects.First();
      while (node)
      {
        wxShape *constrainedObject = (wxShape *)node->Data();

        double y3 = (double)(y + (minHeight/2.0));
        if (!Equals(y3, constrainedObject->GetY()))
	    {
          changed = TRUE;
          constrainedObject->Move(dc, constrainedObject->GetX(), y3, FALSE);
	    }

        node = node->Next();
      }
      return changed;
    }

    default:
      return FALSE;
  }
  return FALSE;
}
Commit	Line	Data
1fc25a89 JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: constrnt.cpp
	3	// Purpose: OGL Constraint classes
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 12/07/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "constrnt.h"
	14	#endif
	15
	16	// For compilers that support precompilation, includes "wx.h".
92a19c2e	17	#include "wx/wxprec.h"
1fc25a89 JS	18
	19	#ifdef __BORLANDC__
	20	#pragma hdrstop
	21	#endif
	22
	23	#ifndef WX_PRECOMP
	24	#include <wx/wx.h>
	25	#endif
	26
	27	#include <wx/wxexpr.h>
	28
	29	#include <wx/ogl/basic.h>
	30	#include <wx/ogl/constrnt.h>
	31	#include <wx/ogl/canvas.h>
	32
	33	wxList *wxOGLConstraintTypes = NULL;
	34
	35	/*
	36	* Constraint type
	37	*
	38	*/
	39
	40	IMPLEMENT_DYNAMIC_CLASS(wxOGLConstraintType, wxObject)
	41
	42	wxOGLConstraintType::wxOGLConstraintType(int theType, const wxString& theName, const wxString& thePhrase)
	43	{
	44	m_type = theType;
	45	m_name = theName;
	46	m_phrase = thePhrase;
	47	}
	48
	49	wxOGLConstraintType::~wxOGLConstraintType()
	50	{
	51	}
	52
	53	void OGLInitializeConstraintTypes()
	54	{
	55	if (!wxOGLConstraintTypes)
	56	return;
	57
	58	wxOGLConstraintTypes = new wxList(wxKEY_INTEGER);
	59
	60	wxOGLConstraintTypes->Append(gyCONSTRAINT_CENTRED_VERTICALLY,
	61	new wxOGLConstraintType(gyCONSTRAINT_CENTRED_VERTICALLY, "Centre vertically", "centred vertically w.r.t."));
	62
	63	wxOGLConstraintTypes->Append(gyCONSTRAINT_CENTRED_HORIZONTALLY,
	64	new wxOGLConstraintType(gyCONSTRAINT_CENTRED_HORIZONTALLY, "Centre horizontally", "centred horizontally w.r.t."));
	65
	66	wxOGLConstraintTypes->Append(gyCONSTRAINT_CENTRED_BOTH,
	67	new wxOGLConstraintType(gyCONSTRAINT_CENTRED_BOTH, "Centre", "centred w.r.t."));
	68
	69	wxOGLConstraintTypes->Append(gyCONSTRAINT_LEFT_OF,
	70	new wxOGLConstraintType(gyCONSTRAINT_LEFT_OF, "Left of", "left of"));
	71
	72	wxOGLConstraintTypes->Append(gyCONSTRAINT_RIGHT_OF,
	73	new wxOGLConstraintType(gyCONSTRAINT_RIGHT_OF, "Right of", "right of"));
	74
	75	wxOGLConstraintTypes->Append(gyCONSTRAINT_ABOVE,
	76	new wxOGLConstraintType(gyCONSTRAINT_ABOVE, "Above", "above"));
	77
	78	wxOGLConstraintTypes->Append(gyCONSTRAINT_BELOW,
	79	new wxOGLConstraintType(gyCONSTRAINT_BELOW, "Below", "below"));
	80
	81	// Alignment
82	wxOGLConstraintTypes->Append(gyCONSTRAINT_ALIGNED_TOP,
83	new wxOGLConstraintType(gyCONSTRAINT_ALIGNED_TOP, "Top-aligned", "aligned to the top of"));
84
85	wxOGLConstraintTypes->Append(gyCONSTRAINT_ALIGNED_BOTTOM,
86	new wxOGLConstraintType(gyCONSTRAINT_ALIGNED_BOTTOM, "Bottom-aligned", "aligned to the bottom of"));
87
88	wxOGLConstraintTypes->Append(gyCONSTRAINT_ALIGNED_LEFT,
89	new wxOGLConstraintType(gyCONSTRAINT_ALIGNED_LEFT, "Left-aligned", "aligned to the left of"));
90
91	wxOGLConstraintTypes->Append(gyCONSTRAINT_ALIGNED_RIGHT,
92	new wxOGLConstraintType(gyCONSTRAINT_ALIGNED_RIGHT, "Right-aligned", "aligned to the right of"));
93
94	// Mid-alignment
95	wxOGLConstraintTypes->Append(gyCONSTRAINT_MIDALIGNED_TOP,
96	new wxOGLConstraintType(gyCONSTRAINT_MIDALIGNED_TOP, "Top-midaligned", "centred on the top of"));
97
98	wxOGLConstraintTypes->Append(gyCONSTRAINT_MIDALIGNED_BOTTOM,
99	new wxOGLConstraintType(gyCONSTRAINT_MIDALIGNED_BOTTOM, "Bottom-midaligned", "centred on the bottom of"));
100
101	wxOGLConstraintTypes->Append(gyCONSTRAINT_MIDALIGNED_LEFT,
102	new wxOGLConstraintType(gyCONSTRAINT_MIDALIGNED_LEFT, "Left-midaligned", "centred on the left of"));
103
104	wxOGLConstraintTypes->Append(gyCONSTRAINT_MIDALIGNED_RIGHT,
105	new wxOGLConstraintType(gyCONSTRAINT_MIDALIGNED_RIGHT, "Right-midaligned", "centred on the right of"));
106	}
107
108	void OGLCleanUpConstraintTypes()
109	{
110	if (!wxOGLConstraintTypes)
111	return;
112
113	wxNode* node = wxOGLConstraintTypes->First();
114	while (node)
115	{
116	wxOGLConstraintType* ct = (wxOGLConstraintType*) node->Data();
117	delete ct;
118	node = node->Next();
119	}
120	delete wxOGLConstraintTypes;
121	wxOGLConstraintTypes = NULL;
122	}
123
124	/*
125	* Constraint Stuff
126	*
127	*/
128
129	IMPLEMENT_DYNAMIC_CLASS(wxOGLConstraint, wxObject)
130
131	wxOGLConstraint::wxOGLConstraint(int type, wxShape *constraining, wxList& constrained)
132	{
133	m_xSpacing = 0.0;
134	m_ySpacing = 0.0;
135
136	m_constraintType = type;
137	m_constrainingObject = constraining;
138
139	m_constraintId = 0;
140	m_constraintName = "noname";
141
142	wxNode *node = constrained.First();
143	while (node)
144	{
145	m_constrainedObjects.Append(node->Data());
146	node = node->Next();
147	}
148	}
149
150	wxOGLConstraint::~wxOGLConstraint()
151	{
152	}
153
154	bool wxOGLConstraint::Equals(double a, double b)
155	{
156	double marg = 0.5;
157
158	bool eq = ((b <= a + marg) && (b >= a - marg));
159	return eq;
160	}
161
162	// Return TRUE if anything changed
163	bool wxOGLConstraint::Evaluate()
164	{
165	double maxWidth, maxHeight, minWidth, minHeight, x, y;
166	m_constrainingObject->GetBoundingBoxMax(&maxWidth, &maxHeight);
167	m_constrainingObject->GetBoundingBoxMin(&minWidth, &minHeight);
168	x = m_constrainingObject->GetX();
169	y = m_constrainingObject->GetY();
170
171	wxClientDC dc(m_constrainingObject->GetCanvas());
172	m_constrainingObject->GetCanvas()->PrepareDC(dc);
173
174	switch (m_constraintType)
175	{
176	case gyCONSTRAINT_CENTRED_VERTICALLY:
177	{
178	int n = m_constrainedObjects.Number();
179	double totalObjectHeight = 0.0;
180	wxNode *node = m_constrainedObjects.First();
181	while (node)
182	{
183	wxShape constrainedObject = (wxShape )node->Data();
184
185	double width2, height2;
186	constrainedObject->GetBoundingBoxMax(&width2, &height2);
187	totalObjectHeight += height2;
188	node = node->Next();
189	}
190	double startY;
191	double spacingY;
192	// Check if within the constraining object...
193	if ((totalObjectHeight + (n + 1)*m_ySpacing) <= minHeight)
194	{
195	spacingY = (double)((minHeight - totalObjectHeight)/(n + 1));
196	startY = (double)(y - (minHeight/2.0));
197	}
198	// Otherwise, use default spacing
199	else
200	{
201	spacingY = m_ySpacing;
202	startY = (double)(y - ((totalObjectHeight + (n+1)*spacingY)/2.0));
203	}
204
205	// Now position the objects
206	bool changed = FALSE;
207	node = m_constrainedObjects.First();
208	while (node)
209	{
210	wxShape constrainedObject = (wxShape )node->Data();
211	double width2, height2;
212	constrainedObject->GetBoundingBoxMax(&width2, &height2);
213	startY += (double)(spacingY + (height2/2.0));
214	if (!Equals(startY, constrainedObject->GetY()))
215	{
216	constrainedObject->Move(dc, constrainedObject->GetX(), startY, FALSE);
217	changed = TRUE;
218	}
219	startY += (double)(height2/2.0);
220	node = node->Next();
221	}
222	return changed;
223	}
224	case gyCONSTRAINT_CENTRED_HORIZONTALLY:
225	{
226	int n = m_constrainedObjects.Number();
227	double totalObjectWidth = 0.0;
228	wxNode *node = m_constrainedObjects.First();
229	while (node)
230	{
231	wxShape constrainedObject = (wxShape )node->Data();
232
233	double width2, height2;
234	constrainedObject->GetBoundingBoxMax(&width2, &height2);
235	totalObjectWidth += width2;
236	node = node->Next();
237	}
238	double startX;
239	double spacingX;
240	// Check if within the constraining object...
241	if ((totalObjectWidth + (n + 1)*m_xSpacing) <= minWidth)
242	{
243	spacingX = (double)((minWidth - totalObjectWidth)/(n + 1));
244	startX = (double)(x - (minWidth/2.0));
245	}
246	// Otherwise, use default spacing
247	else
248	{
249	spacingX = m_xSpacing;
250	startX = (double)(x - ((totalObjectWidth + (n+1)*spacingX)/2.0));
251	}
252
253	// Now position the objects
254	bool changed = FALSE;
255	node = m_constrainedObjects.First();
256	while (node)
257	{
258	wxShape constrainedObject = (wxShape )node->Data();
259	double width2, height2;
260	constrainedObject->GetBoundingBoxMax(&width2, &height2);
261	startX += (double)(spacingX + (width2/2.0));
262	if (!Equals(startX, constrainedObject->GetX()))
263	{
264	constrainedObject->Move(dc, startX, constrainedObject->GetY(), FALSE);
265	changed = TRUE;
266	}
267	startX += (double)(width2/2.0);
268	node = node->Next();
269	}
270	return changed;
271	}
272	case gyCONSTRAINT_CENTRED_BOTH:
273	{
274	int n = m_constrainedObjects.Number();
275	double totalObjectWidth = 0.0;
276	double totalObjectHeight = 0.0;
277	wxNode *node = m_constrainedObjects.First();
278	while (node)
279	{
280	wxShape constrainedObject = (wxShape )node->Data();
281
282	double width2, height2;
283	constrainedObject->GetBoundingBoxMax(&width2, &height2);
284	totalObjectWidth += width2;
285	totalObjectHeight += height2;
286	node = node->Next();
287	}
288	double startX;
289	double spacingX;
290	double startY;
291	double spacingY;
292
293	// Check if within the constraining object...
294	if ((totalObjectWidth + (n + 1)*m_xSpacing) <= minWidth)
295	{
296	spacingX = (double)((minWidth - totalObjectWidth)/(n + 1));
297	startX = (double)(x - (minWidth/2.0));
298	}
299	// Otherwise, use default spacing
300	else
301	{
302	spacingX = m_xSpacing;
303	startX = (double)(x - ((totalObjectWidth + (n+1)*spacingX)/2.0));
304	}
305
306	// Check if within the constraining object...
307	if ((totalObjectHeight + (n + 1)*m_ySpacing) <= minHeight)
308	{
309	spacingY = (double)((minHeight - totalObjectHeight)/(n + 1));
310	startY = (double)(y - (minHeight/2.0));
311	}
312	// Otherwise, use default spacing
313	else
314	{
315	spacingY = m_ySpacing;
316	startY = (double)(y - ((totalObjectHeight + (n+1)*spacingY)/2.0));
317	}
318
319	// Now position the objects
320	bool changed = FALSE;
321	node = m_constrainedObjects.First();
322	while (node)
323	{
324	wxShape constrainedObject = (wxShape )node->Data();
325	double width2, height2;
326	constrainedObject->GetBoundingBoxMax(&width2, &height2);
327	startX += (double)(spacingX + (width2/2.0));
328	startY += (double)(spacingY + (height2/2.0));
329
330	if ((!Equals(startX, constrainedObject->GetX())) \|\| (!Equals(startY, constrainedObject->GetY())))
331	{
332	constrainedObject->Move(dc, startX, startY, FALSE);
333	changed = TRUE;
334	}
335
336	startX += (double)(width2/2.0);
337	startY += (double)(height2/2.0);
338
339	node = node->Next();
340	}
341	return changed;
342	}
343	case gyCONSTRAINT_LEFT_OF:
344	{
345	bool changed = FALSE;
346
347	wxNode *node = m_constrainedObjects.First();
348	while (node)
349	{
350	wxShape constrainedObject = (wxShape )node->Data();
351
352	double width2, height2;
353	constrainedObject->GetBoundingBoxMax(&width2, &height2);
354
355	double x3 = (double)(x - (minWidth/2.0) - (width2/2.0) - m_xSpacing);
356	if (!Equals(x3, constrainedObject->GetX()))
357	{
358	changed = TRUE;
359	constrainedObject->Move(dc, x3, constrainedObject->GetY(), FALSE);
360	}
361
362	node = node->Next();
363	}
364	return changed;
365	}
366	case gyCONSTRAINT_RIGHT_OF:
367	{
368	bool changed = FALSE;
369
370	wxNode *node = m_constrainedObjects.First();
371	while (node)
372	{
373	wxShape constrainedObject = (wxShape )node->Data();
374
375	double width2, height2;
376	constrainedObject->GetBoundingBoxMax(&width2, &height2);
377
378	double x3 = (double)(x + (minWidth/2.0) + (width2/2.0) + m_xSpacing);
379	if (!Equals(x3, constrainedObject->GetX()))
380	{
381	changed = TRUE;
382	constrainedObject->Move(dc, x3, constrainedObject->GetY(), FALSE);
383	}
384
385	node = node->Next();
386	}
387	return changed;
388
389	return FALSE;
390	}
391	case gyCONSTRAINT_ABOVE:
392	{
393	bool changed = FALSE;
394
395	wxNode *node = m_constrainedObjects.First();
396	while (node)
397	{
398	wxShape constrainedObject = (wxShape )node->Data();
399
400	double width2, height2;
401	constrainedObject->GetBoundingBoxMax(&width2, &height2);
402
403	double y3 = (double)(y - (minHeight/2.0) - (height2/2.0) - m_ySpacing);
404	if (!Equals(y3, constrainedObject->GetY()))
405	{
406	changed = TRUE;
407	constrainedObject->Move(dc, constrainedObject->GetX(), y3, FALSE);
408	}
409
410	node = node->Next();
411	}
412	return changed;
413	}
414	case gyCONSTRAINT_BELOW:
415	{
416	bool changed = FALSE;
417
418	wxNode *node = m_constrainedObjects.First();
419	while (node)
420	{
421	wxShape constrainedObject = (wxShape )node->Data();
422
423	double width2, height2;
424	constrainedObject->GetBoundingBoxMax(&width2, &height2);
425
426	double y3 = (double)(y + (minHeight/2.0) + (height2/2.0) + m_ySpacing);
427	if (!Equals(y3, constrainedObject->GetY()))
428	{
429	changed = TRUE;
430	constrainedObject->Move(dc, constrainedObject->GetX(), y3, FALSE);
431	}
432
433	node = node->Next();
434	}
435	return changed;
436	}
437	case gyCONSTRAINT_ALIGNED_LEFT:
438	{
439	bool changed = FALSE;
440
441	wxNode *node = m_constrainedObjects.First();
442	while (node)
443	{
444	wxShape constrainedObject = (wxShape )node->Data();
445
446	double width2, height2;
447	constrainedObject->GetBoundingBoxMax(&width2, &height2);
448
449	double x3 = (double)(x - (minWidth/2.0) + (width2/2.0) + m_xSpacing);
450	if (!Equals(x3, constrainedObject->GetX()))
451	{
452	changed = TRUE;
453	constrainedObject->Move(dc, x3, constrainedObject->GetY(), FALSE);
454	}
455
456	node = node->Next();
457	}
458	return changed;
459	}
460	case gyCONSTRAINT_ALIGNED_RIGHT:
461	{
462	bool changed = FALSE;
463
464	wxNode *node = m_constrainedObjects.First();
465	while (node)
466	{
467	wxShape constrainedObject = (wxShape )node->Data();
468
469	double width2, height2;
470	constrainedObject->GetBoundingBoxMax(&width2, &height2);
471
472	double x3 = (double)(x + (minWidth/2.0) - (width2/2.0) - m_xSpacing);
473	if (!Equals(x3, constrainedObject->GetX()))
474	{
475	changed = TRUE;
476	constrainedObject->Move(dc, x3, constrainedObject->GetY(), FALSE);
477	}
478
479	node = node->Next();
480	}
481	return changed;
482
483	return FALSE;
484	}
485	case gyCONSTRAINT_ALIGNED_TOP:
486	{
487	bool changed = FALSE;
488
489	wxNode *node = m_constrainedObjects.First();
490	while (node)
491	{
492	wxShape constrainedObject = (wxShape )node->Data();
493
494	double width2, height2;
495	constrainedObject->GetBoundingBoxMax(&width2, &height2);
496
497	double y3 = (double)(y - (minHeight/2.0) + (height2/2.0) + m_ySpacing);
498	if (!Equals(y3, constrainedObject->GetY()))
499	{
500	changed = TRUE;
501	constrainedObject->Move(dc, constrainedObject->GetX(), y3, FALSE);
502	}
503
504	node = node->Next();
505	}
506	return changed;
507	}
508	case gyCONSTRAINT_ALIGNED_BOTTOM:
509	{
510	bool changed = FALSE;
511
512	wxNode *node = m_constrainedObjects.First();
513	while (node)
514	{
515	wxShape constrainedObject = (wxShape )node->Data();
516
517	double width2, height2;
518	constrainedObject->GetBoundingBoxMax(&width2, &height2);
519
520	double y3 = (double)(y + (minHeight/2.0) - (height2/2.0) - m_ySpacing);
521	if (!Equals(y3, constrainedObject->GetY()))
522	{
523	changed = TRUE;
524	constrainedObject->Move(dc, constrainedObject->GetX(), y3, FALSE);
525	}
526
527	node = node->Next();
528	}
529	return changed;
530	}
531	case gyCONSTRAINT_MIDALIGNED_LEFT:
532	{
533	bool changed = FALSE;
534
535	wxNode *node = m_constrainedObjects.First();
536	while (node)
537	{
538	wxShape constrainedObject = (wxShape )node->Data();
539
540	double x3 = (double)(x - (minWidth/2.0));
541	if (!Equals(x3, constrainedObject->GetX()))
542	{
543	changed = TRUE;
544	constrainedObject->Move(dc, x3, constrainedObject->GetY(), FALSE);
545	}
546
547	node = node->Next();
548	}
549	return changed;
550	}
551	case gyCONSTRAINT_MIDALIGNED_RIGHT:
552	{
553	bool changed = FALSE;
554
555	wxNode *node = m_constrainedObjects.First();
556	while (node)
557	{
558	wxShape constrainedObject = (wxShape )node->Data();
559
560	double x3 = (double)(x + (minWidth/2.0));
561	if (!Equals(x3, constrainedObject->GetX()))
562	{
563	changed = TRUE;
564	constrainedObject->Move(dc, x3, constrainedObject->GetY(), FALSE);
565	}
566
567	node = node->Next();
568	}
569	return changed;
570
571	return FALSE;
572	}
573	case gyCONSTRAINT_MIDALIGNED_TOP:
574	{
575	bool changed = FALSE;
576
577	wxNode *node = m_constrainedObjects.First();
578	while (node)
579	{
580	wxShape constrainedObject = (wxShape )node->Data();
581
582	double y3 = (double)(y - (minHeight/2.0));
583	if (!Equals(y3, constrainedObject->GetY()))
584	{
585	changed = TRUE;
586	constrainedObject->Move(dc, constrainedObject->GetX(), y3, FALSE);
587	}
588
589	node = node->Next();
590	}
591	return changed;
592	}
593	case gyCONSTRAINT_MIDALIGNED_BOTTOM:
594	{
595	bool changed = FALSE;
596
597	wxNode *node = m_constrainedObjects.First();
598	while (node)
599	{
600	wxShape constrainedObject = (wxShape )node->Data();
601
602	double y3 = (double)(y + (minHeight/2.0));
603	if (!Equals(y3, constrainedObject->GetY()))
604	{
605	changed = TRUE;
606	constrainedObject->Move(dc, constrainedObject->GetX(), y3, FALSE);
607	}
608
609	node = node->Next();
610	}
611	return changed;
612	}
613
614	default:
615	return FALSE;
616	}
617	return FALSE;
618	}
619