public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
        {
            if (type.GetGenericTypeDefinition() != typeof(List<>))
            { throw new Exception(Resources.ExceptionDesignerAttributeInvalidType); }

            Type itemType = type.GetGenericArguments()[0];

            if (!itemType.IsEnum)
            { throw new Exception(Resources.ExceptionDesignerAttributeInvalidType); }

            System.Collections.IList enumArray = (System.Collections.IList)Plugin.CreateInstance(type);

            if (!string.IsNullOrEmpty(str)) {
                int index = str.IndexOf(':');

                if (index >= 0)
                { str = str.Substring(index + 1); }

                string[] tokens = str.Split('|');
                foreach(string s in tokens) {
                    enumArray.Add(Enum.Parse(itemType, s, true));
                }
            }

            return enumArray;
        }

        public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
        {
            if (Plugin.IsCustomClassType(type))
            { return ParseStringValue(result, type, null, str, node); }

            throw new Exception(Resources.ExceptionDesignerAttributeInvalidType);
        }

        public new static object ParseStringValue(List<Nodes.Node.ErrorCheck> result, Type type, string str, DefaultObject node)
        {
            Debug.Check(type != null && Plugin.IsArrayType(type));

            object obj = Plugin.CreateInstance(type);
            Debug.Check(obj != null);

            if (!string.IsNullOrEmpty(str)) {
                System.Collections.IList list = (System.Collections.IList)obj;
                Type itemType = type.GetGenericArguments()[0];

                int index = str.IndexOf(':');

                if (index >= 0)
                { str = str.Substring(index + 1); }

                if (!string.IsNullOrEmpty(str)) {
                    System.Collections.IList structArray = (System.Collections.IList)Plugin.CreateInstance(type);
                    parseStringValue(result, node, structArray, itemType, str, 0, str.Length - 1);

                    return structArray;
                }
            }

            return obj;
        }

        public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
        {
            if (type != typeof(RightValueDef))
            { throw new Exception(Resources.ExceptionDesignerAttributeInvalidType); }

            if (str.Length == 0 ||
                str.Length == 2 && str == "\"\"") {
                return null;
            }

            if (!str.StartsWith("const")) {
                int pos = str.IndexOf('(');

                if (pos < 0) {
                    VariableDef var = DesignerPropertyEnum.parsePropertyVar(result, node, str);

                    return new RightValueDef(var);

                } else {
                    Nodes.Behavior behavior = node.Behavior as Nodes.Behavior;
                    AgentType agentType = (behavior != null) ? behavior.AgentType : null;

                    string valueClass = VariableDef.kSelfMethod;
                    MethodDef method = DesignerMethodEnum.parseMethodString(result, node, agentType, this.MethodType, str);

                    if (method == null) {
                        string className = Plugin.GetClassName(str);
                        method = DesignerMethodEnum.parseMethodString(result, node, Plugin.GetInstanceAgentType(className, behavior, null), this.MethodType, str);
                        valueClass = className + VariableDef.kMethod;
                    }

                    string instanceName = Plugin.GetInstanceName(str);

                    if (!string.IsNullOrEmpty(instanceName)) {
                        valueClass = instanceName + VariableDef.kMethod;
                    }

                    return new RightValueDef(method, valueClass);
                }

            } else {
                VariableDef var = this.parseConstVar(result, node, parentObject, str);

                if (var != null) {
                    return new RightValueDef(var);
                }
            }

            return null;
        }

        public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
        {
            if (type != typeof(bool))
            { throw new Exception(Resources.ExceptionDesignerAttributeInvalidType); }

            str = str.ToLowerInvariant();

            if (str == "true")
            { return true; }

            if (str == "false")
            { return false; }

            throw new Exception(string.Format(Resources.ExceptionDesignerAttributeIllegalBooleanValue, str));
        }

        public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
        {
            if (type != typeof(MethodDef))
            { throw new Exception(Resources.ExceptionDesignerAttributeInvalidType); }

            Nodes.Behavior behavior = node.Behavior as Nodes.Behavior;

            if (behavior != null && behavior.AgentType != null) {
                MethodDef method = parseMethodString(result, node, behavior.AgentType, this.MethodType, str);

                if (method == null) {
                    string className = Plugin.GetClassName(str);
                    method = parseMethodString(result, node, Plugin.GetInstanceAgentType(className, behavior, null), this.MethodType, str);
                }

                return method;
            }

            return null;
        }

        public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
        {
            foreach(Plugin.InstanceName_t t in Plugin.InstanceNames) {
                if (str == t.agentType_.AgentTypeName
#if BEHAVIAC_NAMESPACE_FIX
                    || t.agentType_.AgentTypeName.EndsWith(str)
#endif
                   ) {
                    return t.agentType_;
                }
            }

            foreach(AgentType t in Plugin.AgentTypes) {
                if (str == t.ToString()
#if BEHAVIAC_NAMESPACE_FIX
                    || t.AgentTypeName.EndsWith(str)
#endif
                   ) {
                    return t;
                }
            }

            return null;
        }

 public override bool AcceptsAttachment(DefaultObject obj)
 {
     return (obj != null) && (obj is WaitTransition);
 }

        private static VariableDef createVariable(List<Nodes.Node.ErrorCheck> result, DefaultObject node, AgentType agentType, string instacneName, string propertyName)
        {
            List<string> tokens = DesignerPropertyEnum.SplitTokens(propertyName);
            Debug.Check(tokens.Count > 0);
            string arrayIndexStr = null;

            if (tokens.Count > 1) {
                propertyName = tokens[0] + "[]";
                arrayIndexStr = tokens[1];
            }

            Nodes.Behavior behavior = node.Behavior as Nodes.Behavior;
            agentType = Plugin.GetInstanceAgentType(instacneName, behavior, agentType);

            if (agentType != null) {
                IList<PropertyDef> properties = agentType.GetProperties();
                foreach(PropertyDef p in properties) {
                    if (p.Name == propertyName
#if BEHAVIAC_NAMESPACE_FIX
                        || p.Name.EndsWith(propertyName)
#endif
                       ) {
                        VariableDef v = new VariableDef(p, instacneName);

                        if (v != null && !string.IsNullOrEmpty(arrayIndexStr)) {
                            v.ArrayIndexElement = new MethodDef.Param("ArrayIndex", typeof(int), "int", "ArrayIndex", "ArrayIndex");
                            v.ArrayIndexElement.IsArrayIndex = true;
                            DesignerMethodEnum.parseParam(result, node, null, v.ArrayIndexElement, arrayIndexStr);
                        }

                        return v;
                    }
                }
            }

            return null;
        }

 /// <summary>
 /// Determines if an attachment of a certain type is aceepted by this node or not.
 /// </summary>
 /// <param name="type">The type of the attachment we want to add.</param>
 /// <returns>Returns if the attachment may be added or not</returns>
 public virtual bool AcceptsAttachment(DefaultObject obj) {
     return (obj != null) && !obj.IsFSM && obj.CanBeAttached;
 }

        public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
        {
            if (!Plugin.IsIntergerNumberType(type))
                throw new Exception(Resources.ExceptionDesignerAttributeInvalidType);

            int resultValue = 0;

            if (int.TryParse(str, NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat, out resultValue))
                return resultValue;

            throw new Exception(string.Format(Resources.ExceptionDesignerAttributeIllegalIntegerValue, str));
        }

        protected static VariableDef setProperty(List<Nodes.Node.ErrorCheck> result, DefaultObject node, AgentType agentType, string propertyName, string arrayIndexStr, string valueType)
        {
            if (agentType != null)
            {
                IList<PropertyDef> properties = agentType.GetProperties();
                foreach (PropertyDef p in properties)
                {
                    if (p.Name == propertyName
#if BEHAVIAC_NAMESPACE_FIX
                        || p.Name.EndsWith(propertyName)
#endif
                        )
                    {
                        PropertyDef prop = p.Clone();
                        prop.Owner = valueType;

                        VariableDef v = new VariableDef(prop, valueType);

                        if (v != null && !string.IsNullOrEmpty(arrayIndexStr))
                        {
                            v.ArrayIndexElement = new MethodDef.Param("ArrayIndex", typeof(int), "int", "ArrayIndex", "ArrayIndex");
                            v.ArrayIndexElement.IsArrayIndex = true;
                            DesignerMethodEnum.parseParam(result, node, null, v.ArrayIndexElement, arrayIndexStr);
                        }

                        return v;
                    }
                }
            }

            return null;
        }

        protected VariableDef parseConstVar(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, string str)
        {
            Debug.Check(str.StartsWith("const"));

            //const Int32 1
            object propertyMemberDepended = null;
            Type objType = node.GetType();

            if (this.DependedProperty != "") {
                System.Reflection.PropertyInfo pi = objType.GetProperty(this.DependedProperty);

                if (pi != null) {
                    propertyMemberDepended = pi.GetValue(node, null);

                } else if (pi == null && parentObject != null) {
                    Type parentType = parentObject.GetType();
                    pi = parentType.GetProperty(this.DependedProperty);
                    propertyMemberDepended = pi.GetValue(parentObject, null);
                }
            }

            Type valueType = null;
            VariableDef variableDepended = propertyMemberDepended as VariableDef;

            if (variableDepended != null) {
                valueType = variableDepended.GetValueType();

            } else if (propertyMemberDepended != null) {
                MethodDef methodDepended = propertyMemberDepended as MethodDef;

                if (methodDepended != null) {
                    valueType = methodDepended.ReturnType;

                } else {
                    RightValueDef varRV = propertyMemberDepended as RightValueDef;

                    if (varRV != null) {
                        valueType = varRV.ValueType;
                    }
                }

            } else {
                string[] tokens = str.Split(' ');
                Debug.Check(tokens.Length >= 3);

                valueType = Plugin.GetTypeFromName(tokens[1]);
            }

            if (valueType != null) {
                VariableDef variable = new VariableDef(null);

                //string[] tokens = str.Split(' ');
                //Debug.Check(tokens.Length == 3);
                Debug.Check(str.StartsWith("const"));
                //skip 'const '
                int pos = str.IndexOf(' ');
                Debug.Check(pos != -1);
                pos = str.IndexOf(' ', pos + 1);
                string token = str.Substring(pos + 1);

                Plugin.InvokeTypeParser(result, valueType, token,
                                        (object value) => variable.Value = value,
                                        node);

                return variable;
            }

            return null;
        }

        public static bool parseParam(List<Nodes.Node.ErrorCheck> result, DefaultObject node, MethodDef method, MethodDef.Param par, string param)
        {
            string propName = null;

            if (param[0] == '\"')
            {
                param = param.Substring(1, param.Length - 2);
            }
            else if (param[0] == '{') //struct
            {
                //to set it as action.Method is used in the following parsing
                Nodes.Action action = node as Nodes.Action;

                if (action != null)
                {
                    action.Method = method;
                }
            }
            else
            {
                string noStaticParam = param.Replace("static ", "");
                int index = noStaticParam.IndexOf(" ");
                if (index >= 0)
                    propName = noStaticParam.Substring(index + 1);
            }

            bool bOk = false;

            if (propName != null)
            {
                VariableDef var = setParameter(result, node, propName);

                if (var != null)
                {
                    par.Value = var;
                    bOk = true;
                }
            }
            else
            {
                bOk = Plugin.InvokeTypeParser(result, par.Type, param, 
                    (object value) => par.Value = value, 
                    node, par.Name);
            }

            return bOk;
        }

        /// <summary>
        /// Creates a new NodeTag and an instance of the node for the defaults.
        /// </summary>
        /// <param name="type">The type of the node in the node explorer.</param>
        /// <param name="nodetype">The type of the node which will be added to the behaviour tree.</param>
        /// <param name="filename">The filename of the behaviour we want to load. Use string.Empty if the node is not a behaviour.</param>
        public NodeTag(NodeTagType type, Type nodetype, string filename)
        {
            if((type ==NodeTagType.BehaviorFolder || type ==NodeTagType.NodeFolder) && nodetype !=null)
                throw new Exception(Resources.ExceptionWrongNodeTagType);

            _type= type;
            _nodetype= nodetype;
            _filename= filename;

            if(nodetype ==null)
            {
                _defaults= null;
            }
            else
            {
                //if(!nodetype.IsSubclassOf(typeof(DefaultObject)))
                //	throw new Exception(Resources.ExceptionNotImplementDefaultObject);

                if(nodetype.IsSubclassOf(typeof(Events.Event)) && type !=NodeTagType.Event)
                    throw new Exception(Resources.ExceptionWrongNodeTagType);

                if(nodetype.IsSubclassOf(typeof(Nodes.Node)) && type !=NodeTagType.Node && type !=NodeTagType.Behavior)
                    throw new Exception(Resources.ExceptionWrongNodeTagType);

                _defaults=type ==NodeTagType.Event ? (DefaultObject)Brainiac.Design.Events.Event.Create(nodetype, null) : (DefaultObject)Nodes.Node.Create(nodetype);
            }
        }

        /// <summary>
        /// Used to replace the default object with a behaviour once loaded.
        /// </summary>
        /// <param name="behavior">The behaviour we have loaded.</param>
        public void AssignLoadedBehavior(BehaviorNode behavior)
        {
            Debug.Check(_type ==NodeTagType.Behavior);
            Debug.Check(_filename ==behavior.FileManager.Filename);

            _defaults= (DefaultObject)behavior;
        }

        public static bool parseParam(List<Nodes.Node.ErrorCheck> result, DefaultObject node, MethodDef method, MethodDef.Param par, string param)
        {
            string[] tokens = null;

            if (param[0] == '\"') {
                param = param.Substring(1, param.Length - 2);

            } else if (param[0] == '{') {
                //struct

                //to set it as action.Method is used in the following parsing
                Nodes.Action action = node as Nodes.Action;

                if (action != null) {
                    action.Method = method;
                }

            } else {
                tokens = param.Split(' ');
            }


            bool bOk = false;

            if (tokens != null && tokens.Length > 1) {
                //par
                VariableDef var = setParameter(result, node, tokens[tokens.Length - 1]);

                if (var != null) {
                    par.Value = var;
                    bOk = true;
                }

            } else {
                bOk = Plugin.InvokeTypeParser(result, par.Type, param, (object value) => par.Value = value, node, par.Name);
            }

            return bOk;
        }

        public override object FromStringValue(List<Nodes.Node.ErrorCheck> result, DefaultObject node, object parentObject, Type type, string str)
        {
            if (type != typeof(string))
            { throw new Exception(Resources.ExceptionDesignerAttributeInvalidType); }

            return str;
        }

        public static VariableDef setParameter(List<Nodes.Node.ErrorCheck> result, DefaultObject node, string propertyName)
        {
            Nodes.Behavior behavior = node.Behavior as Nodes.Behavior;

            // Convert the Par to the Property
            if (!propertyName.Contains(".") && !propertyName.Contains(":"))
            { propertyName = "Self." + behavior.AgentType.AgentTypeName + "::" + propertyName; }

            VariableDef var = null;
            string instance = Plugin.GetInstanceName(propertyName);

            if (!string.IsNullOrEmpty(instance)) {
                propertyName = propertyName.Substring(instance.Length + 1, propertyName.Length - instance.Length - 1);

                var = createVariable(result, node, behavior.AgentType, instance, propertyName);

                if (var != null) {
                    return var;
                }
            }

            // Try to find the Agent property with the name.
            if (behavior != null && behavior.AgentType != null) {
                instance = "Self";
                var = createVariable(result, node, behavior.AgentType, instance, propertyName);

                if (var != null) {
                    return var;
                }
            }

            // Try to find the global property with the name.
            string instacneName = Plugin.GetClassName(propertyName);

            if (!string.IsNullOrEmpty(instacneName) && Plugin.GetInstanceAgentType(instacneName, behavior, null) != null) {
                var = createVariable(result, node, behavior.AgentType, instacneName, propertyName);

                if (var != null) {
                    return var;
                }
            }

            return null;
        }

 public override bool AcceptsAttachment(DefaultObject obj)
 {
     return false;
 }