예제 #1
0
        public static List <string> GetGlobalStringArray(string varName)
        {
            List <string> ret = new List <string>();

            MoonSharp.Interpreter.Table t = Instance.BootstrapScript.Globals[varName] as MoonSharp.Interpreter.Table;
            foreach (var res in t.Values)
            {
                ret.Add(res.CastToString());
            }

            return(ret);
        }
예제 #2
0
        //public Autodesk.Revit.DB.XYZ GetLocation(Element e)
        //{
        //    var lp = e.Location as LocationPoint;
        //    if (lp == null)
        //    {
        //        return new Autodesk.Revit.DB.XYZ();
        //    }
        //    else
        //        return lp.Point;
        //}

        public Element[] GetFilteredElements(MoonSharp.Interpreter.Table t)
        {
            var filter = new FilteredElementCollector(UIApp.ActiveUIDocument.Document);

            for (int i = 0; i < t.Keys.Count(); i++)
            {
                switch (t.Keys.ElementAt(i).String)
                {
                case "full":
                    filter = filter.WherePasses(
                        new LogicalOrFilter(
                            new ElementIsElementTypeFilter(false),
                            new ElementIsElementTypeFilter(true)));
                    break;

                case "class":
                    filter = filter.OfClass((from x in TypeForm.GlobalTypesList
                                             where x.Name == t.Values.ElementAt(i).String
                                             select x).ToArray()[0]);
                    break;

                case "category":
                    filter = filter.OfCategory((BuiltInCategory)Enum.Parse(typeof(BuiltInCategory), t.Values.ElementAt(i).String));
                    break;

                case "filter":
                    var            func = t.Values.ElementAt(i).Function;
                    List <Element> ret  = new List <Element>();

                    foreach (var e in filter)
                    {
                        if (func.Call(e).Boolean)
                        {
                            ret.Add(e);
                        }
                    }

                    return(ret.ToArray());
                }
            }

            if (t.Keys.Count() == 0)
            {
                filter = filter.WherePasses(
                    new LogicalOrFilter(
                        new ElementIsElementTypeFilter(false),
                        new ElementIsElementTypeFilter(true)));
            }

            return(filter.ToElements().ToArray());
        }
예제 #3
0
        public object CLRObject(string name, MoonSharp.Interpreter.Table t, string ns = "")
        {
            var tmp = (from x in TypeForm.GlobalTypesList
                       where x.Name == name && (ns == "" || x.Namespace == ns)
                       select x);

            if (tmp.Count() == 0)
            {
                throw new System.InvalidOperationException("This type is not imported: " + name);
            }

            var clsType = tmp.ToArray()[0];

            List <object> _params = new List <object>();

            foreach (var v in t.Values)
            {
                _params.Add(v.ToObject());
            }

            return(Activator.CreateInstance(clsType, _params.ToArray()));
        }
예제 #4
0
        public static void SetRow(Gwen.Control.Table table, Gwen.Control.TableRow row, object item)
        {
            string[] displayMembers = table.DisplayMembers;

            if (displayMembers == null || displayMembers.Length == 0)
            {
                string text = item.ToString();
                row.Text     = text;
                row.Name     = text;
                row.UserData = item;
            }
            else
            {
                if (!(item is KeyValuePair <object, object>))
                {
                    throw new ScriptRuntimeException("Expecting table item");
                }

                var keyValuePair = (KeyValuePair <object, object>)item;

                MoonSharp.Interpreter.Table luaTable = keyValuePair.Value as MoonSharp.Interpreter.Table;
                if (luaTable == null)
                {
                    throw new ScriptRuntimeException("Expecting table");
                }

                string col = luaTable[displayMembers[0]].ToString();
                row.Name     = col;
                row.UserData = item;
                row.SetCellText(0, col);

                for (int i = 1; i < displayMembers.Length; i++)
                {
                    row.SetCellText(i, luaTable[displayMembers[i]].ToString());
                }
            }
        }
예제 #5
0
파일: Table.cs 프로젝트: Enyss/RSSE2
        public Table(MoonSharp.Interpreter.Table luaTable) : base()
        {
            IEnumerable <DynValue> keys = luaTable.Keys.AsEnumerable();

            foreach (DynValue key in keys)
            {
                DynValue value = luaTable.Get(key);

                switch (value.Type)
                {
                case DataType.Table:
                    this.Add(key.String, new Table(value.Table));
                    break;

                case DataType.String:
                    this.Add(key.String, value.String);
                    break;

                case DataType.Number:
                    this.Add(key.String, value.Number);
                    break;
                }
            }
        }
