contrib/src/ogl/ogldiag.cpp

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

// 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

#if wxUSE_PROLOGIO
#include "wx/deprecated/wxexpr.h"
#endif

#ifdef new
#undef new
#endif

#include <ctype.h>
#include <math.h>
#include <stdlib.h>

#include "wx/ogl/ogl.h"


IMPLEMENT_DYNAMIC_CLASS(wxDiagram, wxObject)

// Object canvas
wxDiagram::wxDiagram()
{
  m_diagramCanvas = NULL;
  m_quickEditMode = false;
  m_snapToGrid = true;
  m_gridSpacing = 5.0;
  m_shapeList = new wxList;
  m_mouseTolerance = DEFAULT_MOUSE_TOLERANCE;
}

wxDiagram::~wxDiagram()
{
  if (m_shapeList)
    delete m_shapeList;
}

void wxDiagram::SetSnapToGrid(bool snap)
{
  m_snapToGrid = snap;
}

void wxDiagram::SetGridSpacing(double spacing)
{
  m_gridSpacing = spacing;
}

void wxDiagram::Snap(double *x, double *y)
{
  if (m_snapToGrid)
  {
    *x = m_gridSpacing * ((int)(*x/m_gridSpacing + 0.5));
    *y = m_gridSpacing * ((int)(*y/m_gridSpacing + 0.5));
  }
}


void wxDiagram::Redraw(wxDC& dc)
{
  if (m_shapeList)
  {
    if (GetCanvas())
      GetCanvas()->SetCursor(* wxHOURGLASS_CURSOR);
    wxNode *current = m_shapeList->GetFirst();

    while (current)
    {
      wxShape *object = (wxShape *)current->GetData();
      if (!object->GetParent())
        object->Draw(dc);

      current = current->GetNext();
    }
    if (GetCanvas())
      GetCanvas()->SetCursor(* wxSTANDARD_CURSOR);
  }
}

void wxDiagram::Clear(wxDC& dc)
{
  dc.Clear();
}

// Insert object after addAfter, or at end of list.
void wxDiagram::AddShape(wxShape *object, wxShape *addAfter)
{
  wxNode *nodeAfter = NULL;
  if (addAfter)
    nodeAfter = m_shapeList->Member(addAfter);

  if (!m_shapeList->Member(object))
  {
    if (nodeAfter)
    {
      if (nodeAfter->GetNext())
        m_shapeList->Insert(nodeAfter->GetNext(), object);
      else
        m_shapeList->Append(object);
    }
    else
      m_shapeList->Append(object);
    object->SetCanvas(GetCanvas());
  }
}

void wxDiagram::InsertShape(wxShape *object)
{
  m_shapeList->Insert(object);
  object->SetCanvas(GetCanvas());
}

void wxDiagram::RemoveShape(wxShape *object)
{
  m_shapeList->DeleteObject(object);
}

// Should this delete the actual objects too? I think not.
void wxDiagram::RemoveAllShapes()
{
  m_shapeList->Clear();
}

void wxDiagram::DeleteAllShapes()
{
  wxNode *node = m_shapeList->GetFirst();
  while (node)
  {
    wxShape *shape = (wxShape *)node->GetData();
    if (!shape->GetParent())
    {
      RemoveShape(shape);
      delete shape;
      node = m_shapeList->GetFirst();
    }
    else
      node = node->GetNext();
  }
}

void wxDiagram::ShowAll(bool show)
{
  wxNode *current = m_shapeList->GetFirst();

  while (current)
  {
    wxShape *object = (wxShape *)current->GetData();
    object->Show(show);

    current = current->GetNext();
  }
}

void wxDiagram::DrawOutline(wxDC& dc, double x1, double y1, double x2, double y2)
{
  wxPen dottedPen(*wxBLACK, 1, wxDOT);
  dc.SetPen(dottedPen);
  dc.SetBrush((* wxTRANSPARENT_BRUSH));

  wxPoint points[5];

  points[0].x = (int) x1;
  points[0].y = (int) y1;

  points[1].x = (int) x2;
  points[1].y = (int) y1;

  points[2].x = (int) x2;
  points[2].y = (int) y2;

  points[3].x = (int) x1;
  points[3].y = (int) y2;

  points[4].x = (int) x1;
  points[4].y = (int) y1;
  dc.DrawLines(5, points);
}

// Make sure all text that should be centred, is centred.
void wxDiagram::RecentreAll(wxDC& dc)
{
  wxNode *object_node = m_shapeList->GetFirst();
  while (object_node)
  {
    wxShape *obj = (wxShape *)object_node->GetData();
    obj->Recentre(dc);
    object_node = object_node->GetNext();
  }
}

// Input/output
#if wxUSE_PROLOGIO
bool wxDiagram::SaveFile(const wxString& filename)
{
  wxBeginBusyCursor();

  wxExprDatabase *database = new wxExprDatabase;

  // First write the diagram type
  wxExpr *header = new wxExpr(_T("diagram"));
  OnHeaderSave(*database, *header);

  database->Append(header);

  wxNode *node = m_shapeList->GetFirst();
  while (node)
  {
    wxShape *shape = (wxShape *)node->GetData();

    if (!shape->IsKindOf(CLASSINFO(wxControlPoint)))
    {
      wxExpr *expr;
      if (shape->IsKindOf(CLASSINFO(wxLineShape)))
        expr = new wxExpr(_T("line"));
       else
        expr = new wxExpr(_T("shape"));

      OnShapeSave(*database, *shape, *expr);
    }
    node = node->GetNext();
  }
  OnDatabaseSave(*database);

  wxString tempFile;
  wxGetTempFileName(wxT("diag"), tempFile);
  FILE* file = fopen(tempFile.mb_str(wxConvFile), "w");
  if (! file)
  {
    wxEndBusyCursor();
    delete database;
    return false;
  }

  database->Write(file);
  fclose(file);
  delete database;

/*
  // Save backup
  if (FileExists(filename))
  {
    char buf[400];
#ifdef __X__
    sprintf(buf, "%s.bak", filename);
#endif
#ifdef __WXMSW__
    sprintf(buf, "_diagram.bak");
#endif
    if (FileExists(buf)) wxRemoveFile(buf);
    if (!wxRenameFile(filename, buf))
    {
      wxCopyFile(filename, buf);
      wxRemoveFile(filename);
    }
  }
*/

  // Copy the temporary file to the correct filename
  if (!wxRenameFile(tempFile, filename))
  {
    wxCopyFile(tempFile, filename);
    wxRemoveFile(tempFile);
  }

  wxEndBusyCursor();
  return true;
}

