[wxWidgets.git] / utils / wxtree / src / wxtree.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        tree.h
// Purpose:     wxTreeLayout class
// Author:      Julian Smart
// Modified by: 
// Created:     7/4/98
// RCS-ID:      $Id$
// Copyright:   (c) 1998 Julian Smart
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "wxtree.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 "wxtree.h"

/*
 * Abstract tree
 *
 */

IMPLEMENT_ABSTRACT_CLASS(wxTreeLayout, wxObject)

wxTreeLayout::wxTreeLayout()
{
  m_xSpacing = 16;
  m_ySpacing = 20;
  m_topMargin = 5;
  m_leftMargin = 5;
  m_orientation = FALSE;
  m_parentNode = 0;
}

void wxTreeLayout::DoLayout(wxDC& dc, long topId)
{
  if (topId != -1)
    SetTopNode(topId);

  long actualTopId = GetTopNode();
  long id = actualTopId;
  while (id != -1)
  {
    SetNodeX(id, 0);
    SetNodeY(id, 0);
    ActivateNode(id, FALSE);
    id = GetNextNode(id);
  }
  m_lastY = m_topMargin;
  m_lastX = m_leftMargin;
  CalcLayout(actualTopId, 0, dc);
}

void wxTreeLayout::Draw(wxDC& dc)
{
    dc.Clear();
    DrawBranches(dc);
    DrawNodes(dc);
}

void wxTreeLayout::DrawNodes(wxDC& dc)
{  
  long id = GetTopNode();
  while (id != -1)
  {
    if (NodeActive(id))
      DrawNode(id, dc);
    id = GetNextNode(id);
  }
}

void wxTreeLayout::DrawBranches(wxDC& dc)
{  
  long id = GetTopNode();
  while (id != -1)
  {
    if (GetNodeParent(id) > -1)
    {
      long parent = GetNodeParent(id);
      if (NodeActive(parent))
        DrawBranch(parent, id, dc);
    }
    id = GetNextNode(id);
  }
}

void wxTreeLayout::DrawNode(long id, wxDC& dc)
{
  char buf[80];
  wxString name(GetNodeName(id));
  if (name != "")
    sprintf(buf, "%s", (const char*) name);
  else
    sprintf(buf, "<unnamed>");

  long x = 80;
  long y = 20;
  dc.GetTextExtent(buf, &x, &y);
  dc.DrawText(buf, GetNodeX(id), (long)(GetNodeY(id) - (y/2.0)));
}

void wxTreeLayout::DrawBranch(long from, long to, wxDC& dc)
{
    long w, h;
    GetNodeSize(from, &w, &h, dc);
    dc.DrawLine(GetNodeX(from)+w, GetNodeY(from),
                              GetNodeX(to), GetNodeY(to));
}

void wxTreeLayout::Initialize(void)
{
}

void wxTreeLayout::GetNodeSize(long id, long *x, long *y, wxDC& dc)
{
  wxString name(GetNodeName(id));
  if (name != "")
    dc.GetTextExtent(name, x, y);
  else
  {
    *x = 70; *y = 20;
  }
}

void wxTreeLayout::CalcLayout(long nodeId, int level, wxDC& dc)
{
  wxList children;
  GetChildren(nodeId, children);
  int n = children.Number();

  if (m_orientation == FALSE)
  {
    // Left to right
    // X Calculations
    if (level == 0)
      SetNodeX(nodeId, m_leftMargin);
    else
    {
      long x = 0;
      long y = 0;
      long parentId = GetNodeParent(nodeId);
      if (parentId != -1)
        GetNodeSize(parentId, &x, &y, dc);
      SetNodeX(nodeId, (long)(GetNodeX(parentId) + m_xSpacing + x));
    }

    wxNode *node = children.First();
    while (node)
    {
      CalcLayout((long)node->Data(), level+1, dc);
      node = node->Next();
    }

    // Y Calculations
    long averageY;
    ActivateNode(nodeId, TRUE);
  
    if (n > 0)
    {
      averageY = 0;
      node = children.First();
      while (node)
      {
        averageY += GetNodeY((long)node->Data());
        node = node->Next();
      }
      averageY = averageY / n;
      SetNodeY(nodeId, averageY);
    }
    else
    {
      SetNodeY(nodeId, m_lastY);
      long x, y;
      GetNodeSize(nodeId, &x, &y, dc);
 
      m_lastY = m_lastY + y + m_ySpacing;
    }
  }
  else
  {
    // Top to bottom
    
    // Y Calculations
    if (level == 0)
      SetNodeY(nodeId, m_topMargin);
    else
    {
      long x = 0;
      long y = 0;
      long parentId = GetNodeParent(nodeId);
      if (parentId != -1)
        GetNodeSize(parentId, &x, &y, dc);
      SetNodeY(nodeId, (long)(GetNodeY(parentId) + m_ySpacing + y));
    }

    wxNode *node = children.First();
    while (node)
    {
      CalcLayout((long)node->Data(), level+1, dc);
      node = node->Next();
    }

    // X Calculations
    long averageX;
    ActivateNode(nodeId, TRUE);
  
    if (n > 0)
    {
      averageX = 0;
      node = children.First();
      while (node)
      {
        averageX += GetNodeX((long)node->Data());
        node = node->Next();
      }
      averageX = averageX / n;
      SetNodeX(nodeId, averageX);
    }
    else
    {
      SetNodeX(nodeId, m_lastX);
      long x, y;
      GetNodeSize(nodeId, &x, &y, dc);
 
      m_lastX = m_lastX + x + m_xSpacing;
    }
  }
}

