/*
  	 Uiml.Net: a Uiml.Net renderer (http://lumumba.uhasselt.be/kris/research/uiml.net/)
   
	 Copyright (C) 2003  Kris Luyten (kris.luyten@uhasselt.be)
	                     Expertise Centre for Digital Media (http://edm.uhasselt.be)
								Hasselt University

	This program is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public License
	as published by the Free Software Foundation; either version 2.1
	of	the License, or (at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

namespace Uiml.Executing
{
	using Uiml;
	
	using System;
	using System.Xml;
	using System.Collections;
	using System.IO;

	using Uiml.Rendering;

	/// <summary>
	/// Represents &lt;condition&gt; of the XML
	/// </summary>
	public class Condition : IExecutable, IUimlElement
	{
		private string m_conditionType;
		private System.Object m_conditionObject;
		private ArrayList m_actions;
		private Part m_partTree;
		private IRenderer m_renderer;
		
        /// <summary>
        /// Constructor
        /// </summary>
		public Condition()
		{
			m_actions = new ArrayList();
		}

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="xmlNode">XML node</param>
        /// <param name="partTop">The parts of the GUI</param>
		public Condition(XmlNode xmlNode, Part partTop) : this()
		{
			m_partTree = partTop;
			Process(xmlNode);
		}

        /// <summary>
        /// For catching events
        /// </summary>
        /// <returns></returns>
		public delegate System.Object EventNotifier();

        /// <summary>
        /// Process the xml node &lt;condition&gt;
        /// </summary>
        /// <param name="n">The node to process</param>
		public void Process(XmlNode n)
		{
			if(n.Name == CONDITION)
			{
				if(n.HasChildNodes)
				{
					XmlNodeList xnl = n.ChildNodes;
					switch(xnl[0].Name)
					{
						case EVENT:
							ConditionType = EVENT;
							m_conditionObject = new Event(xnl[0]);
							break;
						case OPERATOR:
							ConditionType = OPERATOR;
							m_conditionObject = new Op(xnl[0], m_partTree);
							break;
						case EQUAL:
							ConditionType = EQUAL;
							m_conditionObject = new Equal(xnl[0], m_partTree);
							break;
					}
				}
			}
		}

        /// <summary>
        /// Execute the condition
        /// </summary>
        /// <returns></returns>
		public System.Object Execute()
		{
			//if(CheckCondition())
			{
				IEnumerator enumActions = m_actions.GetEnumerator();
				while(enumActions.MoveNext())
				{
					Action a = (Action)enumActions.Current;
					a.Execute(m_renderer);
				}
			}
			return null;
		}

		///<summary>
		/// Check if the event triggered satisfies the condition that was declared
		///</summary>
		private bool CheckCondition()
		{
            if (ConditionType == EVENT)
            {
                // always true => otherwise an error in linking the events
                return true;
            }
            else if (ConditionType == OPERATOR)
            {
                ((Op)m_conditionObject).CheckCondition();
            }
            else if (ConditionType == EQUAL)
            {
                ((Equal)m_conditionObject).CheckCondition();
            }

			return false;
		}

        /// <summary>
        /// Execute the condition
        /// </summary>
        /// <param name="renderer">The renderer for the interface</param>
        /// <returns></returns>
		public System.Object Execute(IRenderer renderer)
		{
			m_renderer = renderer;
			return Execute();
		}

		public void Execute(System.Object o, EventArgs a)
		{
		}

        /// <summary>
        /// Attach an action to this condition
        /// </summary>
        /// <param name="a">The action to be attached</param>
		public void Attach(Action a)
		{
			m_actions.Add(a);
		}

        /// <summary>
        /// Get or set the condition type
        /// </summary>
		public string ConditionType
		{
			get { return m_conditionType;  }
			set { m_conditionType = value; }
		}

		///<summary>
		///  Returns all the events this condition specifies.
		///</summary>
		public IEnumerator Events
		{
			get 			
			{
				return GetEvents().GetEnumerator();
			}
		}

        /// <summary>
        /// Returns all the events this condition specifies
        /// </summary>
        /// <returns></returns>
		public ArrayList GetEvents()
		{
			ArrayList l = new ArrayList();
			GetEvents(ref l);
			return l;
		}

        /// <summary>
        /// Calculate all the events this condition specifies
        /// </summary>
        /// <param name="l">A reference to the list of events</param>
		private void GetEvents(ref ArrayList l)
		{
            l.Add(m_conditionObject);
			/*if(m_conditionObject is Event)
				l.Add(m_conditionObject);
			else if(m_conditionObject is Op)
				((Op)m_conditionObject).GetEvents(l);
			else if(m_conditionObject is Equal)
				((Equal)m_conditionObject).GetEvents(l);*/
		}

        /// <summary>
        /// Get the children of this condition
        /// </summary>
		public ArrayList Children
		{
			get { return null; }
		}

        public Object ConditionObject
        {
            get { return m_conditionObject; }
        }

		public const string CONDITION = "condition";
		public const string EQUAL     = "equal";
		public const string OPERATOR  = "op";
		public const string EVENT     = "event";
	}
}