Formatting cleanup.

1 files changed, 804 insertions, 767 deletions

diff --git a/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs b/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs
index 0b2cc9e..a0e0a37 100644
--- a/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs
+++ b/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
  *
@@ -45,534 +45,553 @@ namespace OpenSim.Region.Environment.Scenes
 
         #region Object Permission Checks
 
-            public delegate uint GenerateClientFlags(LLUUID userID, LLUUID objectIDID);
-            private List<GenerateClientFlags> GenerateClientFlagsCheckFunctions = new List<GenerateClientFlags>();
+        public delegate uint GenerateClientFlags(LLUUID userID, LLUUID objectIDID);
+        private List<GenerateClientFlags> GenerateClientFlagsCheckFunctions = new List<GenerateClientFlags>();
 
-            public void addGenerateClientFlags(GenerateClientFlags delegateFunc)
-            {
-                if (!GenerateClientFlagsCheckFunctions.Contains(delegateFunc))
-                    GenerateClientFlagsCheckFunctions.Add(delegateFunc);
-            }
-            public void removeGenerateClientFlags(GenerateClientFlags delegateFunc)
-            {
-                if (GenerateClientFlagsCheckFunctions.Contains(delegateFunc))
-                    GenerateClientFlagsCheckFunctions.Remove(delegateFunc);
-            }
+        public void addGenerateClientFlags(GenerateClientFlags delegateFunc)
+        {
+            if (!GenerateClientFlagsCheckFunctions.Contains(delegateFunc))
+                GenerateClientFlagsCheckFunctions.Add(delegateFunc);
+        }
 
-            public uint ExternalChecksGenerateClientFlags(LLUUID userID, LLUUID objectID)
-            {
-                SceneObjectPart part=m_scene.GetSceneObjectPart(objectID);
-                
-                if (part == null)
-                    return 0;
-
-                uint perms=part.GetEffectiveObjectFlags() |
-                        (uint)LLObject.ObjectFlags.ObjectModify |
-                        (uint)LLObject.ObjectFlags.ObjectCopy |
-                        (uint)LLObject.ObjectFlags.ObjectMove |
-                        (uint)LLObject.ObjectFlags.ObjectTransfer |
-                        (uint)LLObject.ObjectFlags.ObjectYouOwner |
-                        (uint)LLObject.ObjectFlags.ObjectAnyOwner |
-                        (uint)LLObject.ObjectFlags.ObjectOwnerModify |
-                        (uint)LLObject.ObjectFlags.ObjectYouOfficer;
-
-                foreach (GenerateClientFlags check in GenerateClientFlagsCheckFunctions)
-                {
-                    perms &= check(userID, objectID);
-                }
-                return perms;
-            }
+        public void removeGenerateClientFlags(GenerateClientFlags delegateFunc)
+        {
+            if (GenerateClientFlagsCheckFunctions.Contains(delegateFunc))
+                GenerateClientFlagsCheckFunctions.Remove(delegateFunc);
+        }
 
-            public delegate void SetBypassPermissions(bool value);
-            private List<SetBypassPermissions> SetBypassPermissionsCheckFunctions = new List<SetBypassPermissions>();
+        public uint ExternalChecksGenerateClientFlags(LLUUID userID, LLUUID objectID)
+        {
+            SceneObjectPart part=m_scene.GetSceneObjectPart(objectID);
 
-            public void addSetBypassPermissions(SetBypassPermissions delegateFunc)
-            {
-                if (!SetBypassPermissionsCheckFunctions.Contains(delegateFunc))
-                    SetBypassPermissionsCheckFunctions.Add(delegateFunc);
-            }
-            public void removeSetBypassPermissions(SetBypassPermissions delegateFunc)
-            {
-                if (SetBypassPermissionsCheckFunctions.Contains(delegateFunc))
-                    SetBypassPermissionsCheckFunctions.Remove(delegateFunc);
-            }
+            if (part == null)
+                return 0;
 
-            public void ExternalChecksSetBypassPermissions(bool value)
+            uint perms=part.GetEffectiveObjectFlags() |
+                (uint)LLObject.ObjectFlags.ObjectModify |
+                (uint)LLObject.ObjectFlags.ObjectCopy |
+                (uint)LLObject.ObjectFlags.ObjectMove |
+                (uint)LLObject.ObjectFlags.ObjectTransfer |
+                (uint)LLObject.ObjectFlags.ObjectYouOwner |
+                (uint)LLObject.ObjectFlags.ObjectAnyOwner |
+                (uint)LLObject.ObjectFlags.ObjectOwnerModify |
+                (uint)LLObject.ObjectFlags.ObjectYouOfficer;
+
+            foreach (GenerateClientFlags check in GenerateClientFlagsCheckFunctions)
             {
-                foreach (SetBypassPermissions check in SetBypassPermissionsCheckFunctions)
-                {
-                    check(value);
-                }
+                perms &= check(userID, objectID);
             }
+            return perms;
+        }
 
-            public delegate bool BypassPermissions();
-            private List<BypassPermissions> BypassPermissionsCheckFunctions = new List<BypassPermissions>();
+        public delegate void SetBypassPermissions(bool value);
+        private List<SetBypassPermissions> SetBypassPermissionsCheckFunctions = new List<SetBypassPermissions>();
 
-            public void addBypassPermissions(BypassPermissions delegateFunc)
-            {
-                if (!BypassPermissionsCheckFunctions.Contains(delegateFunc))
-                    BypassPermissionsCheckFunctions.Add(delegateFunc);
-            }
-            public void removeBypassPermissions(BypassPermissions delegateFunc)
+        public void addSetBypassPermissions(SetBypassPermissions delegateFunc)
+        {
+            if (!SetBypassPermissionsCheckFunctions.Contains(delegateFunc))
+                SetBypassPermissionsCheckFunctions.Add(delegateFunc);
+        }
+
+        public void removeSetBypassPermissions(SetBypassPermissions delegateFunc)
+        {
+            if (SetBypassPermissionsCheckFunctions.Contains(delegateFunc))
+                SetBypassPermissionsCheckFunctions.Remove(delegateFunc);
+        }
+
+        public void ExternalChecksSetBypassPermissions(bool value)
+        {
+            foreach (SetBypassPermissions check in SetBypassPermissionsCheckFunctions)
             {
-                if (BypassPermissionsCheckFunctions.Contains(delegateFunc))
-                    BypassPermissionsCheckFunctions.Remove(delegateFunc);
+                check(value);
             }
+        }
 
