1 files changed, 147 insertions, 0 deletions

diff --git a/OpenSim/Framework/EstateSettings.cs b/OpenSim/Framework/EstateSettings.cs
index a92abbf..4df7860 100644
--- a/OpenSim/Framework/EstateSettings.cs
+++ b/OpenSim/Framework/EstateSettings.cs
@@ -28,6 +28,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Reflection;
 using OpenMetaverse;
 
 namespace OpenSim.Framework
@@ -58,6 +59,30 @@ namespace OpenSim.Framework
             set { m_EstateName = value; }
         }
 
+        private bool m_AllowLandmark = true;
+
+        public bool AllowLandmark
+        {
+            get { return m_AllowLandmark; }
+            set { m_AllowLandmark = value; }
+        }
+
+        private bool m_AllowParcelChanges = true;
+
+        public bool AllowParcelChanges
+        {
+            get { return m_AllowParcelChanges; }
+            set { m_AllowParcelChanges = value; }
+        }
+
+        private bool m_AllowSetHome = true;
+
+        public bool AllowSetHome
+        {
+            get { return m_AllowSetHome; }
+            set { m_AllowSetHome = value; }
+        }
+
         private uint m_ParentEstateID = 1;
 
         public uint ParentEstateID
@@ -374,10 +399,132 @@ namespace OpenSim.Framework
             return l_EstateAccess.Contains(user);
         }
 
+        public void SetFromFlags(ulong regionFlags)
+        {
+            ResetHomeOnTeleport = ((regionFlags & (ulong)OpenMetaverse.RegionFlags.ResetHomeOnTeleport) == (ulong)OpenMetaverse.RegionFlags.ResetHomeOnTeleport);
+            BlockDwell = ((regionFlags & (ulong)OpenMetaverse.RegionFlags.BlockDwell) == (ulong)OpenMetaverse.RegionFlags.BlockDwell);
+            AllowLandmark = ((regionFlags & (ulong)OpenMetaverse.RegionFlags.AllowLandmark) == (ulong)OpenMetaverse.RegionFlags.AllowLandmark);
+            AllowParcelChanges = ((regionFlags & (ulong)OpenMetaverse.RegionFlags.AllowParcelChanges) == (ulong)OpenMetaverse.RegionFlags.AllowParcelChanges);
+            AllowSetHome = ((regionFlags & (ulong)OpenMetaverse.RegionFlags.AllowSetHome) == (ulong)OpenMetaverse.RegionFlags.AllowSetHome);
+        }
+
         public bool GroupAccess(UUID groupID)
         {
             return l_EstateGroups.Contains(groupID);
         }
 
+        public Dictionary<string, object> ToMap()
+        {
+            Dictionary<string, object> map = new Dictionary<string, object>();
+            PropertyInfo[] properties = this.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
+            foreach (PropertyInfo p in properties)
+            {
+                // EstateBans is a complex type, let's treat it as special
+                if (p.Name == "EstateBans")
+                    continue;
+
+                object value = p.GetValue(this, null);
+                if (value != null)
+                {
+                    if (p.PropertyType.IsArray) // of UUIDs
+                    {
+                        if (((Array)value).Length > 0)
+                        {
+                            string[] args = new string[((Array)value).Length];
+                            int index = 0;
+                            foreach (object o in (Array)value)
+                                args[index++] = o.ToString();
+                            map[p.Name] = String.Join(",", args);
+                        }
+                    }
+                    else // simple types
+                        map[p.Name] = value;
+                }
+            }
+
+            // EstateBans are special
+            if (EstateBans.Length > 0)
+            {
+                Dictionary<string, object> bans = new Dictionary<string, object>();
+                int i = 0;
+                foreach (EstateBan ban in EstateBans)
+                    bans["ban" + i++] = ban.ToMap();
+                map["EstateBans"] = bans;
+            }
+
+            return map;
+        }
+
+        /// <summary>
+        /// For debugging
+        /// </summary>
+        /// <returns></returns>
+        public override string ToString()
+        {
+            Dictionary<string, object> map = ToMap();
+            String result = String.Empty;
+
+            foreach (KeyValuePair<string, object> kvp in map)
+            {
+                if (kvp.Key == "EstateBans")
+                {
+                    result += "EstateBans:" + Environment.NewLine;
+                    foreach (KeyValuePair<string, object> ban in (Dictionary<string, object>)kvp.Value)
+                        result += ban.Value.ToString();
+                }
+                else
+                    result += string.Format("{0}: {1} {2}", kvp.Key, kvp.Value.ToString(), Environment.NewLine);
+            }
+
+            return result;
+        }
+
+        public EstateSettings(Dictionary<string, object> map)
+        {
+            foreach (KeyValuePair<string, object> kvp in map)
+            {
+                PropertyInfo p = this.GetType().GetProperty(kvp.Key, BindingFlags.Public | BindingFlags.Instance);
+                if (p == null)
+                    continue;
+
+                // EstateBans is a complex type, let's treat it as special
+                if (p.Name == "EstateBans")
+                    continue;
+
+                if (p.PropertyType.IsArray)
+                {
+                    string[] elements = ((string)map[p.Name]).Split(new char[] { ',' });
+                    UUID[] uuids = new UUID[elements.Length];
+                    int i = 0;
+                    foreach (string e in elements)
+                        uuids[i++] = new UUID(e);
+                    p.SetValue(this, uuids, null);
+                }
+                else
+                {
+                    object value = p.GetValue(this, null);
+                    if (value is String)
+                        p.SetValue(this, map[p.Name], null);
+                    else if (value is UInt32)
+                        p.SetValue(this, UInt32.Parse((string)map[p.Name]), null);
+                    else if (value is Boolean)
+                        p.SetValue(this, Boolean.Parse((string)map[p.Name]), null);
+                    else if (value is UUID)
+                        p.SetValue(this, UUID.Parse((string)map[p.Name]), null);
+                }
+            }
+
+            // EstateBans are special
+            if (map.ContainsKey("EstateBans"))
+            {
+                var banData = ((Dictionary<string, object>)map["EstateBans"]).Values;
+                EstateBan[] bans = new EstateBan[banData.Count];
+                int b = 0;
+                foreach (Dictionary<string, object> ban in banData)
+                    bans[b++] = new EstateBan(ban);
+                PropertyInfo bansProperty = this.GetType().GetProperty("EstateBans", BindingFlags.Public | BindingFlags.Instance);
+                bansProperty.SetValue(this, bans, null);
+            }
+        }
     }
 }