bool wxDiagram::LoadFile(const wxString& filename)
{
  wxBeginBusyCursor();

  wxExprDatabase database(wxExprInteger, _T("id"));
  if (!database.Read(filename))
  {
    wxEndBusyCursor();
    return false;
  }

  DeleteAllShapes();

  database.BeginFind();
  wxExpr *header = database.FindClauseByFunctor(_T("diagram"));

  if (header)
    OnHeaderLoad(database, *header);

  // Scan through all clauses and register the ids
  wxNode *node = database.GetFirst();
  while (node)
  {
    wxExpr *clause = (wxExpr *)node->GetData();
    long id = -1;
    clause->GetAttributeValue(_T("id"), id);
    wxRegisterId(id);
    node = node->GetNext();
  }

  ReadNodes(database);
  ReadContainerGeometry(database);
  ReadLines(database);

  OnDatabaseLoad(database);

  wxEndBusyCursor();

  return true;
}

void wxDiagram::ReadNodes(wxExprDatabase& database)
{
  // Find and create the node images
  database.BeginFind();
  wxExpr *clause = database.FindClauseByFunctor(_T("shape"));
  while (clause)
  {
    wxChar *type = NULL;
    long parentId = -1;

    clause->AssignAttributeValue(wxT("type"), &type);
    clause->AssignAttributeValue(wxT("parent"), &parentId);
    wxClassInfo *classInfo = wxClassInfo::FindClass(type);
    if (classInfo)
    {
      wxShape *shape = (wxShape *)classInfo->CreateObject();
      OnShapeLoad(database, *shape, *clause);

      shape->SetCanvas(GetCanvas());
      shape->Show(true);

      m_shapeList->Append(shape);

      // If child of composite, link up
      if (parentId > -1)
      {
        wxExpr *parentExpr = database.HashFind(_T("shape"), parentId);
        if (parentExpr && parentExpr->GetClientData())
        {
          wxShape *parent = (wxShape *)parentExpr->GetClientData();
          shape->SetParent(parent);
          parent->GetChildren().Append(shape);
        }
      }

      clause->SetClientData(shape);
    }
    if (type)
      delete[] type;

    clause = database.FindClauseByFunctor(_T("shape"));
  }
  return;
}

void wxDiagram::ReadLines(wxExprDatabase& database)
{
  database.BeginFind();
  wxExpr *clause = database.FindClauseByFunctor(_T("line"));
  while (clause)
  {
    wxString type;
    long parentId = -1;

    clause->GetAttributeValue(_T("type"), type);
    clause->GetAttributeValue(_T("parent"), parentId);
    wxClassInfo *classInfo = wxClassInfo::FindClass(type);
    if (classInfo)
    {
      wxLineShape *shape = (wxLineShape *)classInfo->CreateObject();
      shape->Show(true);

      OnShapeLoad(database, *shape, *clause);
      shape->SetCanvas(GetCanvas());

      long image_to = -1; long image_from = -1;
      clause->GetAttributeValue(_T("to"), image_to);
      clause->GetAttributeValue(_T("from"), image_from);

      wxExpr *image_to_expr = database.HashFind(_T("shape"), image_to);

      if (!image_to_expr)
      {
        // Error
      }
      wxExpr *image_from_expr = database.HashFind(_T("shape"), image_from);

      if (!image_from_expr)
      {
        // Error
      }

      if (image_to_expr && image_from_expr)
      {
        wxShape *image_to_object = (wxShape *)image_to_expr->GetClientData();
        wxShape *image_from_object = (wxShape *)image_from_expr->GetClientData();

        if (image_to_object && image_from_object)
        {
          image_from_object->AddLine(shape, image_to_object, shape->GetAttachmentFrom(), shape->GetAttachmentTo());
        }
      }
      clause->SetClientData(shape);

      m_shapeList->Append(shape);
    }

    clause = database.FindClauseByFunctor(_T("line"));
  }
}