/*
 * Tree with storage
 *
 */

IMPLEMENT_DYNAMIC_CLASS(wxStoredTree, wxTreeLayout)

wxStoredTree::wxStoredTree(int n):wxTreeLayout()
{
  m_nodes = NULL;
  m_maxNodes = 0;
  Initialize(n);
}

wxStoredTree::~wxStoredTree(void)
{
  if (m_nodes)
    delete[] m_nodes;
}

void wxStoredTree::Initialize(int n)
{
  m_maxNodes = n;
  wxTreeLayout::Initialize();
  if (m_nodes) delete[] m_nodes;
  m_nodes = new wxStoredNode[m_maxNodes];
  int i;
  for (i = 0; i < n; i++)
  {
    m_nodes[i].m_name = "";
    m_nodes[i].m_active = FALSE;
    m_nodes[i].m_parentId = -1;
    m_nodes[i].m_x = 0;
    m_nodes[i].m_y = 0;
  }
  m_num = 0;
}

long wxStoredTree::AddChild(const wxString& name, const wxString& parent)
{
  if (m_num < (m_maxNodes -1 ))
  {
    long i = -1;
    if (parent != "")
      i = NameToId(parent);
    else m_parentNode = m_num;

    m_nodes[m_num].m_parentId = i;
    m_nodes[m_num].m_name = name;
    m_nodes[m_num].m_x = m_nodes[m_num].m_y = 0;
    m_nodes[m_num].m_clientData = 0;
    m_num ++;

    return (m_num - 1);
  }
  else
    return -1;
}

long wxStoredTree::NameToId(const wxString& name)
{
  long i;
  for (i = 0; i < m_num; i++)
    if (name == m_nodes[i].m_name)
      return i;
  return -1;
}

void wxStoredTree::GetChildren(long id, wxList& list)
{
  long currentId = GetTopNode();
  while (currentId != -1)
  {
    if (id == GetNodeParent(currentId))
      list.Append((wxObject *)currentId);
    currentId = GetNextNode(currentId);
  }
}

wxStoredNode* wxStoredTree::GetNode(long idx) const
{
    wxASSERT(idx < m_num);

    return &m_nodes[idx];
};

long wxStoredTree::GetNodeX(long id)
{
    wxASSERT(id < m_num);

    return (long)m_nodes[id].m_x;
}

long wxStoredTree::GetNodeY(long id)
{
    wxASSERT(id < m_num);

    return (long)m_nodes[id].m_y;
}

void wxStoredTree::SetNodeX(long id, long x)
{
    wxASSERT(id < m_num);

    m_nodes[id].m_x = (int)x;
}

void wxStoredTree::SetNodeY(long id, long y)
{
    wxASSERT(id < m_num);

    m_nodes[id].m_y = (int)y;
}

void wxStoredTree::SetNodeName(long id, const wxString& name)
{
    wxASSERT(id < m_num);

    m_nodes[id].m_name = name;
}

wxString wxStoredTree::GetNodeName(long id)
{
    wxASSERT(id < m_num);

    return m_nodes[id].m_name;
}

long wxStoredTree::GetNodeParent(long id)
{
  if (id != -1)
  {
    wxASSERT(id < m_num);

    return m_nodes[id].m_parentId;
  }
  else
    return -1;
}

long wxStoredTree::GetNextNode(long id)
{
  wxASSERT(id < m_num);

  if ((id != -1) && (id < (m_num - 1)))
    return id + 1;
  else
    return -1;
}