예제 #6
0
            public static DynValue ClassToLuaTable(Script script, object obj)
            {
                MoonSharp.Interpreter.Table table = new MoonSharp.Interpreter.Table(script);
                var properties = obj.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);

                for (int i = 0; i < properties.Length; i++)
                {
                    var property = properties[i];

                    var value = property.GetValue(obj, null);
                    if (value == null)
                    {
                        continue;
                    }

                    if (value.GetType() == typeof(string))
                    {
                        table.Set(property.Name, DynValue.NewString((string)value));
                    }
                    else if (value.GetType() == typeof(int))
                    {
                        table.Set(property.Name, DynValue.NewNumber((int)value));
                    }
                    else if (value.GetType() == typeof(float))
                    {
                        table.Set(property.Name, DynValue.NewNumber((float)value));
                    }
                    else if (value.GetType() == typeof(bool))
                    {
                        table.Set(property.Name, DynValue.NewBoolean((bool)value));
                    }
                    else if (value is ProtoBuf.IExtensible)
                    {
                        table.Set(property.Name, ClassToLuaTable(script, value));
                    }
                    else if (value is IList)
                    {
                        IList list = value as IList;
                        MoonSharp.Interpreter.Table value_table = new MoonSharp.Interpreter.Table(script);
                        for (int j = 0; j < list.Count; ++j)
                        {
                            DynValue item = null;
                            if (list[j] is ProtoBuf.IExtensible)
                            {
                                item = ClassToLuaTable(script, list[j]);
                            }
                            else if (list[j] is int)
                            {
                                item = DynValue.NewNumber((int)list[j]);
                            }
                            else if (list[j] is float)
                            {
                                item = DynValue.NewNumber((float)list[j]);
                            }
                            else if (list[j] is string)
                            {
                                item = DynValue.NewString((string)list[j]);
                            }
                            else if (list[j] is bool)
                            {
                                item = DynValue.NewBoolean((bool)list[j]);
                            }
                            else
                            {
                                Debug.LogError("Convert List to lua table error: unsupported types " + list[j].GetType());
                            }
                            value_table.Append(item);
                        }
                        table.Set(property.Name, DynValue.NewTable(value_table));
                    }
                    else
                    {
                        Debug.LogError("Convert class to lua table error: unsupported types " + value);
                    }
                }

                return(DynValue.NewTable(table));
            }
예제 #7
0
        public MoonSharp.Interpreter.Table GetCLRObjectTable(object obj, int level = 1, bool err = false)
        {
            level--;
            MoonSharp.Interpreter.Table ret = new MoonSharp.Interpreter.Table(MoonScript);
            foreach (PropertyDescriptor descriptor in TypeDescriptor.GetProperties(obj))
            {
                string name = descriptor.Name;
                if (TypeForm.OmittedProperties.Contains(name))
                {
                    continue;
                }
                object _value = null;

                try {
                    _value = descriptor.GetValue(obj);
                } catch (Exception e) {
                    ret.Set(name, MoonSharp.Interpreter.DynValue.NewString("[Error]"));
                    continue;
                }

                if (_value is int)
                {
                    ret.Set(name, MoonSharp.Interpreter.DynValue.NewNumber((int)_value));
                }
                else if (_value is double)
                {
                    ret.Set(name, MoonSharp.Interpreter.DynValue.NewNumber((double)_value));
                }
                else if (_value is byte)
                {
                    ret.Set(name, MoonSharp.Interpreter.DynValue.NewNumber((byte)_value));
                }
                else if (_value is string)
                {
                    ret.Set(name, MoonSharp.Interpreter.DynValue.NewString((string)_value));
                }
                else if (_value is bool)
                {
                    ret.Set(name, MoonSharp.Interpreter.DynValue.NewBoolean((bool)_value));
                }
                else if (_value != null && _value.GetType().IsEnum)
                {
                    ret.Set(name, MoonSharp.Interpreter.DynValue.NewNumber(Convert.ToInt32(_value)));
                }
                else if (level > 0)
                {
                    try {
                        ret.Set(name, MoonSharp.Interpreter.DynValue.NewTable(GetCLRObjectTable(_value, level, err)));
                    } catch (Exception e)
                    {
                        if (err)
                        {
                            ret.Set(name, MoonSharp.Interpreter.DynValue.NewString("[Cannot get inside]"));
                        }
                    }
                }
                else
                {
                    ret.Set(name, MoonSharp.Interpreter.DynValue.NewString(_value?.ToString()));
                }
            }

            return(ret);
        }