// Containers have divisions that reference adjoining divisions,
// so we need a separate pass to link everything up.
// Also used by Symbol Library.
void wxDiagram::ReadContainerGeometry(wxExprDatabase& database)
{
  database.BeginFind();
  wxExpr *clause = database.FindClauseByFunctor(_T("shape"));
  while (clause)
  {
    wxShape *image = (wxShape *)clause->GetClientData();
    if (image && image->IsKindOf(CLASSINFO(wxCompositeShape)))
    {
      wxCompositeShape *composite = (wxCompositeShape *)image;
      wxExpr *divisionExpr = NULL;

      // Find the list of divisions in the composite
      clause->GetAttributeValue(_T("divisions"), &divisionExpr);
      if (divisionExpr)
      {
        int i = 0;
        wxExpr *idExpr = divisionExpr->Nth(i);
        while (idExpr)
        {
          long divisionId = idExpr->IntegerValue();
          wxExpr *childExpr = database.HashFind(_T("shape"), divisionId);
          if (childExpr && childExpr->GetClientData())
          {
            wxDivisionShape *child = (wxDivisionShape *)childExpr->GetClientData();
            composite->GetDivisions().Append(child);

            // Find the adjoining shapes
            long leftSideId = -1;
            long topSideId = -1;
            long rightSideId = -1;
            long bottomSideId = -1;
            childExpr->GetAttributeValue(_T("left_side"), leftSideId);
            childExpr->GetAttributeValue(_T("top_side"), topSideId);
            childExpr->GetAttributeValue(_T("right_side"), rightSideId);
            childExpr->GetAttributeValue(_T("bottom_side"), bottomSideId);
            if (leftSideId > -1)
            {
              wxExpr *leftExpr = database.HashFind(_T("shape"), leftSideId);
              if (leftExpr && leftExpr->GetClientData())
              {
                wxDivisionShape *leftSide = (wxDivisionShape *)leftExpr->GetClientData();
                child->SetLeftSide(leftSide);
              }
            }
            if (topSideId > -1)
            {
              wxExpr *topExpr = database.HashFind(_T("shape"), topSideId);
              if (topExpr && topExpr->GetClientData())
              {
                wxDivisionShape *topSide = (wxDivisionShape *)topExpr->GetClientData();
                child->SetTopSide(topSide);
              }
            }
            if (rightSideId > -1)
            {
              wxExpr *rightExpr = database.HashFind(_T("shape"), rightSideId);
              if (rightExpr && rightExpr->GetClientData())
              {
                wxDivisionShape *rightSide = (wxDivisionShape *)rightExpr->GetClientData();
                child->SetRightSide(rightSide);
              }
            }
            if (bottomSideId > -1)
            {
              wxExpr *bottomExpr = database.HashFind(_T("shape"), bottomSideId);
              if (bottomExpr && bottomExpr->GetClientData())
              {
                wxDivisionShape *bottomSide = (wxDivisionShape *)bottomExpr->GetClientData();
                child->SetBottomSide(bottomSide);
              }
            }
          }
          i ++;
          idExpr = divisionExpr->Nth(i);
        }
      }
    }

    clause = database.FindClauseByFunctor(_T("shape"));
  }
}

// Allow for modifying file
bool wxDiagram::OnDatabaseLoad(wxExprDatabase& WXUNUSED(db))
{
  return true;
}

bool wxDiagram::OnDatabaseSave(wxExprDatabase& WXUNUSED(db))
{
  return true;
}

bool wxDiagram::OnShapeSave(wxExprDatabase& db, wxShape& shape, wxExpr& expr)
{
  shape.WriteAttributes(&expr);
  db.Append(&expr);

  if (shape.IsKindOf(CLASSINFO(wxCompositeShape)))
  {
    wxNode *node = shape.GetChildren().GetFirst();
    while (node)
    {
      wxShape *childShape = (wxShape *)node->GetData();
      wxExpr *childExpr = new wxExpr(_T("shape"));
      OnShapeSave(db, *childShape, *childExpr);
      node = node->GetNext();
    }
  }

  return true;
}

bool wxDiagram::OnShapeLoad(wxExprDatabase& WXUNUSED(db), wxShape& shape, wxExpr& expr)
{
  shape.ReadAttributes(&expr);
  return true;
}

bool wxDiagram::OnHeaderSave(wxExprDatabase& WXUNUSED(db), wxExpr& WXUNUSED(expr))
{
  return true;
}

bool wxDiagram::OnHeaderLoad(wxExprDatabase& WXUNUSED(db), wxExpr& WXUNUSED(expr))
{
  return true;
}

#endif

void wxDiagram::SetCanvas(wxShapeCanvas *can)
{
  m_diagramCanvas = can;
}

// Find a shape by its id
wxShape* wxDiagram::FindShape(long id) const
{
    wxNode* node = GetShapeList()->GetFirst();
    while (node)
    {
        wxShape* shape = (wxShape*) node->GetData();
        if (shape->GetId() == id)
            return shape;
        node = node->GetNext();
    }
    return NULL;
}


//// Crossings classes

wxLineCrossings::wxLineCrossings()
{
}

wxLineCrossings::~wxLineCrossings()
{
    ClearCrossings();
}

void wxLineCrossings::FindCrossings(wxDiagram& diagram)
{
    ClearCrossings();
    wxNode* node1 = diagram.GetShapeList()->GetFirst();
    while (node1)
    {
        wxShape* shape1 = (wxShape*) node1->GetData();
        if (shape1->IsKindOf(CLASSINFO(wxLineShape)))
        {
            wxLineShape* lineShape1 = (wxLineShape*) shape1;
            // Iterate through the segments
            wxList* pts1 = lineShape1->GetLineControlPoints();
            size_t i;
            for (i = 0; i < (pts1->GetCount() - 1); i++)
            {
                wxRealPoint* pt1_a = (wxRealPoint*) (pts1->Item(i)->GetData());
                wxRealPoint* pt1_b = (wxRealPoint*) (pts1->Item(i+1)->GetData());

                // Now we iterate through the segments again

                wxNode* node2 = diagram.GetShapeList()->GetFirst();
                while (node2)
                {
                    wxShape* shape2 = (wxShape*) node2->GetData();

                    // Assume that the same line doesn't cross itself
                    if (shape2->IsKindOf(CLASSINFO(wxLineShape)) && (shape1 != shape2))
                    {
                        wxLineShape* lineShape2 = (wxLineShape*) shape2;
                        // Iterate through the segments
                        wxList* pts2 = lineShape2->GetLineControlPoints();
                        int j;
                        for (j = 0; j < (int) (pts2->GetCount() - 1); j++)
                        {
                            wxRealPoint* pt2_a = (wxRealPoint*) (pts2->Item(j)->GetData());
                            wxRealPoint* pt2_b = (wxRealPoint*) (pts2->Item(j+1)->GetData());

                            // Now let's see if these two segments cross.
                            double ratio1, ratio2;
                            oglCheckLineIntersection(pt1_a->x, pt1_a->y, pt1_b->x, pt1_b->y,
                               pt2_a->x, pt2_a->y, pt2_b->x, pt2_b->y,
                             & ratio1, & ratio2);

                            if ((ratio1 < 1.0) && (ratio1 > -1.0))
                            {
                                // Intersection!
                                wxLineCrossing* crossing = new wxLineCrossing;
                                crossing->m_intersect.x = (pt1_a->x + (pt1_b->x - pt1_a->x)*ratio1);
                                crossing->m_intersect.y = (pt1_a->y + (pt1_b->y - pt1_a->y)*ratio1);

                                crossing->m_pt1 = * pt1_a;
                                crossing->m_pt2 = * pt1_b;
                                crossing->m_pt3 = * pt2_a;
                                crossing->m_pt4 = * pt2_b;

                                crossing->m_lineShape1 = lineShape1;
                                crossing->m_lineShape2 = lineShape2;

                                m_crossings.Append(crossing);
                            }
                        }
                    }
                    node2 = node2->GetNext();
                }
            }
        }

        node1 = node1->GetNext();
    }
}