void wxStoredTree::SetClientData(long id, long clientData)
{
    wxASSERT(id < m_num);

    m_nodes[id].m_clientData = clientData;
}

long wxStoredTree::GetClientData(long id) const
{
    wxASSERT(id < m_num);

    return m_nodes[id].m_clientData;
}

void wxStoredTree::ActivateNode(long id, bool active)
{
    wxASSERT(id < m_num);

    m_nodes[id].m_active = active;
}

bool wxStoredTree::NodeActive(long id)
{
    wxASSERT(id < m_num);

    return m_nodes[id].m_active;
}

wxString wxStoredTree::HitTest(wxMouseEvent& event, wxDC& dc)
{
	long x, y;
	event.Position(&x, &y);

        int i;
	for (i = 0; i < m_maxNodes; i++)
	{
		wxStoredNode* item = &m_nodes[i];

		long width, height;
		dc.GetTextExtent(m_nodes[i].m_name, &width, &height);

		if ( (x >= (m_nodes[i].m_x-10)) && (x < (m_nodes[i].m_x + width+10)) &&
					(y >= m_nodes[i].m_y-10) && (y < (m_nodes[i].m_y + height+10)) )
		{
			return m_nodes[i].m_name;
		}
	}

	return wxString("");
}
Commit	Line	Data
4414cc1d JS	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: tree.h
	3	// Purpose: wxTreeLayout class
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 7/4/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1998 Julian Smart
	9	// Licence: wxWindows licence
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "wxtree.h"
	14	#endif
	15
	16	// For compilers that support precompilation, includes "wx.h".
	17	#include <wx/wxprec.h>
	18
	19	#ifdef __BORLANDC__
	20	#pragma hdrstop
	21	#endif
	22
	23	#ifndef WX_PRECOMP
	24	#include <wx/wx.h>
	25	#endif
	26
	27	#include "wxtree.h"
	28
	29	/*
	30	* Abstract tree
	31	*
	32	*/
	33
	34	IMPLEMENT_ABSTRACT_CLASS(wxTreeLayout, wxObject)
	35
	36	wxTreeLayout::wxTreeLayout()
	37	{
	38	m_xSpacing = 16;
	39	m_ySpacing = 20;
	40	m_topMargin = 5;
	41	m_leftMargin = 5;
	42	m_orientation = FALSE;
	43	m_parentNode = 0;
	44	}
	45
	46	void wxTreeLayout::DoLayout(wxDC& dc, long topId)
	47	{
	48	if (topId != -1)
	49	SetTopNode(topId);
	50
	51	long actualTopId = GetTopNode();
	52	long id = actualTopId;
	53	while (id != -1)
	54	{
	55	SetNodeX(id, 0);
	56	SetNodeY(id, 0);
	57	ActivateNode(id, FALSE);
	58	id = GetNextNode(id);
	59	}
	60	m_lastY = m_topMargin;
	61	m_lastX = m_leftMargin;
	62	CalcLayout(actualTopId, 0, dc);
	63	}
	64