-            public bool ExternalChecksBypassPermissions()
+        public delegate bool BypassPermissions();
+        private List<BypassPermissions> BypassPermissionsCheckFunctions = new List<BypassPermissions>();
+
+        public void addBypassPermissions(BypassPermissions delegateFunc)
+        {
+            if (!BypassPermissionsCheckFunctions.Contains(delegateFunc))
+                BypassPermissionsCheckFunctions.Add(delegateFunc);
+        }
+
+        public void removeBypassPermissions(BypassPermissions delegateFunc)
+        {
+            if (BypassPermissionsCheckFunctions.Contains(delegateFunc))
+                BypassPermissionsCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksBypassPermissions()
+        {
+            foreach (BypassPermissions check in BypassPermissionsCheckFunctions)
             {
-                foreach (BypassPermissions check in BypassPermissionsCheckFunctions)
+                if (check() == false)
                 {
-                    if (check() == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            public delegate bool PropagatePermissions();
-            private List<PropagatePermissions> PropagatePermissionsCheckFunctions = new List<PropagatePermissions>();
+        public delegate bool PropagatePermissions();
+        private List<PropagatePermissions> PropagatePermissionsCheckFunctions = new List<PropagatePermissions>();
 
-            public void addPropagatePermissions(PropagatePermissions delegateFunc)
-            {
-                if (!PropagatePermissionsCheckFunctions.Contains(delegateFunc))
-                    PropagatePermissionsCheckFunctions.Add(delegateFunc);
-            }
-            public void removePropagatePermissions(PropagatePermissions delegateFunc)
-            {
-                if (PropagatePermissionsCheckFunctions.Contains(delegateFunc))
-                    PropagatePermissionsCheckFunctions.Remove(delegateFunc);
-            }
+        public void addPropagatePermissions(PropagatePermissions delegateFunc)
+        {
+            if (!PropagatePermissionsCheckFunctions.Contains(delegateFunc))
+                PropagatePermissionsCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksPropagatePermissions()
+        public void removePropagatePermissions(PropagatePermissions delegateFunc)
+        {
+            if (PropagatePermissionsCheckFunctions.Contains(delegateFunc))
+                PropagatePermissionsCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksPropagatePermissions()
+        {
+            foreach (PropagatePermissions check in PropagatePermissionsCheckFunctions)
             {
-                foreach (PropagatePermissions check in PropagatePermissionsCheckFunctions)
+                if (check() == false)
                 {
-                    if (check() == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #region REZ OBJECT
-            public delegate bool CanRezObject(int objectCount, LLUUID owner, LLVector3 objectPosition, Scene scene);
-            private List<CanRezObject> CanRezObjectCheckFunctions = new List<CanRezObject>();
+        #region REZ OBJECT
+        public delegate bool CanRezObject(int objectCount, LLUUID owner, LLVector3 objectPosition, Scene scene);
+        private List<CanRezObject> CanRezObjectCheckFunctions = new List<CanRezObject>();
 
-            public void addCheckRezObject(CanRezObject delegateFunc)
-            {
-                if (!CanRezObjectCheckFunctions.Contains(delegateFunc))
-                    CanRezObjectCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckRezObject(CanRezObject delegateFunc)
-            {
-                if (CanRezObjectCheckFunctions.Contains(delegateFunc))
-                    CanRezObjectCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckRezObject(CanRezObject delegateFunc)
+        {
+            if (!CanRezObjectCheckFunctions.Contains(delegateFunc))
+                CanRezObjectCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanRezObject(int objectCount, LLUUID owner, LLVector3 objectPosition)
+        public void removeCheckRezObject(CanRezObject delegateFunc)
+        {
+            if (CanRezObjectCheckFunctions.Contains(delegateFunc))
+                CanRezObjectCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanRezObject(int objectCount, LLUUID owner, LLVector3 objectPosition)
+        {
+            foreach (CanRezObject check in CanRezObjectCheckFunctions)
             {
-                foreach (CanRezObject check in CanRezObjectCheckFunctions)
+                if (check(objectCount, owner,objectPosition, m_scene) == false)
                 {
-                    if (check(objectCount, owner,objectPosition, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region DELETE OBJECT
-            public delegate bool CanDeleteObject(LLUUID objectID, LLUUID deleter, Scene scene);
-            private List<CanDeleteObject> CanDeleteObjectCheckFunctions = new List<CanDeleteObject>();
+        #region DELETE OBJECT
+        public delegate bool CanDeleteObject(LLUUID objectID, LLUUID deleter, Scene scene);
+        private List<CanDeleteObject> CanDeleteObjectCheckFunctions = new List<CanDeleteObject>();
 
-            public void addCheckDeleteObject(CanDeleteObject delegateFunc)
-            {
-                if (!CanDeleteObjectCheckFunctions.Contains(delegateFunc))
-                    CanDeleteObjectCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckDeleteObject(CanDeleteObject delegateFunc)
-            {
-                if (CanDeleteObjectCheckFunctions.Contains(delegateFunc))
-                    CanDeleteObjectCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckDeleteObject(CanDeleteObject delegateFunc)
+        {
+            if (!CanDeleteObjectCheckFunctions.Contains(delegateFunc))
+                CanDeleteObjectCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanDeleteObject(LLUUID objectID, LLUUID deleter)
+        public void removeCheckDeleteObject(CanDeleteObject delegateFunc)
+        {
+            if (CanDeleteObjectCheckFunctions.Contains(delegateFunc))
+                CanDeleteObjectCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanDeleteObject(LLUUID objectID, LLUUID deleter)
+        {
+            foreach (CanDeleteObject check in CanDeleteObjectCheckFunctions)
             {
-                foreach (CanDeleteObject check in CanDeleteObjectCheckFunctions)
+                if (check(objectID,deleter,m_scene) == false)
                 {
-                    if (check(objectID,deleter,m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region TAKE OBJECT
-            public delegate bool CanTakeObject(LLUUID objectID, LLUUID stealer, Scene scene);
-            private List<CanTakeObject> CanTakeObjectCheckFunctions = new List<CanTakeObject>();
+        #region TAKE OBJECT
+        public delegate bool CanTakeObject(LLUUID objectID, LLUUID stealer, Scene scene);
+        private List<CanTakeObject> CanTakeObjectCheckFunctions = new List<CanTakeObject>();
 
-            public void addCheckTakeObject(CanTakeObject delegateFunc)
-            {
-                if (!CanTakeObjectCheckFunctions.Contains(delegateFunc))
-                    CanTakeObjectCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckTakeObject(CanTakeObject delegateFunc)
-            {
-                if (CanTakeObjectCheckFunctions.Contains(delegateFunc))
-                    CanTakeObjectCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckTakeObject(CanTakeObject delegateFunc)
+        {
+            if (!CanTakeObjectCheckFunctions.Contains(delegateFunc))
+                CanTakeObjectCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanTakeObject(LLUUID objectID, LLUUID AvatarTakingUUID)
+        public void removeCheckTakeObject(CanTakeObject delegateFunc)
+        {
+            if (CanTakeObjectCheckFunctions.Contains(delegateFunc))
+                CanTakeObjectCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanTakeObject(LLUUID objectID, LLUUID AvatarTakingUUID)
+        {
+            foreach (CanTakeObject check in CanTakeObjectCheckFunctions)
             {
-                foreach (CanTakeObject check in CanTakeObjectCheckFunctions)
+                if (check(objectID, AvatarTakingUUID, m_scene) == false)
                 {
-                    if (check(objectID, AvatarTakingUUID, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region TAKE COPY OBJECT
-            public delegate bool CanTakeCopyObject(LLUUID objectID, LLUUID userID, Scene inScene);
-            private List<CanTakeCopyObject> CanTakeCopyObjectCheckFunctions = new List<CanTakeCopyObject>();
+        #region TAKE COPY OBJECT
+        public delegate bool CanTakeCopyObject(LLUUID objectID, LLUUID userID, Scene inScene);
+        private List<CanTakeCopyObject> CanTakeCopyObjectCheckFunctions = new List<CanTakeCopyObject>();
 
-            public void addCheckTakeCopyObject(CanTakeCopyObject delegateFunc)
-            {
-                if (!CanTakeCopyObjectCheckFunctions.Contains(delegateFunc))
-                    CanTakeCopyObjectCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckTakeCopyObject(CanTakeCopyObject delegateFunc)
-            {
-                if (CanTakeCopyObjectCheckFunctions.Contains(delegateFunc))
-                    CanTakeCopyObjectCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckTakeCopyObject(CanTakeCopyObject delegateFunc)
+        {
+            if (!CanTakeCopyObjectCheckFunctions.Contains(delegateFunc))
+                CanTakeCopyObjectCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanTakeCopyObject(LLUUID objectID, LLUUID userID)
+        public void removeCheckTakeCopyObject(CanTakeCopyObject delegateFunc)
+        {
+            if (CanTakeCopyObjectCheckFunctions.Contains(delegateFunc))
+                CanTakeCopyObjectCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanTakeCopyObject(LLUUID objectID, LLUUID userID)
+        {
+            foreach (CanTakeCopyObject check in CanTakeCopyObjectCheckFunctions)
             {
-                foreach (CanTakeCopyObject check in CanTakeCopyObjectCheckFunctions)
+                if (check(objectID,userID,m_scene) == false)
                 {
-                    if (check(objectID,userID,m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region DUPLICATE OBJECT
-            public delegate bool CanDuplicateObject(int objectCount, LLUUID objectID, LLUUID owner, Scene scene, LLVector3 objectPosition);
-            private List<CanDuplicateObject> CanDuplicateObjectCheckFunctions = new List<CanDuplicateObject>();
+        #region DUPLICATE OBJECT
+        public delegate bool CanDuplicateObject(int objectCount, LLUUID objectID, LLUUID owner, Scene scene, LLVector3 objectPosition);
+        private List<CanDuplicateObject> CanDuplicateObjectCheckFunctions = new List<CanDuplicateObject>();
 
-            public void addCheckDuplicateObject(CanDuplicateObject delegateFunc)
-            {
-                if (!CanDuplicateObjectCheckFunctions.Contains(delegateFunc))
-                    CanDuplicateObjectCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckDuplicateObject(CanDuplicateObject delegateFunc)
-            {
-                if (CanDuplicateObjectCheckFunctions.Contains(delegateFunc))
-                    CanDuplicateObjectCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckDuplicateObject(CanDuplicateObject delegateFunc)
+        {
+            if (!CanDuplicateObjectCheckFunctions.Contains(delegateFunc))
+                CanDuplicateObjectCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanDuplicateObject(int objectCount, LLUUID objectID, LLUUID owner, LLVector3 objectPosition)
+        public void removeCheckDuplicateObject(CanDuplicateObject delegateFunc)
+        {
+            if (CanDuplicateObjectCheckFunctions.Contains(delegateFunc))
+                CanDuplicateObjectCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanDuplicateObject(int objectCount, LLUUID objectID, LLUUID owner, LLVector3 objectPosition)
+        {
+            foreach (CanDuplicateObject check in CanDuplicateObjectCheckFunctions)
             {
-                foreach (CanDuplicateObject check in CanDuplicateObjectCheckFunctions)
+                if (check(objectCount, objectID, owner, m_scene, objectPosition) == false)
                 {
-                    if (check(objectCount, objectID, owner, m_scene, objectPosition) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region EDIT OBJECT
-            public delegate bool CanEditObject(LLUUID objectID, LLUUID editorID, Scene scene);
-            private List<CanEditObject> CanEditObjectCheckFunctions = new List<CanEditObject>();
+        #region EDIT OBJECT
+        public delegate bool CanEditObject(LLUUID objectID, LLUUID editorID, Scene scene);
+        private List<CanEditObject> CanEditObjectCheckFunctions = new List<CanEditObject>();
 
-            public void addCheckEditObject(CanEditObject delegateFunc)
-            {
-                if (!CanEditObjectCheckFunctions.Contains(delegateFunc))
-                    CanEditObjectCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckEditObject(CanEditObject delegateFunc)
-            {
-                if (CanEditObjectCheckFunctions.Contains(delegateFunc))
-                    CanEditObjectCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckEditObject(CanEditObject delegateFunc)
+        {
+            if (!CanEditObjectCheckFunctions.Contains(delegateFunc))
+                CanEditObjectCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanEditObject(LLUUID objectID, LLUUID editorID)
+        public void removeCheckEditObject(CanEditObject delegateFunc)
+        {
+            if (CanEditObjectCheckFunctions.Contains(delegateFunc))
+                CanEditObjectCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanEditObject(LLUUID objectID, LLUUID editorID)
+        {
+            foreach (CanEditObject check in CanEditObjectCheckFunctions)
             {
-                foreach (CanEditObject check in CanEditObjectCheckFunctions)
+                if (check(objectID, editorID, m_scene) == false)
                 {
-                    if (check(objectID, editorID, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region MOVE OBJECT
-            public delegate bool CanMoveObject(LLUUID objectID, LLUUID moverID, Scene scene);
-            private List<CanMoveObject> CanMoveObjectCheckFunctions = new List<CanMoveObject>();
+        #region MOVE OBJECT
+        public delegate bool CanMoveObject(LLUUID objectID, LLUUID moverID, Scene scene);
+        private List<CanMoveObject> CanMoveObjectCheckFunctions = new List<CanMoveObject>();
 
-            public void addCheckMoveObject(CanMoveObject delegateFunc)
-            {
-                if (!CanMoveObjectCheckFunctions.Contains(delegateFunc))
-                    CanMoveObjectCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckMoveObject(CanMoveObject delegateFunc)
-            {
-                if (CanMoveObjectCheckFunctions.Contains(delegateFunc))
-                    CanMoveObjectCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckMoveObject(CanMoveObject delegateFunc)
+        {
+            if (!CanMoveObjectCheckFunctions.Contains(delegateFunc))
+                CanMoveObjectCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanMoveObject(LLUUID objectID, LLUUID moverID)
+        public void removeCheckMoveObject(CanMoveObject delegateFunc)
+        {
+            if (CanMoveObjectCheckFunctions.Contains(delegateFunc))
+                CanMoveObjectCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanMoveObject(LLUUID objectID, LLUUID moverID)
+        {
+            foreach (CanMoveObject check in CanMoveObjectCheckFunctions)
             {
-                foreach (CanMoveObject check in CanMoveObjectCheckFunctions)
+                if (check(objectID,moverID,m_scene) == false)
                 {
-                    if (check(objectID,moverID,m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region OBJECT ENTRY
-            public delegate bool CanObjectEntry(LLUUID objectID, LLVector3 newPoint, Scene scene);
-            private List<CanObjectEntry> CanObjectEntryCheckFunctions = new List<CanObjectEntry>();
+        #region OBJECT ENTRY
+        public delegate bool CanObjectEntry(LLUUID objectID, LLVector3 newPoint, Scene scene);
+        private List<CanObjectEntry> CanObjectEntryCheckFunctions = new List<CanObjectEntry>();
 
-            public void addCheckObjectEntry(CanObjectEntry delegateFunc)
-            {
-                if (!CanObjectEntryCheckFunctions.Contains(delegateFunc))
-                    CanObjectEntryCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckObjectEntry(CanObjectEntry delegateFunc)
-            {
-                if (CanObjectEntryCheckFunctions.Contains(delegateFunc))
-                    CanObjectEntryCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckObjectEntry(CanObjectEntry delegateFunc)
+        {
+            if (!CanObjectEntryCheckFunctions.Contains(delegateFunc))
+                CanObjectEntryCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanObjectEntry(LLUUID objectID, LLVector3 newPoint)
+        public void removeCheckObjectEntry(CanObjectEntry delegateFunc)
+        {
+            if (CanObjectEntryCheckFunctions.Contains(delegateFunc))
+                CanObjectEntryCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanObjectEntry(LLUUID objectID, LLVector3 newPoint)
+        {
+            foreach (CanObjectEntry check in CanObjectEntryCheckFunctions)
             {
-                foreach (CanObjectEntry check in CanObjectEntryCheckFunctions)
+                if (check(objectID, newPoint, m_scene) == false)
                 {
-                    if (check(objectID, newPoint, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region RETURN OBJECT
-            public delegate bool CanReturnObject(LLUUID objectID, LLUUID returnerID, Scene scene);
-            private List<CanReturnObject> CanReturnObjectCheckFunctions = new List<CanReturnObject>();
+        #region RETURN OBJECT
+        public delegate bool CanReturnObject(LLUUID objectID, LLUUID returnerID, Scene scene);
+        private List<CanReturnObject> CanReturnObjectCheckFunctions = new List<CanReturnObject>();
 
-            public void addCheckReturnObject(CanReturnObject delegateFunc)
-            {
-                if (!CanReturnObjectCheckFunctions.Contains(delegateFunc))
-                    CanReturnObjectCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckReturnObject(CanReturnObject delegateFunc)
-            {
-                if (CanReturnObjectCheckFunctions.Contains(delegateFunc))
-                    CanReturnObjectCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckReturnObject(CanReturnObject delegateFunc)
+        {
+            if (!CanReturnObjectCheckFunctions.Contains(delegateFunc))
+                CanReturnObjectCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanReturnObject(LLUUID objectID, LLUUID returnerID)
+        public void removeCheckReturnObject(CanReturnObject delegateFunc)
+        {
+            if (CanReturnObjectCheckFunctions.Contains(delegateFunc))
+                CanReturnObjectCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanReturnObject(LLUUID objectID, LLUUID returnerID)
+        {
+            foreach (CanReturnObject check in CanReturnObjectCheckFunctions)
             {
-                foreach (CanReturnObject check in CanReturnObjectCheckFunctions)
+                if (check(objectID,returnerID,m_scene) == false)
                 {
-                    if (check(objectID,returnerID,m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region INSTANT MESSAGE
-            public delegate bool CanInstantMessage(LLUUID user, LLUUID target, Scene startScene);
-            private List<CanInstantMessage> CanInstantMessageCheckFunctions = new List<CanInstantMessage>();
+        #region INSTANT MESSAGE
+        public delegate bool CanInstantMessage(LLUUID user, LLUUID target, Scene startScene);
+        private List<CanInstantMessage> CanInstantMessageCheckFunctions = new List<CanInstantMessage>();
 
-            public void addCheckInstantMessage(CanInstantMessage delegateFunc)
-            {
-                if (!CanInstantMessageCheckFunctions.Contains(delegateFunc))
-                    CanInstantMessageCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckInstantMessage(CanInstantMessage delegateFunc)
-            {
-                if (CanInstantMessageCheckFunctions.Contains(delegateFunc))
-                    CanInstantMessageCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckInstantMessage(CanInstantMessage delegateFunc)
+        {
+            if (!CanInstantMessageCheckFunctions.Contains(delegateFunc))
+                CanInstantMessageCheckFunctions.Add(delegateFunc);
+        }
+
+        public void removeCheckInstantMessage(CanInstantMessage delegateFunc)
+        {
+            if (CanInstantMessageCheckFunctions.Contains(delegateFunc))
+                CanInstantMessageCheckFunctions.Remove(delegateFunc);
+        }
 
-            public bool ExternalChecksCanInstantMessage(LLUUID user, LLUUID target)
+        public bool ExternalChecksCanInstantMessage(LLUUID user, LLUUID target)
+        {
+            foreach (CanInstantMessage check in CanInstantMessageCheckFunctions)
             {
-                foreach (CanInstantMessage check in CanInstantMessageCheckFunctions)
+                if (check(user, target, m_scene) == false)
                 {
-                    if (check(user, target, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region INVENTORY TRANSFER
-            public delegate bool CanInventoryTransfer(LLUUID user, LLUUID target, Scene startScene);
-            private List<CanInventoryTransfer> CanInventoryTransferCheckFunctions = new List<CanInventoryTransfer>();
+        #region INVENTORY TRANSFER
+        public delegate bool CanInventoryTransfer(LLUUID user, LLUUID target, Scene startScene);
+        private List<CanInventoryTransfer> CanInventoryTransferCheckFunctions = new List<CanInventoryTransfer>();
 
-            public void addCheckInventoryTransfer(CanInventoryTransfer delegateFunc)
-            {
-                if (!CanInventoryTransferCheckFunctions.Contains(delegateFunc))
-                    CanInventoryTransferCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckInventoryTransfer(CanInventoryTransfer delegateFunc)
+        public void addCheckInventoryTransfer(CanInventoryTransfer delegateFunc)
+        {
+            if (!CanInventoryTransferCheckFunctions.Contains(delegateFunc))
+                CanInventoryTransferCheckFunctions.Add(delegateFunc);
+        }
+
+        public void removeCheckInventoryTransfer(CanInventoryTransfer delegateFunc)
             {
                 if (CanInventoryTransferCheckFunctions.Contains(delegateFunc))
                     CanInventoryTransferCheckFunctions.Remove(delegateFunc);
             }
 
-            public bool ExternalChecksCanInventoryTransfer(LLUUID user, LLUUID target)
+        public bool ExternalChecksCanInventoryTransfer(LLUUID user, LLUUID target)
+        {
+            foreach (CanInventoryTransfer check in CanInventoryTransferCheckFunctions)
             {
-                foreach (CanInventoryTransfer check in CanInventoryTransferCheckFunctions)
+                if (check(user, target, m_scene) == false)
                 {
-                    if (check(user, target, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region VIEW SCRIPT
-            public delegate bool CanViewScript(LLUUID script, LLUUID objectID, LLUUID user, Scene scene);
-            private List<CanViewScript> CanViewScriptCheckFunctions = new List<CanViewScript>();
+        #region VIEW SCRIPT
+        public delegate bool CanViewScript(LLUUID script, LLUUID objectID, LLUUID user, Scene scene);
+        private List<CanViewScript> CanViewScriptCheckFunctions = new List<CanViewScript>();
 
-            public void addCheckViewScript(CanViewScript delegateFunc)
-            {
-                if (!CanViewScriptCheckFunctions.Contains(delegateFunc))
-                    CanViewScriptCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckViewScript(CanViewScript delegateFunc)
-            {
-                if (CanViewScriptCheckFunctions.Contains(delegateFunc))
-                    CanViewScriptCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckViewScript(CanViewScript delegateFunc)
+        {
+            if (!CanViewScriptCheckFunctions.Contains(delegateFunc))
+                CanViewScriptCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanViewScript(LLUUID script, LLUUID objectID, LLUUID user)
+        public void removeCheckViewScript(CanViewScript delegateFunc)
+        {
+            if (CanViewScriptCheckFunctions.Contains(delegateFunc))
+                CanViewScriptCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanViewScript(LLUUID script, LLUUID objectID, LLUUID user)
+        {
+            foreach (CanViewScript check in CanViewScriptCheckFunctions)
             {
-                foreach (CanViewScript check in CanViewScriptCheckFunctions)
+                if (check(script, objectID, user, m_scene) == false)
                 {
-                    if (check(script, objectID, user, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            public delegate bool CanViewNotecard(LLUUID script, LLUUID objectID, LLUUID user, Scene scene);
-            private List<CanViewNotecard> CanViewNotecardCheckFunctions = new List<CanViewNotecard>();
+        public delegate bool CanViewNotecard(LLUUID script, LLUUID objectID, LLUUID user, Scene scene);
+        private List<CanViewNotecard> CanViewNotecardCheckFunctions = new List<CanViewNotecard>();
 
-            public void addCheckViewNotecard(CanViewNotecard delegateFunc)
-            {
-                if (!CanViewNotecardCheckFunctions.Contains(delegateFunc))
-                    CanViewNotecardCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckViewNotecard(CanViewNotecard delegateFunc)
-            {
-                if (CanViewNotecardCheckFunctions.Contains(delegateFunc))
-                    CanViewNotecardCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckViewNotecard(CanViewNotecard delegateFunc)
+        {
+            if (!CanViewNotecardCheckFunctions.Contains(delegateFunc))
+                CanViewNotecardCheckFunctions.Add(delegateFunc);
+        }
+
+        public void removeCheckViewNotecard(CanViewNotecard delegateFunc)
+        {
+            if (CanViewNotecardCheckFunctions.Contains(delegateFunc))
+                CanViewNotecardCheckFunctions.Remove(delegateFunc);
+        }
 
-            public bool ExternalChecksCanViewNotecard(LLUUID script, LLUUID objectID, LLUUID user)
+        public bool ExternalChecksCanViewNotecard(LLUUID script, LLUUID objectID, LLUUID user)
+        {
+            foreach (CanViewNotecard check in CanViewNotecardCheckFunctions)
             {
-                foreach (CanViewNotecard check in CanViewNotecardCheckFunctions)
+                if (check(script, objectID, user, m_scene) == false)
                 {
-                    if (check(script, objectID, user, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
+
+        #endregion
 
-            #endregion
+        #region EDIT SCRIPT
+        public delegate bool CanEditScript(LLUUID script, LLUUID objectID, LLUUID user, Scene scene);
+        private List<CanEditScript> CanEditScriptCheckFunctions = new List<CanEditScript>();
 
-            #region EDIT SCRIPT
-            public delegate bool CanEditScript(LLUUID script, LLUUID objectID, LLUUID user, Scene scene);
-            private List<CanEditScript> CanEditScriptCheckFunctions = new List<CanEditScript>();
+        public void addCheckEditScript(CanEditScript delegateFunc)
+        {
+            if (!CanEditScriptCheckFunctions.Contains(delegateFunc))
+                CanEditScriptCheckFunctions.Add(delegateFunc);
+        }
 
-            public void addCheckEditScript(CanEditScript delegateFunc)
-            {
-                if (!CanEditScriptCheckFunctions.Contains(delegateFunc))
-                    CanEditScriptCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckEditScript(CanEditScript delegateFunc)
-            {
-                if (CanEditScriptCheckFunctions.Contains(delegateFunc))
-                    CanEditScriptCheckFunctions.Remove(delegateFunc);
-            }
+        public void removeCheckEditScript(CanEditScript delegateFunc)
+        {
+            if (CanEditScriptCheckFunctions.Contains(delegateFunc))
+                CanEditScriptCheckFunctions.Remove(delegateFunc);
+        }
 
-            public bool ExternalChecksCanEditScript(LLUUID script, LLUUID objectID, LLUUID user)
+        public bool ExternalChecksCanEditScript(LLUUID script, LLUUID objectID, LLUUID user)
+        {
+            foreach (CanEditScript check in CanEditScriptCheckFunctions)
             {
-                foreach (CanEditScript check in CanEditScriptCheckFunctions)
+                if (check(script, objectID, user, m_scene) == false)
                 {
-                    if (check(script, objectID, user, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            public delegate bool CanEditNotecard(LLUUID notecard, LLUUID objectID, LLUUID user, Scene scene);
-            private List<CanEditNotecard> CanEditNotecardCheckFunctions = new List<CanEditNotecard>();
+        public delegate bool CanEditNotecard(LLUUID notecard, LLUUID objectID, LLUUID user, Scene scene);
+        private List<CanEditNotecard> CanEditNotecardCheckFunctions = new List<CanEditNotecard>();
 
-            public void addCheckEditNotecard(CanEditNotecard delegateFunc)
-            {
-                if (!CanEditNotecardCheckFunctions.Contains(delegateFunc))
-                    CanEditNotecardCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckEditNotecard(CanEditNotecard delegateFunc)
-            {
-                if (CanEditNotecardCheckFunctions.Contains(delegateFunc))
-                    CanEditNotecardCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckEditNotecard(CanEditNotecard delegateFunc)
+        {
+            if (!CanEditNotecardCheckFunctions.Contains(delegateFunc))
+                CanEditNotecardCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanEditNotecard(LLUUID script, LLUUID objectID, LLUUID user)
+        public void removeCheckEditNotecard(CanEditNotecard delegateFunc)
+        {
+            if (CanEditNotecardCheckFunctions.Contains(delegateFunc))
+                CanEditNotecardCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanEditNotecard(LLUUID script, LLUUID objectID, LLUUID user)
             {
                 foreach (CanEditNotecard check in CanEditNotecardCheckFunctions)
                 {
@@ -584,388 +603,402 @@ namespace OpenSim.Region.Environment.Scenes
                 return true;
             }
 
-            #endregion
+        #endregion
 
-            #region RUN SCRIPT (When Script Placed in Object)
-            public delegate bool CanRunScript(LLUUID script, LLUUID objectID, LLUUID user, Scene scene);
-            private List<CanRunScript> CanRunScriptCheckFunctions = new List<CanRunScript>();
+        #region RUN SCRIPT (When Script Placed in Object)
+        public delegate bool CanRunScript(LLUUID script, LLUUID objectID, LLUUID user, Scene scene);
+        private List<CanRunScript> CanRunScriptCheckFunctions = new List<CanRunScript>();
 
-            public void addCheckRunScript(CanRunScript delegateFunc)
-            {
-                if (!CanRunScriptCheckFunctions.Contains(delegateFunc))
-                    CanRunScriptCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckRunScript(CanRunScript delegateFunc)
-            {
-                if (CanRunScriptCheckFunctions.Contains(delegateFunc))
-                    CanRunScriptCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckRunScript(CanRunScript delegateFunc)
+        {
+            if (!CanRunScriptCheckFunctions.Contains(delegateFunc))
+                CanRunScriptCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanRunScript(LLUUID script, LLUUID objectID, LLUUID user)
+        public void removeCheckRunScript(CanRunScript delegateFunc)
+        {
+            if (CanRunScriptCheckFunctions.Contains(delegateFunc))
+                CanRunScriptCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanRunScript(LLUUID script, LLUUID objectID, LLUUID user)
+        {
+            foreach (CanRunScript check in CanRunScriptCheckFunctions)
             {
-                foreach (CanRunScript check in CanRunScriptCheckFunctions)
+                if (check(script, objectID, user, m_scene) == false)
                 {
-                    if (check(script, objectID, user, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region START SCRIPT (When Script run box is Checked after placed in object)
-            public delegate bool CanStartScript(LLUUID script, LLUUID user, Scene scene);
-            private List<CanStartScript> CanStartScriptCheckFunctions = new List<CanStartScript>();
+        #region START SCRIPT (When Script run box is Checked after placed in object)
+        public delegate bool CanStartScript(LLUUID script, LLUUID user, Scene scene);
+        private List<CanStartScript> CanStartScriptCheckFunctions = new List<CanStartScript>();
 
-            public void addCheckStartScript(CanStartScript delegateFunc)
-            {
-                if (!CanStartScriptCheckFunctions.Contains(delegateFunc))
-                    CanStartScriptCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckStartScript(CanStartScript delegateFunc)
-            {
-                if (CanStartScriptCheckFunctions.Contains(delegateFunc))
-                    CanStartScriptCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckStartScript(CanStartScript delegateFunc)
+        {
+            if (!CanStartScriptCheckFunctions.Contains(delegateFunc))
+                CanStartScriptCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanStartScript(LLUUID script, LLUUID user)
+        public void removeCheckStartScript(CanStartScript delegateFunc)
+        {
+            if (CanStartScriptCheckFunctions.Contains(delegateFunc))
+                CanStartScriptCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanStartScript(LLUUID script, LLUUID user)
+        {
+            foreach (CanStartScript check in CanStartScriptCheckFunctions)
             {
-                foreach (CanStartScript check in CanStartScriptCheckFunctions)
+                if (check(script, user, m_scene) == false)
                 {
-                    if (check(script, user, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
         #endregion
 
-            #region STOP SCRIPT (When Script run box is unchecked after placed in object)
-            public delegate bool CanStopScript(LLUUID script, LLUUID user, Scene scene);
-            private List<CanStopScript> CanStopScriptCheckFunctions = new List<CanStopScript>();
+        #region STOP SCRIPT (When Script run box is unchecked after placed in object)
+        public delegate bool CanStopScript(LLUUID script, LLUUID user, Scene scene);
+        private List<CanStopScript> CanStopScriptCheckFunctions = new List<CanStopScript>();
 
-            public void addCheckStopScript(CanStopScript delegateFunc)
-            {
-                if (!CanStopScriptCheckFunctions.Contains(delegateFunc))
-                    CanStopScriptCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckStopScript(CanStopScript delegateFunc)
-            {
-                if (CanStopScriptCheckFunctions.Contains(delegateFunc))
-                    CanStopScriptCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckStopScript(CanStopScript delegateFunc)
+        {
+            if (!CanStopScriptCheckFunctions.Contains(delegateFunc))
+                CanStopScriptCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanStopScript(LLUUID script, LLUUID user)
+        public void removeCheckStopScript(CanStopScript delegateFunc)
+        {
+            if (CanStopScriptCheckFunctions.Contains(delegateFunc))
+                CanStopScriptCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanStopScript(LLUUID script, LLUUID user)
+        {
+            foreach (CanStopScript check in CanStopScriptCheckFunctions)
             {
-                foreach (CanStopScript check in CanStopScriptCheckFunctions)
+                if (check(script, user, m_scene) == false)
                 {
-                    if (check(script, user, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region RESET SCRIPT
-            public delegate bool CanResetScript(LLUUID script, LLUUID user, Scene scene);
-            private List<CanResetScript> CanResetScriptCheckFunctions = new List<CanResetScript>();
+        #region RESET SCRIPT
+        public delegate bool CanResetScript(LLUUID script, LLUUID user, Scene scene);
+        private List<CanResetScript> CanResetScriptCheckFunctions = new List<CanResetScript>();
 
-            public void addCheckResetScript(CanResetScript delegateFunc)
-            {
-                if (!CanResetScriptCheckFunctions.Contains(delegateFunc))
-                    CanResetScriptCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckResetScript(CanResetScript delegateFunc)
-            {
-                if (CanResetScriptCheckFunctions.Contains(delegateFunc))
-                    CanResetScriptCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckResetScript(CanResetScript delegateFunc)
+        {
+            if (!CanResetScriptCheckFunctions.Contains(delegateFunc))
+                CanResetScriptCheckFunctions.Add(delegateFunc);
+        }
+
+        public void removeCheckResetScript(CanResetScript delegateFunc)
+        {
+            if (CanResetScriptCheckFunctions.Contains(delegateFunc))
+                CanResetScriptCheckFunctions.Remove(delegateFunc);
+        }
 
-            public bool ExternalChecksCanResetScript(LLUUID script, LLUUID user)
+        public bool ExternalChecksCanResetScript(LLUUID script, LLUUID user)
+        {
+            foreach (CanResetScript check in CanResetScriptCheckFunctions)
             {
-                foreach (CanResetScript check in CanResetScriptCheckFunctions)
+                if (check(script, user, m_scene) == false)
                 {
-                    if (check(script, user, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region TERRAFORM LAND
-            public delegate bool CanTerraformLand(LLUUID user, LLVector3 position, Scene requestFromScene);
-            private List<CanTerraformLand> CanTerraformLandCheckFunctions = new List<CanTerraformLand>();
+        #region TERRAFORM LAND
+        public delegate bool CanTerraformLand(LLUUID user, LLVector3 position, Scene requestFromScene);
+        private List<CanTerraformLand> CanTerraformLandCheckFunctions = new List<CanTerraformLand>();
 
-            public void addCheckTerraformLand(CanTerraformLand delegateFunc)
-            {
-                if (!CanTerraformLandCheckFunctions.Contains(delegateFunc))
-                    CanTerraformLandCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckTerraformLand(CanTerraformLand delegateFunc)
-            {
-                if (CanTerraformLandCheckFunctions.Contains(delegateFunc))
-                    CanTerraformLandCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckTerraformLand(CanTerraformLand delegateFunc)
+        {
+            if (!CanTerraformLandCheckFunctions.Contains(delegateFunc))
+                CanTerraformLandCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanTerraformLand(LLUUID user, LLVector3 pos)
+        public void removeCheckTerraformLand(CanTerraformLand delegateFunc)
+        {
+            if (CanTerraformLandCheckFunctions.Contains(delegateFunc))
+                CanTerraformLandCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanTerraformLand(LLUUID user, LLVector3 pos)
+        {
+            foreach (CanTerraformLand check in CanTerraformLandCheckFunctions)
             {
-                foreach (CanTerraformLand check in CanTerraformLandCheckFunctions)
+                if (check(user, pos, m_scene) == false)
                 {
-                    if (check(user, pos, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region RUN CONSOLE COMMAND
-            public delegate bool CanRunConsoleCommand(LLUUID user, Scene requestFromScene);
-            private List<CanRunConsoleCommand> CanRunConsoleCommandCheckFunctions = new List<CanRunConsoleCommand>();
+        #region RUN CONSOLE COMMAND
+        public delegate bool CanRunConsoleCommand(LLUUID user, Scene requestFromScene);
+        private List<CanRunConsoleCommand> CanRunConsoleCommandCheckFunctions = new List<CanRunConsoleCommand>();
 
-            public void addCheckRunConsoleCommand(CanRunConsoleCommand delegateFunc)
-            {
-                if (!CanRunConsoleCommandCheckFunctions.Contains(delegateFunc))
-                    CanRunConsoleCommandCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckRunConsoleCommand(CanRunConsoleCommand delegateFunc)
-            {
-                if (CanRunConsoleCommandCheckFunctions.Contains(delegateFunc))
-                    CanRunConsoleCommandCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckRunConsoleCommand(CanRunConsoleCommand delegateFunc)
+        {
+            if (!CanRunConsoleCommandCheckFunctions.Contains(delegateFunc))
+                CanRunConsoleCommandCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanRunConsoleCommand(LLUUID user)
+        public void removeCheckRunConsoleCommand(CanRunConsoleCommand delegateFunc)
+        {
+            if (CanRunConsoleCommandCheckFunctions.Contains(delegateFunc))
+                CanRunConsoleCommandCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanRunConsoleCommand(LLUUID user)
+        {
+            foreach (CanRunConsoleCommand check in CanRunConsoleCommandCheckFunctions)
             {
-                foreach (CanRunConsoleCommand check in CanRunConsoleCommandCheckFunctions)
+                if (check(user, m_scene) == false)
                 {
-                    if (check(user, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            #endregion
+        #endregion
 
-            #region CAN ISSUE ESTATE COMMAND
-            public delegate bool CanIssueEstateCommand(LLUUID user, Scene requestFromScene, bool ownerCommand);
-            private List<CanIssueEstateCommand> CanIssueEstateCommandCheckFunctions = new List<CanIssueEstateCommand>();
+        #region CAN ISSUE ESTATE COMMAND
+        public delegate bool CanIssueEstateCommand(LLUUID user, Scene requestFromScene, bool ownerCommand);
+        private List<CanIssueEstateCommand> CanIssueEstateCommandCheckFunctions = new List<CanIssueEstateCommand>();
 
-            public void addCheckIssueEstateCommand(CanIssueEstateCommand delegateFunc)
-            {
-                if (!CanIssueEstateCommandCheckFunctions.Contains(delegateFunc))
-                    CanIssueEstateCommandCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckIssueEstateCommand(CanIssueEstateCommand delegateFunc)
-            {
-                if (CanIssueEstateCommandCheckFunctions.Contains(delegateFunc))
-                    CanIssueEstateCommandCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckIssueEstateCommand(CanIssueEstateCommand delegateFunc)
+        {
+            if (!CanIssueEstateCommandCheckFunctions.Contains(delegateFunc))
+                CanIssueEstateCommandCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanIssueEstateCommand(LLUUID user, bool ownerCommand)
+        public void removeCheckIssueEstateCommand(CanIssueEstateCommand delegateFunc)
+        {
+            if (CanIssueEstateCommandCheckFunctions.Contains(delegateFunc))
+                CanIssueEstateCommandCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanIssueEstateCommand(LLUUID user, bool ownerCommand)
+        {
+            foreach (CanIssueEstateCommand check in CanIssueEstateCommandCheckFunctions)
             {
-                foreach (CanIssueEstateCommand check in CanIssueEstateCommandCheckFunctions)
+                if (check(user, m_scene, ownerCommand) == false)
                 {
-                    if (check(user, m_scene, ownerCommand) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
-            #endregion
+            return true;
+        }
+        #endregion
 
-            #region CAN BE GODLIKE
-            public delegate bool CanBeGodLike(LLUUID user, Scene requestFromScene);
-            private List<CanBeGodLike> CanBeGodLikeCheckFunctions = new List<CanBeGodLike>();
+        #region CAN BE GODLIKE
+        public delegate bool CanBeGodLike(LLUUID user, Scene requestFromScene);
+        private List<CanBeGodLike> CanBeGodLikeCheckFunctions = new List<CanBeGodLike>();
 
-            public void addCheckBeGodLike(CanBeGodLike delegateFunc)
-            {
-                if (!CanBeGodLikeCheckFunctions.Contains(delegateFunc))
-                    CanBeGodLikeCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckBeGodLike(CanBeGodLike delegateFunc)
-            {
-                if (CanBeGodLikeCheckFunctions.Contains(delegateFunc))
-                    CanBeGodLikeCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckBeGodLike(CanBeGodLike delegateFunc)
+        {
+            if (!CanBeGodLikeCheckFunctions.Contains(delegateFunc))
+                CanBeGodLikeCheckFunctions.Add(delegateFunc);
+        }
+
+        public void removeCheckBeGodLike(CanBeGodLike delegateFunc)
+        {
+            if (CanBeGodLikeCheckFunctions.Contains(delegateFunc))
+                CanBeGodLikeCheckFunctions.Remove(delegateFunc);
+        }
 
-            public bool ExternalChecksCanBeGodLike(LLUUID user)
+        public bool ExternalChecksCanBeGodLike(LLUUID user)
+        {
+            foreach (CanBeGodLike check in CanBeGodLikeCheckFunctions)
             {
-                foreach (CanBeGodLike check in CanBeGodLikeCheckFunctions)
+                if (check(user, m_scene) == false)
                 {
-                    if (check(user, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
-            #endregion
+            return true;
+        }
+        #endregion
 
-            #region EDIT PARCEL
-            public delegate bool CanEditParcel(LLUUID user, ILandObject parcel, Scene scene);
-            private List<CanEditParcel> CanEditParcelCheckFunctions = new List<CanEditParcel>();
+        #region EDIT PARCEL
+        public delegate bool CanEditParcel(LLUUID user, ILandObject parcel, Scene scene);
+        private List<CanEditParcel> CanEditParcelCheckFunctions = new List<CanEditParcel>();
 
-            public void addCheckEditParcel(CanEditParcel delegateFunc)
-            {
-                if (!CanEditParcelCheckFunctions.Contains(delegateFunc))
-                    CanEditParcelCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckEditParcel(CanEditParcel delegateFunc)
-            {
-                if (CanEditParcelCheckFunctions.Contains(delegateFunc))
-                    CanEditParcelCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckEditParcel(CanEditParcel delegateFunc)
+        {
+            if (!CanEditParcelCheckFunctions.Contains(delegateFunc))
+                CanEditParcelCheckFunctions.Add(delegateFunc);
+        }
+
+        public void removeCheckEditParcel(CanEditParcel delegateFunc)
+        {
+            if (CanEditParcelCheckFunctions.Contains(delegateFunc))
+                CanEditParcelCheckFunctions.Remove(delegateFunc);
+        }
 
-            public bool ExternalChecksCanEditParcel(LLUUID user, ILandObject parcel)
+        public bool ExternalChecksCanEditParcel(LLUUID user, ILandObject parcel)
+        {
+            foreach (CanEditParcel check in CanEditParcelCheckFunctions)
             {
-                foreach (CanEditParcel check in CanEditParcelCheckFunctions)
+                if (check(user, parcel, m_scene) == false)
                 {
-                    if (check(user, parcel, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
-            #endregion
+            return true;
+        }
+        #endregion
 
-            #region SELL PARCEL
-            public delegate bool CanSellParcel(LLUUID user, ILandObject parcel, Scene scene);
-            private List<CanSellParcel> CanSellParcelCheckFunctions = new List<CanSellParcel>();
+        #region SELL PARCEL
+        public delegate bool CanSellParcel(LLUUID user, ILandObject parcel, Scene scene);
+        private List<CanSellParcel> CanSellParcelCheckFunctions = new List<CanSellParcel>();
 
-            public void addCheckSellParcel(CanSellParcel delegateFunc)
-            {
-                if (!CanSellParcelCheckFunctions.Contains(delegateFunc))
-                    CanSellParcelCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckSellParcel(CanSellParcel delegateFunc)
-            {
-                if (CanSellParcelCheckFunctions.Contains(delegateFunc))
-                    CanSellParcelCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckSellParcel(CanSellParcel delegateFunc)
+        {
+            if (!CanSellParcelCheckFunctions.Contains(delegateFunc))
+                CanSellParcelCheckFunctions.Add(delegateFunc);
+        }
+
+        public void removeCheckSellParcel(CanSellParcel delegateFunc)
+        {
+            if (CanSellParcelCheckFunctions.Contains(delegateFunc))
+                CanSellParcelCheckFunctions.Remove(delegateFunc);
+        }
 
-            public bool ExternalChecksCanSellParcel(LLUUID user, ILandObject parcel)
+        public bool ExternalChecksCanSellParcel(LLUUID user, ILandObject parcel)
+        {
+            foreach (CanSellParcel check in CanSellParcelCheckFunctions)
             {
-                foreach (CanSellParcel check in CanSellParcelCheckFunctions)
+                if (check(user, parcel, m_scene) == false)
                 {
-                    if (check(user, parcel, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
-            #endregion
+            return true;
+        }
+        #endregion
 
-            #region ABANDON PARCEL
-            public delegate bool CanAbandonParcel(LLUUID user, ILandObject parcel, Scene scene);
-            private List<CanAbandonParcel> CanAbandonParcelCheckFunctions = new List<CanAbandonParcel>();
+        #region ABANDON PARCEL
+        public delegate bool CanAbandonParcel(LLUUID user, ILandObject parcel, Scene scene);
+        private List<CanAbandonParcel> CanAbandonParcelCheckFunctions = new List<CanAbandonParcel>();
 
-            public void addCheckAbandonParcel(CanAbandonParcel delegateFunc)
-            {
-                if (!CanAbandonParcelCheckFunctions.Contains(delegateFunc))
-                    CanAbandonParcelCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckAbandonParcel(CanAbandonParcel delegateFunc)
-            {
-                if (CanAbandonParcelCheckFunctions.Contains(delegateFunc))
-                    CanAbandonParcelCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckAbandonParcel(CanAbandonParcel delegateFunc)
+        {
+            if (!CanAbandonParcelCheckFunctions.Contains(delegateFunc))
+                CanAbandonParcelCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanAbandonParcel(LLUUID user, ILandObject parcel)
+        public void removeCheckAbandonParcel(CanAbandonParcel delegateFunc)
+        {
+            if (CanAbandonParcelCheckFunctions.Contains(delegateFunc))
+                CanAbandonParcelCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanAbandonParcel(LLUUID user, ILandObject parcel)
+        {
+            foreach (CanAbandonParcel check in CanAbandonParcelCheckFunctions)
             {
-                foreach (CanAbandonParcel check in CanAbandonParcelCheckFunctions)
+                if (check(user, parcel, m_scene) == false)
                 {
-                    if (check(user, parcel, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
-            #endregion
+            return true;
+        }
+        #endregion
 
-            public delegate bool CanReclaimParcel(LLUUID user, ILandObject parcel, Scene scene);
-            private List<CanReclaimParcel> CanReclaimParcelCheckFunctions = new List<CanReclaimParcel>();
+        public delegate bool CanReclaimParcel(LLUUID user, ILandObject parcel, Scene scene);
+        private List<CanReclaimParcel> CanReclaimParcelCheckFunctions = new List<CanReclaimParcel>();
 
-            public void addCheckReclaimParcel(CanReclaimParcel delegateFunc)
-            {
-                if (!CanReclaimParcelCheckFunctions.Contains(delegateFunc))
-                    CanReclaimParcelCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckReclaimParcel(CanReclaimParcel delegateFunc)
-            {
-                if (CanReclaimParcelCheckFunctions.Contains(delegateFunc))
-                    CanReclaimParcelCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckReclaimParcel(CanReclaimParcel delegateFunc)
+        {
+            if (!CanReclaimParcelCheckFunctions.Contains(delegateFunc))
+                CanReclaimParcelCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanReclaimParcel(LLUUID user, ILandObject parcel)
+        public void removeCheckReclaimParcel(CanReclaimParcel delegateFunc)
+        {
+            if (CanReclaimParcelCheckFunctions.Contains(delegateFunc))
+                CanReclaimParcelCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanReclaimParcel(LLUUID user, ILandObject parcel)
+        {
+            foreach (CanReclaimParcel check in CanReclaimParcelCheckFunctions)
             {
-                foreach (CanReclaimParcel check in CanReclaimParcelCheckFunctions)
+                if (check(user, parcel, m_scene) == false)
                 {
-                    if (check(user, parcel, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
-            public delegate bool CanBuyLand(LLUUID user, ILandObject parcel, Scene scene);
-            private List<CanBuyLand> CanBuyLandCheckFunctions = new List<CanBuyLand>();
+            return true;
+        }
+        public delegate bool CanBuyLand(LLUUID user, ILandObject parcel, Scene scene);
+        private List<CanBuyLand> CanBuyLandCheckFunctions = new List<CanBuyLand>();
 
-            public void addCheckCanBuyLand(CanBuyLand delegateFunc)
-            {
-                if (!CanBuyLandCheckFunctions.Contains(delegateFunc))
-                    CanBuyLandCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckCanBuyLand(CanBuyLand delegateFunc)
-            {
-                if (CanBuyLandCheckFunctions.Contains(delegateFunc))
-                    CanBuyLandCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckCanBuyLand(CanBuyLand delegateFunc)
+        {
+            if (!CanBuyLandCheckFunctions.Contains(delegateFunc))
+                CanBuyLandCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanBuyLand(LLUUID user, ILandObject parcel)
+        public void removeCheckCanBuyLand(CanBuyLand delegateFunc)
+        {
+            if (CanBuyLandCheckFunctions.Contains(delegateFunc))
+                CanBuyLandCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanBuyLand(LLUUID user, ILandObject parcel)
+        {
+            foreach (CanBuyLand check in CanBuyLandCheckFunctions)
             {
-                foreach (CanBuyLand check in CanBuyLandCheckFunctions)
+                if (check(user, parcel, m_scene) == false)
                 {
-                    if (check(user, parcel, m_scene) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            public delegate bool CanLinkObject(LLUUID user, LLUUID objectID);
-            private List<CanLinkObject> CanLinkObjectCheckFunctions = new List<CanLinkObject>();
+        public delegate bool CanLinkObject(LLUUID user, LLUUID objectID);
+        private List<CanLinkObject> CanLinkObjectCheckFunctions = new List<CanLinkObject>();
 
-            public void addCheckCanLinkObject(CanLinkObject delegateFunc)
-            {
-                if (!CanLinkObjectCheckFunctions.Contains(delegateFunc))
-                    CanLinkObjectCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckCanLinkObject(CanLinkObject delegateFunc)
-            {
-                if (CanLinkObjectCheckFunctions.Contains(delegateFunc))
-                    CanLinkObjectCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckCanLinkObject(CanLinkObject delegateFunc)
+        {
+            if (!CanLinkObjectCheckFunctions.Contains(delegateFunc))
+                CanLinkObjectCheckFunctions.Add(delegateFunc);
+        }
+
+        public void removeCheckCanLinkObject(CanLinkObject delegateFunc)
+        {
+            if (CanLinkObjectCheckFunctions.Contains(delegateFunc))
+                CanLinkObjectCheckFunctions.Remove(delegateFunc);
+        }
 
-            public bool ExternalChecksCanLinkObject(LLUUID user, LLUUID objectID)
+        public bool ExternalChecksCanLinkObject(LLUUID user, LLUUID objectID)
             {
                 foreach (CanLinkObject check in CanLinkObjectCheckFunctions)
                 {
@@ -977,137 +1010,141 @@ namespace OpenSim.Region.Environment.Scenes
                 return true;
             }
 
-            public delegate bool CanDelinkObject(LLUUID user, LLUUID objectID);
-            private List<CanDelinkObject> CanDelinkObjectCheckFunctions = new List<CanDelinkObject>();
+        public delegate bool CanDelinkObject(LLUUID user, LLUUID objectID);
+        private List<CanDelinkObject> CanDelinkObjectCheckFunctions = new List<CanDelinkObject>();
 
-            public void addCheckCanDelinkObject(CanDelinkObject delegateFunc)
-            {
-                if (!CanDelinkObjectCheckFunctions.Contains(delegateFunc))
-                    CanDelinkObjectCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckCanDelinkObject(CanDelinkObject delegateFunc)
-            {
-                if (CanDelinkObjectCheckFunctions.Contains(delegateFunc))
-                    CanDelinkObjectCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckCanDelinkObject(CanDelinkObject delegateFunc)
+        {
+            if (!CanDelinkObjectCheckFunctions.Contains(delegateFunc))
+                CanDelinkObjectCheckFunctions.Add(delegateFunc);
+        }
+
+        public void removeCheckCanDelinkObject(CanDelinkObject delegateFunc)
+        {
+            if (CanDelinkObjectCheckFunctions.Contains(delegateFunc))
+                CanDelinkObjectCheckFunctions.Remove(delegateFunc);
+        }
 
-            public bool ExternalChecksCanDelinkObject(LLUUID user, LLUUID objectID)
+        public bool ExternalChecksCanDelinkObject(LLUUID user, LLUUID objectID)
+        {
+            foreach (CanDelinkObject check in CanDelinkObjectCheckFunctions)
             {
-                foreach (CanDelinkObject check in CanDelinkObjectCheckFunctions)
+                if (check(user, objectID) == false)
                 {
-                    if (check(user, objectID) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
         #endregion
 
-            public delegate bool CanCreateInventory(uint invType, LLUUID objectID, LLUUID userID);
-            private List<CanCreateInventory> CanCreateInventoryCheckFunctions = new List<CanCreateInventory>();
+        public delegate bool CanCreateInventory(uint invType, LLUUID objectID, LLUUID userID);
+        private List<CanCreateInventory> CanCreateInventoryCheckFunctions = new List<CanCreateInventory>();
 
-            public void addCheckCanCreateInventory(CanCreateInventory delegateFunc)
-            {
-                if (!CanCreateInventoryCheckFunctions.Contains(delegateFunc))
-                    CanCreateInventoryCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckCanCreateInventory(CanCreateInventory delegateFunc)
-            {
-                if (CanCreateInventoryCheckFunctions.Contains(delegateFunc))
-                    CanCreateInventoryCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckCanCreateInventory(CanCreateInventory delegateFunc)
+        {
+            if (!CanCreateInventoryCheckFunctions.Contains(delegateFunc))
+                CanCreateInventoryCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanCreateInventory(uint invType, LLUUID objectID, LLUUID userID)
+        public void removeCheckCanCreateInventory(CanCreateInventory delegateFunc)
+        {
+            if (CanCreateInventoryCheckFunctions.Contains(delegateFunc))
+                CanCreateInventoryCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanCreateInventory(uint invType, LLUUID objectID, LLUUID userID)
+        {
+            foreach (CanCreateInventory check in CanCreateInventoryCheckFunctions)
             {
-                foreach (CanCreateInventory check in CanCreateInventoryCheckFunctions)
+                if (check(invType, objectID, userID) == false)
                 {
-                    if (check(invType, objectID, userID) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            public delegate bool CanCopyInventory(LLUUID itemID, LLUUID objectID, LLUUID userID);
-            private List<CanCopyInventory> CanCopyInventoryCheckFunctions = new List<CanCopyInventory>();
+        public delegate bool CanCopyInventory(LLUUID itemID, LLUUID objectID, LLUUID userID);
+        private List<CanCopyInventory> CanCopyInventoryCheckFunctions = new List<CanCopyInventory>();
 
-            public void addCheckCanCopyInventory(CanCopyInventory delegateFunc)
-            {
-                if (!CanCopyInventoryCheckFunctions.Contains(delegateFunc))
-                    CanCopyInventoryCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckCanCopyInventory(CanCopyInventory delegateFunc)
-            {
-                if (CanCopyInventoryCheckFunctions.Contains(delegateFunc))
-                    CanCopyInventoryCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckCanCopyInventory(CanCopyInventory delegateFunc)
+        {
+            if (!CanCopyInventoryCheckFunctions.Contains(delegateFunc))
+                CanCopyInventoryCheckFunctions.Add(delegateFunc);
+        }
+
+        public void removeCheckCanCopyInventory(CanCopyInventory delegateFunc)
+        {
+            if (CanCopyInventoryCheckFunctions.Contains(delegateFunc))
+                CanCopyInventoryCheckFunctions.Remove(delegateFunc);
+        }
 
-            public bool ExternalChecksCanCopyInventory(LLUUID itemID, LLUUID objectID, LLUUID userID)
+        public bool ExternalChecksCanCopyInventory(LLUUID itemID, LLUUID objectID, LLUUID userID)
+        {
+            foreach (CanCopyInventory check in CanCopyInventoryCheckFunctions)
             {
-                foreach (CanCopyInventory check in CanCopyInventoryCheckFunctions)
+                if (check(itemID, objectID, userID) == false)
                 {
-                    if (check(itemID, objectID, userID) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            public delegate bool CanDeleteInventory(LLUUID itemID, LLUUID objectID, LLUUID userID);
-            private List<CanDeleteInventory> CanDeleteInventoryCheckFunctions = new List<CanDeleteInventory>();
+        public delegate bool CanDeleteInventory(LLUUID itemID, LLUUID objectID, LLUUID userID);
+        private List<CanDeleteInventory> CanDeleteInventoryCheckFunctions = new List<CanDeleteInventory>();
 
-            public void addCheckCanDeleteInventory(CanDeleteInventory delegateFunc)
-            {
-                if (!CanDeleteInventoryCheckFunctions.Contains(delegateFunc))
-                    CanDeleteInventoryCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckCanDeleteInventory(CanDeleteInventory delegateFunc)
-            {
-                if (CanDeleteInventoryCheckFunctions.Contains(delegateFunc))
-                    CanDeleteInventoryCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckCanDeleteInventory(CanDeleteInventory delegateFunc)
+        {
+            if (!CanDeleteInventoryCheckFunctions.Contains(delegateFunc))
+                CanDeleteInventoryCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanDeleteInventory(LLUUID itemID, LLUUID objectID, LLUUID userID)
+        public void removeCheckCanDeleteInventory(CanDeleteInventory delegateFunc)
+        {
+            if (CanDeleteInventoryCheckFunctions.Contains(delegateFunc))
+                CanDeleteInventoryCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanDeleteInventory(LLUUID itemID, LLUUID objectID, LLUUID userID)
+        {
+            foreach (CanDeleteInventory check in CanDeleteInventoryCheckFunctions)
             {
-                foreach (CanDeleteInventory check in CanDeleteInventoryCheckFunctions)
+                if (check(itemID, objectID, userID) == false)
                 {
-                    if (check(itemID, objectID, userID) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
 
-            public delegate bool CanTeleport(LLUUID userID);
-            private List<CanTeleport> CanTeleportCheckFunctions = new List<CanTeleport>();
+        public delegate bool CanTeleport(LLUUID userID);
+        private List<CanTeleport> CanTeleportCheckFunctions = new List<CanTeleport>();
 
-            public void addCheckCanTeleport(CanTeleport delegateFunc)
-            {
-                if (!CanTeleportCheckFunctions.Contains(delegateFunc))
-                    CanTeleportCheckFunctions.Add(delegateFunc);
-            }
-            public void removeCheckCanTeleport(CanTeleport delegateFunc)
-            {
-                if (CanTeleportCheckFunctions.Contains(delegateFunc))
-                    CanTeleportCheckFunctions.Remove(delegateFunc);
-            }
+        public void addCheckCanTeleport(CanTeleport delegateFunc)
+        {
+            if (!CanTeleportCheckFunctions.Contains(delegateFunc))
+                CanTeleportCheckFunctions.Add(delegateFunc);
+        }
 
-            public bool ExternalChecksCanTeleport(LLUUID userID)
+        public void removeCheckCanTeleport(CanTeleport delegateFunc)
+        {
+            if (CanTeleportCheckFunctions.Contains(delegateFunc))
+                CanTeleportCheckFunctions.Remove(delegateFunc);
+        }
+
+        public bool ExternalChecksCanTeleport(LLUUID userID)
+        {
+            foreach (CanTeleport check in CanTeleportCheckFunctions)
             {
-                foreach (CanTeleport check in CanTeleportCheckFunctions)
+                if (check(userID) == false)
                 {
-                    if (check(userID) == false)
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
+            return true;
+        }
     }
 }
-