void wxLineCrossings::DrawCrossings(wxDiagram& WXUNUSED(diagram), wxDC& dc)
{
    dc.SetBrush(*wxTRANSPARENT_BRUSH);

    long arcWidth = 8;

    wxNode* node = m_crossings.GetFirst();
    while (node)
    {
        wxLineCrossing* crossing = (wxLineCrossing*) node->GetData();
//        dc.DrawEllipse((long) (crossing->m_intersect.x - (arcWidth/2.0) + 0.5), (long) (crossing->m_intersect.y - (arcWidth/2.0) + 0.5),
//           arcWidth, arcWidth);


        // Let's do some geometry to find the points on either end of the arc.
/*

(x1, y1)
    |\
    | \
    |  \
    |   \
    |    \
    |    |\ c    c1
    |  a | \
         |  \
    |     -  x <-- centre of arc
 a1 |     b  |\
    |        | \ c2
    |     a2 |  \
    |         -  \
    |         b2  \
    |              \
    |_______________\ (x2, y2)
          b1

*/

        double a1 = wxMax(crossing->m_pt1.y, crossing->m_pt2.y) - wxMin(crossing->m_pt1.y, crossing->m_pt2.y) ;
        double b1 = wxMax(crossing->m_pt1.x, crossing->m_pt2.x) - wxMin(crossing->m_pt1.x, crossing->m_pt2.x) ;
        double c1 = sqrt( (a1*a1) + (b1*b1) );

        double c = arcWidth / 2.0;
        double a = c * a1/c1 ;
        double b = c * b1/c1 ;

        // I'm not sure this is right, since we don't know which direction we should be going in - need
        // to know which way the line slopes and choose the sign appropriately.
        double arcX1 = crossing->m_intersect.x - b;
        double arcY1 = crossing->m_intersect.y - a;

        double arcX2 = crossing->m_intersect.x + b;
        double arcY2 = crossing->m_intersect.y + a;

        dc.SetPen(*wxBLACK_PEN);
        dc.DrawArc( (long) arcX1, (long) arcY1, (long) arcX2, (long) arcY2,
            (long) crossing->m_intersect.x, (long) crossing->m_intersect.y);

        dc.SetPen(*wxWHITE_PEN);
        dc.DrawLine( (long) arcX1, (long) arcY1, (long) arcX2, (long) arcY2 );

        node = node->GetNext();
    }
}