65	void wxTreeLayout::Draw(wxDC& dc)
66	{
67	dc.Clear();
68	DrawBranches(dc);
69	DrawNodes(dc);
70	}
71
72	void wxTreeLayout::DrawNodes(wxDC& dc)
73	{
74	long id = GetTopNode();
75	while (id != -1)
76	{
77	if (NodeActive(id))
78	DrawNode(id, dc);
79	id = GetNextNode(id);
80	}
81	}
82
83	void wxTreeLayout::DrawBranches(wxDC& dc)
84	{
85	long id = GetTopNode();
86	while (id != -1)
87	{
88	if (GetNodeParent(id) > -1)
89	{
90	long parent = GetNodeParent(id);
91	if (NodeActive(parent))
92	DrawBranch(parent, id, dc);
93	}
94	id = GetNextNode(id);
95	}
96	}
97
98	void wxTreeLayout::DrawNode(long id, wxDC& dc)
99	{
100	char buf[80];
101	wxString name(GetNodeName(id));
102	if (name != "")
103	sprintf(buf, "%s", (const char*) name);
104	else
105	sprintf(buf, "<unnamed>");
106
107	long x = 80;
108	long y = 20;
109	dc.GetTextExtent(buf, &x, &y);
110	dc.DrawText(buf, GetNodeX(id), (long)(GetNodeY(id) - (y/2.0)));
111	}
112
113	void wxTreeLayout::DrawBranch(long from, long to, wxDC& dc)
114	{
115	long w, h;
116	GetNodeSize(from, &w, &h, dc);
117	dc.DrawLine(GetNodeX(from)+w, GetNodeY(from),
118	GetNodeX(to), GetNodeY(to));
119	}
120
121	void wxTreeLayout::Initialize(void)
122	{
123	}
124
125	void wxTreeLayout::GetNodeSize(long id, long x, long y, wxDC& dc)
126	{
127	wxString name(GetNodeName(id));
128	if (name != "")
129	dc.GetTextExtent(name, x, y);
130	else
131	{
132	x = 70; y = 20;
133	}
134	}
135
136	void wxTreeLayout::CalcLayout(long nodeId, int level, wxDC& dc)
137	{
138	wxList children;
139	GetChildren(nodeId, children);
140	int n = children.Number();
141
142	if (m_orientation == FALSE)
143	{
144	// Left to right
145	// X Calculations
146	if (level == 0)
147	SetNodeX(nodeId, m_leftMargin);
148	else
149	{
150	long x = 0;
151	long y = 0;
152	long parentId = GetNodeParent(nodeId);
153	if (parentId != -1)
154	GetNodeSize(parentId, &x, &y, dc);
155	SetNodeX(nodeId, (long)(GetNodeX(parentId) + m_xSpacing + x));
156	}
157
158	wxNode *node = children.First();
159	while (node)
160	{
161	CalcLayout((long)node->Data(), level+1, dc);
162	node = node->Next();
163	}
164
165	// Y Calculations
166	long averageY;
167	ActivateNode(nodeId, TRUE);
168
169	if (n > 0)
170	{
171	averageY = 0;
172	node = children.First();
173	while (node)
174	{
175	averageY += GetNodeY((long)node->Data());
176	node = node->Next();
177	}
178	averageY = averageY / n;
179	SetNodeY(nodeId, averageY);
180	}
181	else
182	{
183	SetNodeY(nodeId, m_lastY);
184	long x, y;
185	GetNodeSize(nodeId, &x, &y, dc);
186
187	m_lastY = m_lastY + y + m_ySpacing;
188	}
189	}
190	else
191	{
192	// Top to bottom
193
194	// Y Calculations
195	if (level == 0)
196	SetNodeY(nodeId, m_topMargin);
197	else
198	{
199	long x = 0;
200	long y = 0;
201	long parentId = GetNodeParent(nodeId);
202	if (parentId != -1)
203	GetNodeSize(parentId, &x, &y, dc);
204	SetNodeY(nodeId, (long)(GetNodeY(parentId) + m_ySpacing + y));
205	}
206
207	wxNode *node = children.First();
208	while (node)
209	{
210	CalcLayout((long)node->Data(), level+1, dc);
211	node = node->Next();
212	}
213
214	// X Calculations
215	long averageX;
216	ActivateNode(nodeId, TRUE);
217
218	if (n > 0)
219	{
220	averageX = 0;
221	node = children.First();
222	while (node)
223	{
224	averageX += GetNodeX((long)node->Data());
225	node = node->Next();
226	}
227	averageX = averageX / n;
228	SetNodeX(nodeId, averageX);
229	}
230	else
231	{
232	SetNodeX(nodeId, m_lastX);
233	long x, y;
234	GetNodeSize(nodeId, &x, &y, dc);
235
236	m_lastX = m_lastX + x + m_xSpacing;
237	}
238	}
239	}
240
241	/*
242	* Tree with storage
243	*
244	*/
245
246	IMPLEMENT_DYNAMIC_CLASS(wxStoredTree, wxTreeLayout)
247
248	wxStoredTree::wxStoredTree(int n):wxTreeLayout()
249	{
250	m_nodes = NULL;
251	m_maxNodes = 0;
252	Initialize(n);
253	}
254
255	wxStoredTree::~wxStoredTree(void)
256	{
257	if (m_nodes)
258	delete[] m_nodes;
259	}
260
261	void wxStoredTree::Initialize(int n)
262	{
263	m_maxNodes = n;
264	wxTreeLayout::Initialize();
265	if (m_nodes) delete[] m_nodes;
266	m_nodes = new wxStoredNode[m_maxNodes];
267	int i;
268	for (i = 0; i < n; i++)
269	{
270	m_nodes[i].m_name = "";
271	m_nodes[i].m_active = FALSE;
272	m_nodes[i].m_parentId = -1;
273	m_nodes[i].m_x = 0;
274	m_nodes[i].m_y = 0;
275	}
276	m_num = 0;
277	}
278
279	long wxStoredTree::AddChild(const wxString& name, const wxString& parent)
280	{
281	if (m_num < (m_maxNodes -1 ))
282	{
283	long i = -1;
284	if (parent != "")
285	i = NameToId(parent);
286	else m_parentNode = m_num;
287
288	m_nodes[m_num].m_parentId = i;
289	m_nodes[m_num].m_name = name;
290	m_nodes[m_num].m_x = m_nodes[m_num].m_y = 0;
291	m_nodes[m_num].m_clientData = 0;
292	m_num ++;
293
294	return (m_num - 1);
295	}
296	else
297	return -1;
298	}
299
300	long wxStoredTree::NameToId(const wxString& name)
301	{
302	long i;
303	for (i = 0; i < m_num; i++)
304	if (name == m_nodes[i].m_name)
305	return i;
306	return -1;
307	}
308
309	void wxStoredTree::GetChildren(long id, wxList& list)
310	{
311	long currentId = GetTopNode();
312	while (currentId != -1)
313	{
314	if (id == GetNodeParent(currentId))
315	list.Append((wxObject *)currentId);
316	currentId = GetNextNode(currentId);
317	}
318	}
319
6dd2244b	320	wxStoredNode* wxStoredTree::GetNode(long idx) const
4414cc1d JS	321	{
	322	wxASSERT(idx < m_num);
	323
	324	return &m_nodes[idx];
	325	};
	326
	327	long wxStoredTree::GetNodeX(long id)
	328	{
	329	wxASSERT(id < m_num);
	330
	331	return (long)m_nodes[id].m_x;
	332	}
	333
	334	long wxStoredTree::GetNodeY(long id)
	335	{
	336	wxASSERT(id < m_num);
	337
	338	return (long)m_nodes[id].m_y;
	339	}
	340
	341	void wxStoredTree::SetNodeX(long id, long x)
	342	{
	343	wxASSERT(id < m_num);
	344
	345	m_nodes[id].m_x = (int)x;
	346	}
	347
	348	void wxStoredTree::SetNodeY(long id, long y)
	349	{
	350	wxASSERT(id < m_num);
	351
	352	m_nodes[id].m_y = (int)y;
	353	}
	354
	355	void wxStoredTree::SetNodeName(long id, const wxString& name)
	356	{
	357	wxASSERT(id < m_num);
	358
	359	m_nodes[id].m_name = name;
	360	}
	361
	362	wxString wxStoredTree::GetNodeName(long id)
	363	{
	364	wxASSERT(id < m_num);
	365
	366	return m_nodes[id].m_name;
	367	}
	368
	369	long wxStoredTree::GetNodeParent(long id)
	370	{
	371	if (id != -1)
	372	{
	373	wxASSERT(id < m_num);
	374
	375	return m_nodes[id].m_parentId;
	376	}
	377	else
	378	return -1;
	379	}
	380
	381	long wxStoredTree::GetNextNode(long id)
	382	{
	383	wxASSERT(id < m_num);
	384
385	if ((id != -1) && (id < (m_num - 1)))
386	return id + 1;
387	else
388	return -1;
389	}
390
391	void wxStoredTree::SetClientData(long id, long clientData)
392	{
393	wxASSERT(id < m_num);
394
395	m_nodes[id].m_clientData = clientData;
396	}
397
398	long wxStoredTree::GetClientData(long id) const
399	{
400	wxASSERT(id < m_num);
401
402	return m_nodes[id].m_clientData;
403	}
404
405	void wxStoredTree::ActivateNode(long id, bool active)
406	{
407	wxASSERT(id < m_num);
408
409	m_nodes[id].m_active = active;
410	}
411
412	bool wxStoredTree::NodeActive(long id)
413	{
414	wxASSERT(id < m_num);
415
416	return m_nodes[id].m_active;
417	}
418
419	wxString wxStoredTree::HitTest(wxMouseEvent& event, wxDC& dc)
420	{
421	long x, y;
422	event.Position(&x, &y);
423
424	int i;
425	for (i = 0; i < m_maxNodes; i++)
426	{
427	wxStoredNode* item = &m_nodes[i];
428
429	long width, height;
430	dc.GetTextExtent(m_nodes[i].m_name, &width, &height);
431
432	if ( (x >= (m_nodes[i].m_x-10)) && (x < (m_nodes[i].m_x + width+10)) &&
433	(y >= m_nodes[i].m_y-10) && (y < (m_nodes[i].m_y + height+10)) )
434	{
435	return m_nodes[i].m_name;
436	}
437	}
438
439	return wxString("");
440	}