//+-----------------------------------------------------------------------------
VOID NODE_MANAGER_WINDOW::RemoveNode(MODEL_BASE* Node)
{
	TreeView_DeleteItem(TreeView.GetWindow(), Node->BaseData()->TreeViewItem);
	Node->BaseData()->TreeViewItem = NULL;
}


//+-----------------------------------------------------------------------------
//| Clears all nodes
//+-----------------------------------------------------------------------------
VOID NODE_MANAGER_WINDOW::ClearAllNodes()
{
	TreeView.Clear();
}


//+-----------------------------------------------------------------------------
//| Returns the current parent node
//+-----------------------------------------------------------------------------
MODEL_BASE* NODE_MANAGER_WINDOW::GetCurrentParent()
{
	if(CurrentlySelectedNode == NULL) return NULL;

	return CurrentlySelectedNode;
}


//+-----------------------------------------------------------------------------
//| Creates a new attachment
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::CreateNewAttachment()
{
	MODEL_ATTACHMENT* Attachment;

	Attachment = new MODEL_ATTACHMENT();
	if(Attachment == NULL)
	{
		Error.SetMessage("Unable to create a new attachment, memory allocation failed!");
		return FALSE;
	}

	if(!Model.AddAttachment(Attachment, GetCurrentParent()))
	{
		delete Attachment;
		return FALSE;
	}

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates a new bone
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::CreateNewBone()
{
	MODEL_BONE* Bone;

	Bone = new MODEL_BONE();
	if(Bone == NULL)
	{
		Error.SetMessage("Unable to create a new bone, memory allocation failed!");
		return FALSE;
	}

	if(!Model.AddBone(Bone, GetCurrentParent()))
	{
		delete Bone;
		return FALSE;
	}

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates a new collision shape
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::CreateNewCollisionShape()
{
	MODEL_COLLISION_SHAPE* CollisionShape;

	CollisionShape = new MODEL_COLLISION_SHAPE();
	if(CollisionShape == NULL)
	{
		Error.SetMessage("Unable to create a new collision shape, memory allocation failed!");
		return FALSE;
	}

	if(!Model.AddCollisionShape(CollisionShape, GetCurrentParent()))
	{
		delete CollisionShape;
		return FALSE;
	}

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates a new event object
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::CreateNewEventObject()
{
	MODEL_EVENT_OBJECT* EventObject;

	EventObject = new MODEL_EVENT_OBJECT();
	if(EventObject == NULL)
	{
		Error.SetMessage("Unable to create a new event object, memory allocation failed!");
		return FALSE;
	}

	if(!Model.AddEventObject(EventObject, GetCurrentParent()))
	{
		delete EventObject;
		return FALSE;
	}

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates a new helper
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::CreateNewHelper()
{
	MODEL_HELPER* Helper;

	Helper = new MODEL_HELPER();
	if(Helper == NULL)
	{
		Error.SetMessage("Unable to create a new helper, memory allocation failed!");
		return FALSE;
	}

	if(!Model.AddHelper(Helper, GetCurrentParent()))
	{
		delete Helper;
		return FALSE;
	}

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates a new light
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::CreateNewLight()
{
	MODEL_LIGHT* Light;

	Light = new MODEL_LIGHT();
	if(Light == NULL)
	{
		Error.SetMessage("Unable to create a new light, memory allocation failed!");
		return FALSE;
	}

	if(!Model.AddLight(Light, GetCurrentParent()))
	{
		delete Light;
		return FALSE;
	}

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates a new particle emitter
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::CreateNewParticleEmitter()
{
	MODEL_PARTICLE_EMITTER* ParticleEmitter;

	ParticleEmitter = new MODEL_PARTICLE_EMITTER();
	if(ParticleEmitter == NULL)
	{
		Error.SetMessage("Unable to create a new particle emitter, memory allocation failed!");
		return FALSE;
	}

	if(!Model.AddParticleEmitter(ParticleEmitter, GetCurrentParent()))
	{
		delete ParticleEmitter;
		return FALSE;
	}

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates a new particle emitter 2
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::CreateNewParticleEmitter2()
{
	MODEL_PARTICLE_EMITTER_2* ParticleEmitter2;

	ParticleEmitter2 = new MODEL_PARTICLE_EMITTER_2();
	if(ParticleEmitter2 == NULL)
	{
		Error.SetMessage("Unable to create a new particle emitter 2, memory allocation failed!");
		return FALSE;
	}

	if(!Model.AddParticleEmitter2(ParticleEmitter2, GetCurrentParent()))
	{
		delete ParticleEmitter2;
		return FALSE;
	}

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Creates a new ribbon emitter
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::CreateNewRibbonEmitter()
{
	MODEL_RIBBON_EMITTER* RibbonEmitter;

	RibbonEmitter = new MODEL_RIBBON_EMITTER();
	if(RibbonEmitter == NULL)
	{
		Error.SetMessage("Unable to create a new ribbon emitter, memory allocation failed!");
		return FALSE;
	}

	if(!Model.AddRibbonEmitter(RibbonEmitter, GetCurrentParent()))
	{
		delete RibbonEmitter;
		return FALSE;
	}

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Edits an existing attachment
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::EditAttachment(MODEL_ATTACHMENT* Attachment)
{
	if(!AttachmentDialog.Display(Window, Attachment->Data())) return TRUE;

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Edits an existing bone
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::EditBone(MODEL_BONE* Bone)
{
	MODEL_GEOSET* Geoset;
	MODEL_GEOSET_ANIMATION* GeosetAnimation;

	Geoset = Bone->GeosetNode.IsAttached() ? Bone->GeosetNode.GetObjectData() : NULL;
	GeosetAnimation = Bone->GeosetAnimationNode.IsAttached() ? Bone->GeosetAnimationNode.GetObjectData() : NULL;

	if(!BoneDialog.Display(Window, Bone->Data(), Geoset, GeosetAnimation)) return TRUE;

	if(Geoset != NULL)
	{
		Bone->GeosetNode.Attach(Geoset->BoneNodes);
	}
	else
	{
		Bone->GeosetNode.Detach();
	}

	if(GeosetAnimation != NULL)
	{
		Bone->GeosetAnimationNode.Attach(GeosetAnimation->BoneNodes);
	}
	else
	{
		Bone->GeosetAnimationNode.Detach();
	}

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Edits an existing collision shape
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::EditCollisionShape(MODEL_COLLISION_SHAPE* CollisionShape)
{
	if(!CollisionShapeDialog.Display(Window, CollisionShape->Data())) return TRUE;

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Edits an existing event object
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::EditEventObject(MODEL_EVENT_OBJECT* EventObject)
{
	std::string Name;
	MODEL_EVENT_OBJECT_DATA Data;
	MODEL_GLOBAL_SEQUENCE* GlobalSequence;

	Data = EventObject->Data();
	GlobalSequence = EventObject->GlobalSequenceNode.IsAttached() ? EventObject->GlobalSequenceNode.GetObjectData() : NULL;
	Name = Data.Name;

	if(!EventObjectDialog.Display(Window, Data, GlobalSequence)) return TRUE;

	if(Data.Name != Name)
	{
		TVITEM ItemInfo;

		ItemInfo.mask = TVIF_TEXT;
		ItemInfo.hItem = Data.TreeViewItem;
		ItemInfo.state = 0;
		ItemInfo.stateMask = 0;
		ItemInfo.pszText = const_cast<CHAR*>(Data.Name.c_str());
		ItemInfo.cchTextMax = static_cast<INT>(Data.Name.size());
		ItemInfo.iImage = 0;
		ItemInfo.iSelectedImage = 0;
		ItemInfo.cChildren = 0;
		ItemInfo.lParam = 0;

		TreeView_SetItem(TreeView.GetWindow(), &ItemInfo);
	}

	EventObject->Data() = Data;
	if(GlobalSequence != NULL)
	{
		EventObject->GlobalSequenceNode.Attach(GlobalSequence->EventObjectNodes);
	}
	else
	{
		EventObject->GlobalSequenceNode.Detach();
	}

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Edits an existing helper
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::EditHelper(MODEL_HELPER* Helper)
{
	if(!HelperDialog.Display(Window, Helper->Data())) return TRUE;

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Edits an existing light
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::EditLight(MODEL_LIGHT* Light)
{
	if(!LightDialog.Display(Window, Light->Data())) return TRUE;

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Edits an existing particle emitter
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::EditParticleEmitter(MODEL_PARTICLE_EMITTER* ParticleEmitter)
{
	if(!ParticleEmitterDialog.Display(Window, ParticleEmitter->Data())) return TRUE;

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Edits an existing particle emitter 2
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::EditParticleEmitter2(MODEL_PARTICLE_EMITTER_2* ParticleEmitter2)
{
	MODEL_TEXTURE* Texture;

	Texture = ParticleEmitter2->TextureNode.IsAttached() ? ParticleEmitter2->TextureNode.GetObjectData() : NULL;

	if(!ParticleEmitter2Dialog.Display(Window, ParticleEmitter2->Data(), Texture)) return TRUE;

	if(Texture != NULL)
	{
		ParticleEmitter2->TextureNode.Attach(Texture->ParticleEmitter2Nodes);
	}
	else
	{
		ParticleEmitter2->TextureNode.Detach();
	}

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Edits an existing ribbon emitter
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::EditRibbonEmitter(MODEL_RIBBON_EMITTER* RibbonEmitter)
{
	MODEL_MATERIAL* Material;

	Material = RibbonEmitter->MaterialNode.IsAttached() ? RibbonEmitter->MaterialNode.GetObjectData() : NULL;

	if(!RibbonEmitterDialog.Display(Window, RibbonEmitter->Data(), Material)) return TRUE;

	if(Material != NULL)
	{
		RibbonEmitter->MaterialNode.Attach(Material->RibbonEmitterNodes);
	}
	else
	{
		RibbonEmitter->MaterialNode.Detach();
	}

	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Moves a node up
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::MoveUp()
{
	MODEL_BASE* Node;
	HTREEITEM Item;
	HTREEITEM InsertionPoint;

	Node = CurrentlySelectedNode;
	if(Node == NULL) return FALSE;

	Item = TreeView_GetPrevSibling(TreeView.GetWindow(), Node->BaseData()->TreeViewItem);
	if(Item == NULL)
	{
		Error.SetMessage("Cannot move the node upwards!");
		return FALSE;
	}

	InsertionPoint = TreeView_GetPrevSibling(TreeView.GetWindow(), Item);
	if(InsertionPoint == NULL) InsertionPoint = TVI_FIRST;

	RemoveNode(Node);
	AddNodeAndChildren(Node, InsertionPoint);

	TreeView_SelectItem(TreeView.GetWindow(), Node->BaseData()->TreeViewItem);
	MainWindow.MakeModelUnsaved();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Moves a node down
//+-----------------------------------------------------------------------------
BOOL NODE_MANAGER_WINDOW::MoveDown()
{
	MODEL_BASE* Node;
	HTREEITEM Item;
	HTREEITEM InsertionPoint;

	Node = CurrentlySelectedNode;
	if(Node == NULL) return FALSE;

	Item = TreeView_GetNextSibling(TreeView.GetWindow(), Node->BaseData()->TreeViewItem);
	if(Item == NULL)
	{
		Error.SetMessage("Cannot move the node downwards!");