void wxLineCrossings::ClearCrossings()
{
    wxNode* node = m_crossings.GetFirst();
    while (node)
    {
        wxLineCrossing* crossing = (wxLineCrossing*) node->GetData();
        delete crossing;
        node = node->GetNext();
    }
    m_crossings.Clear();
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: ogldiag.cpp
	3	// Purpose: wxDiagram
	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	// For compilers that support precompilation, includes "wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#ifdef __BORLANDC__
	16	#pragma hdrstop
	17	#endif
	18
	19	#ifndef WX_PRECOMP
	20	#include "wx/wx.h"
	21	#endif
	22
	23	#if wxUSE_PROLOGIO
	24	#include "wx/deprecated/wxexpr.h"
	25	#endif
	26
	27	#ifdef new
	28	#undef new
	29	#endif
	30
	31	#include <ctype.h>
	32	#include <math.h>
	33	#include <stdlib.h>
	34
	35	#include "wx/ogl/ogl.h"
	36
	37
	38	IMPLEMENT_DYNAMIC_CLASS(wxDiagram, wxObject)
	39
	40	// Object canvas
	41	wxDiagram::wxDiagram()
	42	{
	43	m_diagramCanvas = NULL;
	44	m_quickEditMode = false;
	45	m_snapToGrid = true;
	46	m_gridSpacing = 5.0;
	47	m_shapeList = new wxList;
	48	m_mouseTolerance = DEFAULT_MOUSE_TOLERANCE;
	49	}
	50
	51	wxDiagram::~wxDiagram()
	52	{
	53	if (m_shapeList)
	54	delete m_shapeList;
	55	}
	56
	57	void wxDiagram::SetSnapToGrid(bool snap)
	58	{
	59	m_snapToGrid = snap;
	60	}
	61
	62	void wxDiagram::SetGridSpacing(double spacing)
	63	{
	64	m_gridSpacing = spacing;
	65	}
	66
	67	void wxDiagram::Snap(double x, double y)
	68	{
	69	if (m_snapToGrid)
	70	{
	71	x = m_gridSpacing ((int)(*x/m_gridSpacing + 0.5));
	72	y = m_gridSpacing ((int)(*y/m_gridSpacing + 0.5));
	73	}
	74	}
	75
	76
	77	void wxDiagram::Redraw(wxDC& dc)
	78	{
	79	if (m_shapeList)
	80	{
	81	if (GetCanvas())
	82	GetCanvas()->SetCursor(* wxHOURGLASS_CURSOR);
	83	wxNode *current = m_shapeList->GetFirst();
	84
	85	while (current)
	86	{
	87	wxShape object = (wxShape )current->GetData();
	88	if (!object->GetParent())
	89	object->Draw(dc);
	90
	91	current = current->GetNext();
	92	}
	93	if (GetCanvas())
	94	GetCanvas()->SetCursor(* wxSTANDARD_CURSOR);
	95	}
	96	}
	97
	98	void wxDiagram::Clear(wxDC& dc)
	99	{
	100	dc.Clear();
	101	}
	102
	103	// Insert object after addAfter, or at end of list.
	104	void wxDiagram::AddShape(wxShape object, wxShape addAfter)
	105	{
	106	wxNode *nodeAfter = NULL;
	107	if (addAfter)
	108	nodeAfter = m_shapeList->Member(addAfter);
	109
	110	if (!m_shapeList->Member(object))
	111	{
	112	if (nodeAfter)
	113	{
	114	if (nodeAfter->GetNext())
	115	m_shapeList->Insert(nodeAfter->GetNext(), object);
	116	else
	117	m_shapeList->Append(object);
	118	}
	119	else
	120	m_shapeList->Append(object);
	121	object->SetCanvas(GetCanvas());
	122	}
	123	}
	124
	125	void wxDiagram::InsertShape(wxShape *object)
	126	{
	127	m_shapeList->Insert(object);
	128	object->SetCanvas(GetCanvas());
	129	}
	130
	131	void wxDiagram::RemoveShape(wxShape *object)
	132	{
	133	m_shapeList->DeleteObject(object);
	134	}
	135
	136	// Should this delete the actual objects too? I think not.
	137	void wxDiagram::RemoveAllShapes()
	138	{
	139	m_shapeList->Clear();
	140	}
	141
	142	void wxDiagram::DeleteAllShapes()
	143	{
	144	wxNode *node = m_shapeList->GetFirst();
	145	while (node)
	146	{
	147	wxShape shape = (wxShape )node->GetData();
	148	if (!shape->GetParent())
	149	{
	150	RemoveShape(shape);
	151	delete shape;
	152	node = m_shapeList->GetFirst();
	153	}
	154	else
	155	node = node->GetNext();
	156	}
	157	}
	158
	159	void wxDiagram::ShowAll(bool show)
	160	{
	161	wxNode *current = m_shapeList->GetFirst();
	162
	163	while (current)
	164	{
	165	wxShape object = (wxShape )current->GetData();
	166	object->Show(show);
	167
	168	current = current->GetNext();
	169	}
	170	}
	171
	172	void wxDiagram::DrawOutline(wxDC& dc, double x1, double y1, double x2, double y2)
	173	{
	174	wxPen dottedPen(*wxBLACK, 1, wxDOT);
	175	dc.SetPen(dottedPen);
	176	dc.SetBrush((* wxTRANSPARENT_BRUSH));
	177
	178	wxPoint points[5];
	179
	180	points[0].x = (int) x1;
	181	points[0].y = (int) y1;
	182
	183	points[1].x = (int) x2;
	184	points[1].y = (int) y1;
	185
	186	points[2].x = (int) x2;
	187	points[2].y = (int) y2;
	188
	189	points[3].x = (int) x1;
	190	points[3].y = (int) y2;
	191
	192	points[4].x = (int) x1;
	193	points[4].y = (int) y1;
	194	dc.DrawLines(5, points);
	195	}
	196
	197	// Make sure all text that should be centred, is centred.
	198	void wxDiagram::RecentreAll(wxDC& dc)
	199	{
	200	wxNode *object_node = m_shapeList->GetFirst();
	201	while (object_node)
	202	{
	203	wxShape obj = (wxShape )object_node->GetData();
	204	obj->Recentre(dc);
	205	object_node = object_node->GetNext();
	206	}
	207	}
	208
	209	// Input/output
	210	#if wxUSE_PROLOGIO
	211	bool wxDiagram::SaveFile(const wxString& filename)
	212	{
	213	wxBeginBusyCursor();
	214
	215	wxExprDatabase *database = new wxExprDatabase;
	216
	217	// First write the diagram type
	218	wxExpr *header = new wxExpr(_T("diagram"));
	219	OnHeaderSave(database, header);
	220
	221	database->Append(header);
	222
	223	wxNode *node = m_shapeList->GetFirst();
	224	while (node)
	225	{
	226	wxShape shape = (wxShape )node->GetData();
	227
	228	if (!shape->IsKindOf(CLASSINFO(wxControlPoint)))
	229	{
	230	wxExpr *expr;
	231	if (shape->IsKindOf(CLASSINFO(wxLineShape)))
	232	expr = new wxExpr(_T("line"));
	233	else
	234	expr = new wxExpr(_T("shape"));
	235
	236	OnShapeSave(database, shape, *expr);
	237	}
	238	node = node->GetNext();
	239	}
	240	OnDatabaseSave(*database);
	241
	242	wxString tempFile;
	243	wxGetTempFileName(wxT("diag"), tempFile);
	244	FILE* file = fopen(tempFile.mb_str(wxConvFile), "w");
	245	if (! file)
	246	{
	247	wxEndBusyCursor();
	248	delete database;
	249	return false;
	250	}
	251
	252	database->Write(file);
	253	fclose(file);
	254	delete database;
	255
	256	/*
	257	// Save backup
	258	if (FileExists(filename))
	259	{
	260	char buf[400];
	261	#ifdef __X__
	262	sprintf(buf, "%s.bak", filename);
	263	#endif
	264	#ifdef __WXMSW__
	265	sprintf(buf, "_diagram.bak");
	266	#endif
	267	if (FileExists(buf)) wxRemoveFile(buf);
	268	if (!wxRenameFile(filename, buf))
	269	{
	270	wxCopyFile(filename, buf);
	271	wxRemoveFile(filename);
	272	}
	273	}
	274	*/
	275
	276	// Copy the temporary file to the correct filename
	277	if (!wxRenameFile(tempFile, filename))
	278	{
	279	wxCopyFile(tempFile, filename);
	280	wxRemoveFile(tempFile);
	281	}
	282
	283	wxEndBusyCursor();
	284	return true;
	285	}
	286
	287	bool wxDiagram::LoadFile(const wxString& filename)
	288	{
	289	wxBeginBusyCursor();
	290
	291	wxExprDatabase database(wxExprInteger, _T("id"));
	292	if (!database.Read(filename))
	293	{
	294	wxEndBusyCursor();
	295	return false;
	296	}
	297
	298	DeleteAllShapes();
	299
	300	database.BeginFind();
	301	wxExpr *header = database.FindClauseByFunctor(_T("diagram"));
	302
	303	if (header)
	304	OnHeaderLoad(database, *header);
	305
	306	// Scan through all clauses and register the ids
	307	wxNode *node = database.GetFirst();
	308	while (node)
	309	{
	310	wxExpr clause = (wxExpr )node->GetData();
	311	long id = -1;
	312	clause->GetAttributeValue(_T("id"), id);
	313	wxRegisterId(id);
	314	node = node->GetNext();
	315	}
	316
	317	ReadNodes(database);
	318	ReadContainerGeometry(database);
	319	ReadLines(database);
	320
	321	OnDatabaseLoad(database);
	322
	323	wxEndBusyCursor();
	324
	325	return true;
	326	}
	327
	328	void wxDiagram::ReadNodes(wxExprDatabase& database)
	329	{
	330	// Find and create the node images
	331	database.BeginFind();
	332	wxExpr *clause = database.FindClauseByFunctor(_T("shape"));
	333	while (clause)
	334	{
	335	wxChar *type = NULL;
	336	long parentId = -1;
	337
	338	clause->AssignAttributeValue(wxT("type"), &type);
	339	clause->AssignAttributeValue(wxT("parent"), &parentId);
	340	wxClassInfo *classInfo = wxClassInfo::FindClass(type);
	341	if (classInfo)
	342	{
	343	wxShape shape = (wxShape )classInfo->CreateObject();
	344	OnShapeLoad(database, shape, clause);
	345
	346	shape->SetCanvas(GetCanvas());
	347	shape->Show(true);
	348
	349	m_shapeList->Append(shape);
	350
	351	// If child of composite, link up
	352	if (parentId > -1)
	353	{
	354	wxExpr *parentExpr = database.HashFind(_T("shape"), parentId);
	355	if (parentExpr && parentExpr->GetClientData())
	356	{
	357	wxShape parent = (wxShape )parentExpr->GetClientData();
	358	shape->SetParent(parent);
	359	parent->GetChildren().Append(shape);
	360	}
	361	}
	362
	363	clause->SetClientData(shape);
	364	}
	365	if (type)
	366	delete[] type;
	367
	368	clause = database.FindClauseByFunctor(_T("shape"));
	369	}
	370	return;
	371	}
	372
	373	void wxDiagram::ReadLines(wxExprDatabase& database)
	374	{
	375	database.BeginFind();
	376	wxExpr *clause = database.FindClauseByFunctor(_T("line"));
	377	while (clause)
	378	{
	379	wxString type;
	380	long parentId = -1;
	381
	382	clause->GetAttributeValue(_T("type"), type);
	383	clause->GetAttributeValue(_T("parent"), parentId);
	384	wxClassInfo *classInfo = wxClassInfo::FindClass(type);
	385	if (classInfo)
	386	{
	387	wxLineShape shape = (wxLineShape )classInfo->CreateObject();
	388	shape->Show(true);
	389
	390	OnShapeLoad(database, shape, clause);
	391	shape->SetCanvas(GetCanvas());
	392
	393	long image_to = -1; long image_from = -1;
	394	clause->GetAttributeValue(_T("to"), image_to);
	395	clause->GetAttributeValue(_T("from"), image_from);
	396
	397	wxExpr *image_to_expr = database.HashFind(_T("shape"), image_to);
	398
	399	if (!image_to_expr)
	400	{
	401	// Error
	402	}
	403	wxExpr *image_from_expr = database.HashFind(_T("shape"), image_from);
	404
	405	if (!image_from_expr)
	406	{
	407	// Error
	408	}
	409
	410	if (image_to_expr && image_from_expr)
	411	{
	412	wxShape image_to_object = (wxShape )image_to_expr->GetClientData();
	413	wxShape image_from_object = (wxShape )image_from_expr->GetClientData();
	414
	415	if (image_to_object && image_from_object)
	416	{
	417	image_from_object->AddLine(shape, image_to_object, shape->GetAttachmentFrom(), shape->GetAttachmentTo());
	418	}
	419	}
	420	clause->SetClientData(shape);
	421
	422	m_shapeList->Append(shape);
	423	}
	424
	425	clause = database.FindClauseByFunctor(_T("line"));
	426	}
	427	}
	428
	429	// Containers have divisions that reference adjoining divisions,
	430	// so we need a separate pass to link everything up.
	431	// Also used by Symbol Library.
	432	void wxDiagram::ReadContainerGeometry(wxExprDatabase& database)
	433	{
	434	database.BeginFind();
	435	wxExpr *clause = database.FindClauseByFunctor(_T("shape"));
	436	while (clause)
	437	{
	438	wxShape image = (wxShape )clause->GetClientData();
	439	if (image && image->IsKindOf(CLASSINFO(wxCompositeShape)))
	440	{
	441	wxCompositeShape composite = (wxCompositeShape )image;
	442	wxExpr *divisionExpr = NULL;
	443
	444	// Find the list of divisions in the composite
	445	clause->GetAttributeValue(_T("divisions"), &divisionExpr);
	446	if (divisionExpr)
	447	{
	448	int i = 0;
	449	wxExpr *idExpr = divisionExpr->Nth(i);
	450	while (idExpr)
	451	{
	452	long divisionId = idExpr->IntegerValue();
	453	wxExpr *childExpr = database.HashFind(_T("shape"), divisionId);
	454	if (childExpr && childExpr->GetClientData())
	455	{
	456	wxDivisionShape child = (wxDivisionShape )childExpr->GetClientData();
	457	composite->GetDivisions().Append(child);
	458
	459	// Find the adjoining shapes
	460	long leftSideId = -1;
	461	long topSideId = -1;
	462	long rightSideId = -1;
	463	long bottomSideId = -1;
	464	childExpr->GetAttributeValue(_T("left_side"), leftSideId);
	465	childExpr->GetAttributeValue(_T("top_side"), topSideId);
	466	childExpr->GetAttributeValue(_T("right_side"), rightSideId);
	467	childExpr->GetAttributeValue(_T("bottom_side"), bottomSideId);
	468	if (leftSideId > -1)
	469	{
	470	wxExpr *leftExpr = database.HashFind(_T("shape"), leftSideId);
	471	if (leftExpr && leftExpr->GetClientData())
	472	{
	473	wxDivisionShape leftSide = (wxDivisionShape )leftExpr->GetClientData();
	474	child->SetLeftSide(leftSide);
	475	}
	476	}
	477	if (topSideId > -1)
	478	{
	479	wxExpr *topExpr = database.HashFind(_T("shape"), topSideId);
	480	if (topExpr && topExpr->GetClientData())
	481	{
	482	wxDivisionShape topSide = (wxDivisionShape )topExpr->GetClientData();
	483	child->SetTopSide(topSide);
	484	}
	485	}
	486	if (rightSideId > -1)
	487	{
	488	wxExpr *rightExpr = database.HashFind(_T("shape"), rightSideId);
	489	if (rightExpr && rightExpr->GetClientData())
	490	{
	491	wxDivisionShape rightSide = (wxDivisionShape )rightExpr->GetClientData();
	492	child->SetRightSide(rightSide);
	493	}
	494	}
	495	if (bottomSideId > -1)
	496	{
	497	wxExpr *bottomExpr = database.HashFind(_T("shape"), bottomSideId);
	498	if (bottomExpr && bottomExpr->GetClientData())
	499	{
	500	wxDivisionShape bottomSide = (wxDivisionShape )bottomExpr->GetClientData();
	501	child->SetBottomSide(bottomSide);
	502	}
	503	}
	504	}
	505	i ++;
	506	idExpr = divisionExpr->Nth(i);
	507	}
	508	}
	509	}
	510
	511	clause = database.FindClauseByFunctor(_T("shape"));
	512	}
	513	}
	514
	515	// Allow for modifying file
	516	bool wxDiagram::OnDatabaseLoad(wxExprDatabase& WXUNUSED(db))
	517	{
	518	return true;
	519	}
	520
	521	bool wxDiagram::OnDatabaseSave(wxExprDatabase& WXUNUSED(db))
	522	{
	523	return true;
	524	}
	525
	526	bool wxDiagram::OnShapeSave(wxExprDatabase& db, wxShape& shape, wxExpr& expr)
	527	{
	528	shape.WriteAttributes(&expr);
	529	db.Append(&expr);
	530
	531	if (shape.IsKindOf(CLASSINFO(wxCompositeShape)))
	532	{
	533	wxNode *node = shape.GetChildren().GetFirst();
	534	while (node)
	535	{
	536	wxShape childShape = (wxShape )node->GetData();
	537	wxExpr *childExpr = new wxExpr(_T("shape"));
	538	OnShapeSave(db, childShape, childExpr);
	539	node = node->GetNext();
	540	}
	541	}
	542
	543	return true;
	544	}
	545
	546	bool wxDiagram::OnShapeLoad(wxExprDatabase& WXUNUSED(db), wxShape& shape, wxExpr& expr)
	547	{
	548	shape.ReadAttributes(&expr);
	549	return true;
	550	}
	551
	552	bool wxDiagram::OnHeaderSave(wxExprDatabase& WXUNUSED(db), wxExpr& WXUNUSED(expr))
	553	{
	554	return true;
	555	}
	556
	557	bool wxDiagram::OnHeaderLoad(wxExprDatabase& WXUNUSED(db), wxExpr& WXUNUSED(expr))
	558	{
	559	return true;
	560	}
	561
	562	#endif
	563
	564	void wxDiagram::SetCanvas(wxShapeCanvas *can)
	565	{
	566	m_diagramCanvas = can;
	567	}
	568
	569	// Find a shape by its id
	570	wxShape* wxDiagram::FindShape(long id) const
	571	{
	572	wxNode* node = GetShapeList()->GetFirst();
	573	while (node)
	574	{
	575	wxShape* shape = (wxShape*) node->GetData();
	576	if (shape->GetId() == id)
	577	return shape;
	578	node = node->GetNext();
	579	}
	580	return NULL;
	581	}
	582
	583
	584	//// Crossings classes
	585
	586	wxLineCrossings::wxLineCrossings()
	587	{
	588	}
	589
	590	wxLineCrossings::~wxLineCrossings()
	591	{
	592	ClearCrossings();
	593	}
	594
	595	void wxLineCrossings::FindCrossings(wxDiagram& diagram)
	596	{
	597	ClearCrossings();
	598	wxNode* node1 = diagram.GetShapeList()->GetFirst();
	599	while (node1)
	600	{
	601	wxShape* shape1 = (wxShape*) node1->GetData();
	602	if (shape1->IsKindOf(CLASSINFO(wxLineShape)))
	603	{
	604	wxLineShape* lineShape1 = (wxLineShape*) shape1;
	605	// Iterate through the segments
	606	wxList* pts1 = lineShape1->GetLineControlPoints();
	607	size_t i;
	608	for (i = 0; i < (pts1->GetCount() - 1); i++)
	609	{
	610	wxRealPoint* pt1_a = (wxRealPoint*) (pts1->Item(i)->GetData());
	611	wxRealPoint* pt1_b = (wxRealPoint*) (pts1->Item(i+1)->GetData());
	612
	613	// Now we iterate through the segments again
	614
	615	wxNode* node2 = diagram.GetShapeList()->GetFirst();
	616	while (node2)
	617	{
	618	wxShape* shape2 = (wxShape*) node2->GetData();
	619
	620	// Assume that the same line doesn't cross itself
	621	if (shape2->IsKindOf(CLASSINFO(wxLineShape)) && (shape1 != shape2))
	622	{
	623	wxLineShape* lineShape2 = (wxLineShape*) shape2;
	624	// Iterate through the segments
	625	wxList* pts2 = lineShape2->GetLineControlPoints();
	626	int j;
	627	for (j = 0; j < (int) (pts2->GetCount() - 1); j++)
	628	{
	629	wxRealPoint* pt2_a = (wxRealPoint*) (pts2->Item(j)->GetData());
	630	wxRealPoint* pt2_b = (wxRealPoint*) (pts2->Item(j+1)->GetData());
	631
	632	// Now let's see if these two segments cross.
	633	double ratio1, ratio2;
	634	oglCheckLineIntersection(pt1_a->x, pt1_a->y, pt1_b->x, pt1_b->y,
	635	pt2_a->x, pt2_a->y, pt2_b->x, pt2_b->y,
	636	& ratio1, & ratio2);
	637
	638	if ((ratio1 < 1.0) && (ratio1 > -1.0))
	639	{
	640	// Intersection!
	641	wxLineCrossing* crossing = new wxLineCrossing;
	642	crossing->m_intersect.x = (pt1_a->x + (pt1_b->x - pt1_a->x)*ratio1);
	643	crossing->m_intersect.y = (pt1_a->y + (pt1_b->y - pt1_a->y)*ratio1);
	644
	645	crossing->m_pt1 = * pt1_a;
	646	crossing->m_pt2 = * pt1_b;
	647	crossing->m_pt3 = * pt2_a;
	648	crossing->m_pt4 = * pt2_b;
	649
	650	crossing->m_lineShape1 = lineShape1;
	651	crossing->m_lineShape2 = lineShape2;
	652
	653	m_crossings.Append(crossing);
	654	}
	655	}
	656	}
	657	node2 = node2->GetNext();
	658	}
	659	}
	660	}
	661
	662	node1 = node1->GetNext();
	663	}
	664	}
	665
	666	void wxLineCrossings::DrawCrossings(wxDiagram& WXUNUSED(diagram), wxDC& dc)
	667	{
	668	dc.SetBrush(*wxTRANSPARENT_BRUSH);
	669
	670	long arcWidth = 8;
	671
	672	wxNode* node = m_crossings.GetFirst();
	673	while (node)
	674	{
	675	wxLineCrossing* crossing = (wxLineCrossing*) node->GetData();
	676	// dc.DrawEllipse((long) (crossing->m_intersect.x - (arcWidth/2.0) + 0.5), (long) (crossing->m_intersect.y - (arcWidth/2.0) + 0.5),
	677	// arcWidth, arcWidth);
	678
	679
	680	// Let's do some geometry to find the points on either end of the arc.
	681	/*
	682
	683	(x1, y1)
	684	\|\
	685	\| \
	686	\| \
	687	\| \
	688	\| \
	689	\| \|\ c c1
	690	\| a \| \
	691	\| \
	692	\| - x <-- centre of arc
	693	a1 \| b \|\
	694	\| \| \ c2
	695	\| a2 \| \
	696	\| - \
	697	\| b2 \
	698	\| \
	699	\|_______________\ (x2, y2)
	700	b1
	701
	702	*/
	703
	704	double a1 = wxMax(crossing->m_pt1.y, crossing->m_pt2.y) - wxMin(crossing->m_pt1.y, crossing->m_pt2.y) ;
	705	double b1 = wxMax(crossing->m_pt1.x, crossing->m_pt2.x) - wxMin(crossing->m_pt1.x, crossing->m_pt2.x) ;
	706	double c1 = sqrt( (a1a1) + (b1b1) );
	707
	708	double c = arcWidth / 2.0;
	709	double a = c * a1/c1 ;
	710	double b = c * b1/c1 ;
	711
	712	// I'm not sure this is right, since we don't know which direction we should be going in - need
	713	// to know which way the line slopes and choose the sign appropriately.
	714	double arcX1 = crossing->m_intersect.x - b;
	715	double arcY1 = crossing->m_intersect.y - a;
	716
	717	double arcX2 = crossing->m_intersect.x + b;
	718	double arcY2 = crossing->m_intersect.y + a;
	719
	720	dc.SetPen(*wxBLACK_PEN);
	721	dc.DrawArc( (long) arcX1, (long) arcY1, (long) arcX2, (long) arcY2,
	722	(long) crossing->m_intersect.x, (long) crossing->m_intersect.y);
	723
	724	dc.SetPen(*wxWHITE_PEN);
	725	dc.DrawLine( (long) arcX1, (long) arcY1, (long) arcX2, (long) arcY2 );
	726
	727	node = node->GetNext();
	728	}
	729	}
	730
	731	void wxLineCrossings::ClearCrossings()
	732	{
	733	wxNode* node = m_crossings.GetFirst();
	734	while (node)
	735	{
	736	wxLineCrossing* crossing = (wxLineCrossing*) node->GetData();
	737	delete crossing;
	738	node = node->GetNext();
	739	}
	740	m_crossings.Clear();
	741	}
	742