module dataObjects AbstractObject import dcollections ArrayList import

module dataObjects.AbstractObject;


import dcollections.ArrayList;
//import tango.core.Array;
import tango.text.Util; 

package import graphics.Renderer;
import graphics.Color;
import dataObjects.Bound;

import tango.io.Stdout;

char[] getFileName(char[] fullPath)
{
	char[] delimiter = "/";
	version (windows)
	{
		delimiter = "\\";
	}
	char[][] strList = split(fullPath, delimiter);
	char[] retVal = strList[strList.length-1];
	return retVal;
}

abstract class AbstractObject
{
protected:
	ArrayList!(AbstractObject) _children;
//	AbstractObject[] _children;

private:
	AbstractObject _parent;
	
public:
	char[] objectName;
	
	this(AbstractObject parentObject = null)
	{
		_parent = parentObject;
		_children = new ArrayList!(AbstractObject);
	}
	
	abstract void acceptRenderer(Renderer renderer);

	Bound bound;
	
	void calculateBounds(inout Bound globalBound)
	{
		if (!globalBound.newCountCycle)
		{
			 globalBound.minX = bound.minX;
			 globalBound.maxX = bound.maxX;
			 globalBound.minY = bound.minY;
			 globalBound.maxY = bound.maxY;
			 globalBound.minZ = bound.minZ;
			 globalBound.maxZ = bound.maxZ;
			 globalBound.newCountCycle = true;

			 return;
		}
		
		if ( bound.minX < globalBound.minX)
			 globalBound.minX = bound.minX;
		if ( bound.maxX > globalBound.maxX)
			 globalBound.maxX = bound.maxX;
		if ( bound.minY < globalBound.minY)
			 globalBound.minY = bound.minY;
		if ( bound.maxY > globalBound.maxY)
			 globalBound.maxY = bound.maxY;
		if ( bound.minZ < globalBound.minZ)
			 globalBound.minZ = bound.minZ;
		if ( bound.maxZ > globalBound.maxZ)
			 globalBound.maxZ = bound.maxZ;
	}
	
	bool visible;
	
	/* Tree functionality */

	AbstractObject parent() { return _parent; }
	
	void appendChild(AbstractObject child)
	{
		_children.add(child);
//		_children ~= child;

		child._parent = this;
	}
	
	void removeChild(AbstractObject child)
	{
		_children.remove(child);
//		remove(_children, child);
	}
	
	uint pos()
	{
		return parent._children.indexOf(this);
//		return find(parent._children, this);
	}
	
	uint childCount()
	{
		return _children.length;
	}
	
	AbstractObject child(int pos)
	{
		if( pos > 0 || pos < _children.length )
			return _children[pos];
		else
			return null;
	}
}

template SingleColored()
{
	protected Color color;
}