diff options
author | Melanie Thielker | 2008-11-21 22:14:57 +0000 |
---|---|---|
committer | Melanie Thielker | 2008-11-21 22:14:57 +0000 |
commit | ba723a4cf65e7a82f5072eaab51dc008f4a2bfd9 (patch) | |
tree | db636daea691f80b0d8bfd3970b8ced36ef9ced0 /OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs | |
parent | * Comment out unused access time method in MSSQL (diff) | |
download | opensim-SC_OLD-ba723a4cf65e7a82f5072eaab51dc008f4a2bfd9.zip opensim-SC_OLD-ba723a4cf65e7a82f5072eaab51dc008f4a2bfd9.tar.gz opensim-SC_OLD-ba723a4cf65e7a82f5072eaab51dc008f4a2bfd9.tar.bz2 opensim-SC_OLD-ba723a4cf65e7a82f5072eaab51dc008f4a2bfd9.tar.xz |
Refactor: Scene.ExternalChecks -> Scene.Permissions. Also make all
the internals of the permissions module adapter sane
Diffstat (limited to '')
-rw-r--r-- | OpenSim/Region/Environment/Scenes/Scene.Permissions.cs (renamed from OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs) | 540 |
1 files changed, 270 insertions, 270 deletions
diff --git a/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs b/OpenSim/Region/Environment/Scenes/Scene.Permissions.cs index 0977734..3a5a3d1 100644 --- a/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs +++ b/OpenSim/Region/Environment/Scenes/Scene.Permissions.cs | |||
@@ -34,33 +34,33 @@ using OpenSim.Region.Environment.Interfaces; | |||
34 | 34 | ||
35 | namespace OpenSim.Region.Environment.Scenes | 35 | namespace OpenSim.Region.Environment.Scenes |
36 | { | 36 | { |
37 | public class SceneExternalChecks | 37 | public class ScenePermissions |
38 | { | 38 | { |
39 | private Scene m_scene; | 39 | private Scene m_scene; |
40 | 40 | ||
41 | public SceneExternalChecks(Scene scene) | 41 | public ScenePermissions(Scene scene) |
42 | { | 42 | { |
43 | m_scene = scene; | 43 | m_scene = scene; |
44 | } | 44 | } |
45 | 45 | ||
46 | #region Object Permission Checks | 46 | #region Object Permission Checks |
47 | 47 | ||
48 | public delegate uint GenerateClientFlags(UUID userID, UUID objectIDID); | 48 | public delegate uint GenerateClientFlagsHandler(UUID userID, UUID objectIDID); |
49 | private List<GenerateClientFlags> GenerateClientFlagsCheckFunctions = new List<GenerateClientFlags>(); | 49 | private List<GenerateClientFlagsHandler> GenerateClientFlagsCheckFunctions = new List<GenerateClientFlagsHandler>(); |
50 | 50 | ||
51 | public void addGenerateClientFlags(GenerateClientFlags delegateFunc) | 51 | public void AddGenerateClientFlagsHandler(GenerateClientFlagsHandler delegateFunc) |
52 | { | 52 | { |
53 | if (!GenerateClientFlagsCheckFunctions.Contains(delegateFunc)) | 53 | if (!GenerateClientFlagsCheckFunctions.Contains(delegateFunc)) |
54 | GenerateClientFlagsCheckFunctions.Add(delegateFunc); | 54 | GenerateClientFlagsCheckFunctions.Add(delegateFunc); |
55 | } | 55 | } |
56 | 56 | ||
57 | public void removeGenerateClientFlags(GenerateClientFlags delegateFunc) | 57 | public void RemoveGenerateClientFlagsHandler(GenerateClientFlagsHandler delegateFunc) |
58 | { | 58 | { |
59 | if (GenerateClientFlagsCheckFunctions.Contains(delegateFunc)) | 59 | if (GenerateClientFlagsCheckFunctions.Contains(delegateFunc)) |
60 | GenerateClientFlagsCheckFunctions.Remove(delegateFunc); | 60 | GenerateClientFlagsCheckFunctions.Remove(delegateFunc); |
61 | } | 61 | } |
62 | 62 | ||
63 | public uint ExternalChecksGenerateClientFlags(UUID userID, UUID objectID) | 63 | public uint GenerateClientFlags(UUID userID, UUID objectID) |
64 | { | 64 | { |
65 | SceneObjectPart part=m_scene.GetSceneObjectPart(objectID); | 65 | SceneObjectPart part=m_scene.GetSceneObjectPart(objectID); |
66 | 66 | ||
@@ -81,54 +81,54 @@ namespace OpenSim.Region.Environment.Scenes | |||
81 | (uint)PrimFlags.ObjectYouOfficer; | 81 | (uint)PrimFlags.ObjectYouOfficer; |
82 | #pragma warning restore 0612 | 82 | #pragma warning restore 0612 |
83 | 83 | ||
84 | foreach (GenerateClientFlags check in GenerateClientFlagsCheckFunctions) | 84 | foreach (GenerateClientFlagsHandler check in GenerateClientFlagsCheckFunctions) |
85 | { | 85 | { |
86 | perms &= check(userID, objectID); | 86 | perms &= check(userID, objectID); |
87 | } | 87 | } |
88 | return perms; | 88 | return perms; |
89 | } | 89 | } |
90 | 90 | ||
91 | public delegate void SetBypassPermissions(bool value); | 91 | public delegate void SetBypassPermissionsHandler(bool value); |
92 | private List<SetBypassPermissions> SetBypassPermissionsCheckFunctions = new List<SetBypassPermissions>(); | 92 | private List<SetBypassPermissionsHandler> SetBypassPermissionsCheckFunctions = new List<SetBypassPermissionsHandler>(); |
93 | 93 | ||
94 | public void addSetBypassPermissions(SetBypassPermissions delegateFunc) | 94 | public void AddSetBypassPermissionsHandler(SetBypassPermissionsHandler delegateFunc) |
95 | { | 95 | { |
96 | if (!SetBypassPermissionsCheckFunctions.Contains(delegateFunc)) | 96 | if (!SetBypassPermissionsCheckFunctions.Contains(delegateFunc)) |
97 | SetBypassPermissionsCheckFunctions.Add(delegateFunc); | 97 | SetBypassPermissionsCheckFunctions.Add(delegateFunc); |
98 | } | 98 | } |
99 | 99 | ||
100 | public void removeSetBypassPermissions(SetBypassPermissions delegateFunc) | 100 | public void RemoveSetBypassPermissionsHandler(SetBypassPermissionsHandler delegateFunc) |
101 | { | 101 | { |
102 | if (SetBypassPermissionsCheckFunctions.Contains(delegateFunc)) | 102 | if (SetBypassPermissionsCheckFunctions.Contains(delegateFunc)) |
103 | SetBypassPermissionsCheckFunctions.Remove(delegateFunc); | 103 | SetBypassPermissionsCheckFunctions.Remove(delegateFunc); |
104 | } | 104 | } |
105 | 105 | ||
106 | public void ExternalChecksSetBypassPermissions(bool value) | 106 | public void SetBypassPermissions(bool value) |
107 | { | 107 | { |
108 | foreach (SetBypassPermissions check in SetBypassPermissionsCheckFunctions) | 108 | foreach (SetBypassPermissionsHandler check in SetBypassPermissionsCheckFunctions) |
109 | { | 109 | { |
110 | check(value); | 110 | check(value); |
111 | } | 111 | } |
112 | } | 112 | } |
113 | 113 | ||
114 | public delegate bool BypassPermissions(); | 114 | public delegate bool BypassPermissionsHandler(); |
115 | private List<BypassPermissions> BypassPermissionsCheckFunctions = new List<BypassPermissions>(); | 115 | private List<BypassPermissionsHandler> BypassPermissionsCheckFunctions = new List<BypassPermissionsHandler>(); |
116 | 116 | ||
117 | public void addBypassPermissions(BypassPermissions delegateFunc) | 117 | public void AddBypassPermissionsHandler(BypassPermissionsHandler delegateFunc) |
118 | { | 118 | { |
119 | if (!BypassPermissionsCheckFunctions.Contains(delegateFunc)) | 119 | if (!BypassPermissionsCheckFunctions.Contains(delegateFunc)) |
120 | BypassPermissionsCheckFunctions.Add(delegateFunc); | 120 | BypassPermissionsCheckFunctions.Add(delegateFunc); |
121 | } | 121 | } |
122 | 122 | ||
123 | public void removeBypassPermissions(BypassPermissions delegateFunc) | 123 | public void RemoveBypassPermissionsHandler(BypassPermissionsHandler delegateFunc) |
124 | { | 124 | { |
125 | if (BypassPermissionsCheckFunctions.Contains(delegateFunc)) | 125 | if (BypassPermissionsCheckFunctions.Contains(delegateFunc)) |
126 | BypassPermissionsCheckFunctions.Remove(delegateFunc); | 126 | BypassPermissionsCheckFunctions.Remove(delegateFunc); |
127 | } | 127 | } |
128 | 128 | ||
129 | public bool ExternalChecksBypassPermissions() | 129 | public bool BypassPermissions() |
130 | { | 130 | { |
131 | foreach (BypassPermissions check in BypassPermissionsCheckFunctions) | 131 | foreach (BypassPermissionsHandler check in BypassPermissionsCheckFunctions) |
132 | { | 132 | { |
133 | if (check() == false) | 133 | if (check() == false) |
134 | { | 134 | { |
@@ -138,24 +138,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
138 | return true; | 138 | return true; |
139 | } | 139 | } |
140 | 140 | ||
141 | public delegate bool PropagatePermissions(); | 141 | public delegate bool PropagatePermissionsHandler(); |
142 | private List<PropagatePermissions> PropagatePermissionsCheckFunctions = new List<PropagatePermissions>(); | 142 | private List<PropagatePermissionsHandler> PropagatePermissionsCheckFunctions = new List<PropagatePermissionsHandler>(); |
143 | 143 | ||
144 | public void addPropagatePermissions(PropagatePermissions delegateFunc) | 144 | public void AddPropagatePermissionsHandler(PropagatePermissionsHandler delegateFunc) |
145 | { | 145 | { |
146 | if (!PropagatePermissionsCheckFunctions.Contains(delegateFunc)) | 146 | if (!PropagatePermissionsCheckFunctions.Contains(delegateFunc)) |
147 | PropagatePermissionsCheckFunctions.Add(delegateFunc); | 147 | PropagatePermissionsCheckFunctions.Add(delegateFunc); |
148 | } | 148 | } |
149 | 149 | ||
150 | public void removePropagatePermissions(PropagatePermissions delegateFunc) | 150 | public void RemovePropagatePermissionsHandler(PropagatePermissionsHandler delegateFunc) |
151 | { | 151 | { |
152 | if (PropagatePermissionsCheckFunctions.Contains(delegateFunc)) | 152 | if (PropagatePermissionsCheckFunctions.Contains(delegateFunc)) |
153 | PropagatePermissionsCheckFunctions.Remove(delegateFunc); | 153 | PropagatePermissionsCheckFunctions.Remove(delegateFunc); |
154 | } | 154 | } |
155 | 155 | ||
156 | public bool ExternalChecksPropagatePermissions() | 156 | public bool PropagatePermissions() |
157 | { | 157 | { |
158 | foreach (PropagatePermissions check in PropagatePermissionsCheckFunctions) | 158 | foreach (PropagatePermissionsHandler check in PropagatePermissionsCheckFunctions) |
159 | { | 159 | { |
160 | if (check() == false) | 160 | if (check() == false) |
161 | { | 161 | { |
@@ -166,24 +166,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
166 | } | 166 | } |
167 | 167 | ||
168 | #region REZ OBJECT | 168 | #region REZ OBJECT |
169 | public delegate bool CanRezObject(int objectCount, UUID owner, Vector3 objectPosition, Scene scene); | 169 | public delegate bool CanRezObjectHandler(int objectCount, UUID owner, Vector3 objectPosition, Scene scene); |
170 | private List<CanRezObject> CanRezObjectCheckFunctions = new List<CanRezObject>(); | 170 | private List<CanRezObjectHandler> CanRezObjectCheckFunctions = new List<CanRezObjectHandler>(); |
171 | 171 | ||
172 | public void addCheckRezObject(CanRezObject delegateFunc) | 172 | public void AddRezObjectHandler(CanRezObjectHandler delegateFunc) |
173 | { | 173 | { |
174 | if (!CanRezObjectCheckFunctions.Contains(delegateFunc)) | 174 | if (!CanRezObjectCheckFunctions.Contains(delegateFunc)) |
175 | CanRezObjectCheckFunctions.Add(delegateFunc); | 175 | CanRezObjectCheckFunctions.Add(delegateFunc); |
176 | } | 176 | } |
177 | 177 | ||
178 | public void removeCheckRezObject(CanRezObject delegateFunc) | 178 | public void RemoveRezObjectHandler(CanRezObjectHandler delegateFunc) |
179 | { | 179 | { |
180 | if (CanRezObjectCheckFunctions.Contains(delegateFunc)) | 180 | if (CanRezObjectCheckFunctions.Contains(delegateFunc)) |
181 | CanRezObjectCheckFunctions.Remove(delegateFunc); | 181 | CanRezObjectCheckFunctions.Remove(delegateFunc); |
182 | } | 182 | } |
183 | 183 | ||
184 | public bool ExternalChecksCanRezObject(int objectCount, UUID owner, Vector3 objectPosition) | 184 | public bool CanRezObject(int objectCount, UUID owner, Vector3 objectPosition) |
185 | { | 185 | { |
186 | foreach (CanRezObject check in CanRezObjectCheckFunctions) | 186 | foreach (CanRezObjectHandler check in CanRezObjectCheckFunctions) |
187 | { | 187 | { |
188 | if (check(objectCount, owner,objectPosition, m_scene) == false) | 188 | if (check(objectCount, owner,objectPosition, m_scene) == false) |
189 | { | 189 | { |
@@ -196,24 +196,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
196 | #endregion | 196 | #endregion |
197 | 197 | ||
198 | #region DELETE OBJECT | 198 | #region DELETE OBJECT |
199 | public delegate bool CanDeleteObject(UUID objectID, UUID deleter, Scene scene); | 199 | public delegate bool CanDeleteObjectHandler(UUID objectID, UUID deleter, Scene scene); |
200 | private List<CanDeleteObject> CanDeleteObjectCheckFunctions = new List<CanDeleteObject>(); | 200 | private List<CanDeleteObjectHandler> CanDeleteObjectCheckFunctions = new List<CanDeleteObjectHandler>(); |
201 | 201 | ||
202 | public void addCheckDeleteObject(CanDeleteObject delegateFunc) | 202 | public void AddDeleteObjectHandler(CanDeleteObjectHandler delegateFunc) |
203 | { | 203 | { |
204 | if (!CanDeleteObjectCheckFunctions.Contains(delegateFunc)) | 204 | if (!CanDeleteObjectCheckFunctions.Contains(delegateFunc)) |
205 | CanDeleteObjectCheckFunctions.Add(delegateFunc); | 205 | CanDeleteObjectCheckFunctions.Add(delegateFunc); |
206 | } | 206 | } |
207 | 207 | ||
208 | public void removeCheckDeleteObject(CanDeleteObject delegateFunc) | 208 | public void RemoveDeleteObjectHandler(CanDeleteObjectHandler delegateFunc) |
209 | { | 209 | { |
210 | if (CanDeleteObjectCheckFunctions.Contains(delegateFunc)) | 210 | if (CanDeleteObjectCheckFunctions.Contains(delegateFunc)) |
211 | CanDeleteObjectCheckFunctions.Remove(delegateFunc); | 211 | CanDeleteObjectCheckFunctions.Remove(delegateFunc); |
212 | } | 212 | } |
213 | 213 | ||
214 | public bool ExternalChecksCanDeleteObject(UUID objectID, UUID deleter) | 214 | public bool CanDeleteObject(UUID objectID, UUID deleter) |
215 | { | 215 | { |
216 | foreach (CanDeleteObject check in CanDeleteObjectCheckFunctions) | 216 | foreach (CanDeleteObjectHandler check in CanDeleteObjectCheckFunctions) |
217 | { | 217 | { |
218 | if (check(objectID,deleter,m_scene) == false) | 218 | if (check(objectID,deleter,m_scene) == false) |
219 | { | 219 | { |
@@ -226,24 +226,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
226 | #endregion | 226 | #endregion |
227 | 227 | ||
228 | #region TAKE OBJECT | 228 | #region TAKE OBJECT |
229 | public delegate bool CanTakeObject(UUID objectID, UUID stealer, Scene scene); | 229 | public delegate bool CanTakeObjectHandler(UUID objectID, UUID stealer, Scene scene); |
230 | private List<CanTakeObject> CanTakeObjectCheckFunctions = new List<CanTakeObject>(); | 230 | private List<CanTakeObjectHandler> CanTakeObjectCheckFunctions = new List<CanTakeObjectHandler>(); |
231 | 231 | ||
232 | public void addCheckTakeObject(CanTakeObject delegateFunc) | 232 | public void AddTakeObjectHandler(CanTakeObjectHandler delegateFunc) |
233 | { | 233 | { |
234 | if (!CanTakeObjectCheckFunctions.Contains(delegateFunc)) | 234 | if (!CanTakeObjectCheckFunctions.Contains(delegateFunc)) |
235 | CanTakeObjectCheckFunctions.Add(delegateFunc); | 235 | CanTakeObjectCheckFunctions.Add(delegateFunc); |
236 | } | 236 | } |
237 | 237 | ||
238 | public void removeCheckTakeObject(CanTakeObject delegateFunc) | 238 | public void RemoveTakeObjectHandler(CanTakeObjectHandler delegateFunc) |
239 | { | 239 | { |
240 | if (CanTakeObjectCheckFunctions.Contains(delegateFunc)) | 240 | if (CanTakeObjectCheckFunctions.Contains(delegateFunc)) |
241 | CanTakeObjectCheckFunctions.Remove(delegateFunc); | 241 | CanTakeObjectCheckFunctions.Remove(delegateFunc); |
242 | } | 242 | } |
243 | 243 | ||
244 | public bool ExternalChecksCanTakeObject(UUID objectID, UUID AvatarTakingUUID) | 244 | public bool CanTakeObject(UUID objectID, UUID AvatarTakingUUID) |
245 | { | 245 | { |
246 | foreach (CanTakeObject check in CanTakeObjectCheckFunctions) | 246 | foreach (CanTakeObjectHandler check in CanTakeObjectCheckFunctions) |
247 | { | 247 | { |
248 | if (check(objectID, AvatarTakingUUID, m_scene) == false) | 248 | if (check(objectID, AvatarTakingUUID, m_scene) == false) |
249 | { | 249 | { |
@@ -256,24 +256,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
256 | #endregion | 256 | #endregion |
257 | 257 | ||
258 | #region TAKE COPY OBJECT | 258 | #region TAKE COPY OBJECT |
259 | public delegate bool CanTakeCopyObject(UUID objectID, UUID userID, Scene inScene); | 259 | public delegate bool CanTakeCopyObjectHandler(UUID objectID, UUID userID, Scene inScene); |
260 | private List<CanTakeCopyObject> CanTakeCopyObjectCheckFunctions = new List<CanTakeCopyObject>(); | 260 | private List<CanTakeCopyObjectHandler> CanTakeCopyObjectCheckFunctions = new List<CanTakeCopyObjectHandler>(); |
261 | 261 | ||
262 | public void addCheckTakeCopyObject(CanTakeCopyObject delegateFunc) | 262 | public void AddTakeCopyObjectHandler(CanTakeCopyObjectHandler delegateFunc) |
263 | { | 263 | { |
264 | if (!CanTakeCopyObjectCheckFunctions.Contains(delegateFunc)) | 264 | if (!CanTakeCopyObjectCheckFunctions.Contains(delegateFunc)) |
265 | CanTakeCopyObjectCheckFunctions.Add(delegateFunc); | 265 | CanTakeCopyObjectCheckFunctions.Add(delegateFunc); |
266 | } | 266 | } |
267 | 267 | ||
268 | public void removeCheckTakeCopyObject(CanTakeCopyObject delegateFunc) | 268 | public void RemoveTakeCopyObjectHandler(CanTakeCopyObjectHandler delegateFunc) |
269 | { | 269 | { |
270 | if (CanTakeCopyObjectCheckFunctions.Contains(delegateFunc)) | 270 | if (CanTakeCopyObjectCheckFunctions.Contains(delegateFunc)) |
271 | CanTakeCopyObjectCheckFunctions.Remove(delegateFunc); | 271 | CanTakeCopyObjectCheckFunctions.Remove(delegateFunc); |
272 | } | 272 | } |
273 | 273 | ||
274 | public bool ExternalChecksCanTakeCopyObject(UUID objectID, UUID userID) | 274 | public bool CanTakeCopyObject(UUID objectID, UUID userID) |
275 | { | 275 | { |
276 | foreach (CanTakeCopyObject check in CanTakeCopyObjectCheckFunctions) | 276 | foreach (CanTakeCopyObjectHandler check in CanTakeCopyObjectCheckFunctions) |
277 | { | 277 | { |
278 | if (check(objectID,userID,m_scene) == false) | 278 | if (check(objectID,userID,m_scene) == false) |
279 | { | 279 | { |
@@ -286,24 +286,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
286 | #endregion | 286 | #endregion |
287 | 287 | ||
288 | #region DUPLICATE OBJECT | 288 | #region DUPLICATE OBJECT |
289 | public delegate bool CanDuplicateObject(int objectCount, UUID objectID, UUID owner, Scene scene, Vector3 objectPosition); | 289 | public delegate bool CanDuplicateObjectHandler(int objectCount, UUID objectID, UUID owner, Scene scene, Vector3 objectPosition); |
290 | private List<CanDuplicateObject> CanDuplicateObjectCheckFunctions = new List<CanDuplicateObject>(); | 290 | private List<CanDuplicateObjectHandler> CanDuplicateObjectCheckFunctions = new List<CanDuplicateObjectHandler>(); |
291 | 291 | ||
292 | public void addCheckDuplicateObject(CanDuplicateObject delegateFunc) | 292 | public void AddDuplicateObjectHandler(CanDuplicateObjectHandler delegateFunc) |
293 | { | 293 | { |
294 | if (!CanDuplicateObjectCheckFunctions.Contains(delegateFunc)) | 294 | if (!CanDuplicateObjectCheckFunctions.Contains(delegateFunc)) |
295 | CanDuplicateObjectCheckFunctions.Add(delegateFunc); | 295 | CanDuplicateObjectCheckFunctions.Add(delegateFunc); |
296 | } | 296 | } |
297 | 297 | ||
298 | public void removeCheckDuplicateObject(CanDuplicateObject delegateFunc) | 298 | public void RemoveDuplicateObjectHandler(CanDuplicateObjectHandler delegateFunc) |
299 | { | 299 | { |
300 | if (CanDuplicateObjectCheckFunctions.Contains(delegateFunc)) | 300 | if (CanDuplicateObjectCheckFunctions.Contains(delegateFunc)) |
301 | CanDuplicateObjectCheckFunctions.Remove(delegateFunc); | 301 | CanDuplicateObjectCheckFunctions.Remove(delegateFunc); |
302 | } | 302 | } |
303 | 303 | ||
304 | public bool ExternalChecksCanDuplicateObject(int objectCount, UUID objectID, UUID owner, Vector3 objectPosition) | 304 | public bool CanDuplicateObject(int objectCount, UUID objectID, UUID owner, Vector3 objectPosition) |
305 | { | 305 | { |
306 | foreach (CanDuplicateObject check in CanDuplicateObjectCheckFunctions) | 306 | foreach (CanDuplicateObjectHandler check in CanDuplicateObjectCheckFunctions) |
307 | { | 307 | { |
308 | if (check(objectCount, objectID, owner, m_scene, objectPosition) == false) | 308 | if (check(objectCount, objectID, owner, m_scene, objectPosition) == false) |
309 | { | 309 | { |
@@ -316,24 +316,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
316 | #endregion | 316 | #endregion |
317 | 317 | ||
318 | #region EDIT OBJECT | 318 | #region EDIT OBJECT |
319 | public delegate bool CanEditObject(UUID objectID, UUID editorID, Scene scene); | 319 | public delegate bool CanEditObjectHandler(UUID objectID, UUID editorID, Scene scene); |
320 | private List<CanEditObject> CanEditObjectCheckFunctions = new List<CanEditObject>(); | 320 | private List<CanEditObjectHandler> CanEditObjectCheckFunctions = new List<CanEditObjectHandler>(); |
321 | 321 | ||
322 | public void addCheckEditObject(CanEditObject delegateFunc) | 322 | public void AddEditObjectHandler(CanEditObjectHandler delegateFunc) |
323 | { | 323 | { |
324 | if (!CanEditObjectCheckFunctions.Contains(delegateFunc)) | 324 | if (!CanEditObjectCheckFunctions.Contains(delegateFunc)) |
325 | CanEditObjectCheckFunctions.Add(delegateFunc); | 325 | CanEditObjectCheckFunctions.Add(delegateFunc); |
326 | } | 326 | } |
327 | 327 | ||
328 | public void removeCheckEditObject(CanEditObject delegateFunc) | 328 | public void RemoveEditObjectHandler(CanEditObjectHandler delegateFunc) |
329 | { | 329 | { |
330 | if (CanEditObjectCheckFunctions.Contains(delegateFunc)) | 330 | if (CanEditObjectCheckFunctions.Contains(delegateFunc)) |
331 | CanEditObjectCheckFunctions.Remove(delegateFunc); | 331 | CanEditObjectCheckFunctions.Remove(delegateFunc); |
332 | } | 332 | } |
333 | 333 | ||
334 | public bool ExternalChecksCanEditObject(UUID objectID, UUID editorID) | 334 | public bool CanEditObject(UUID objectID, UUID editorID) |
335 | { | 335 | { |
336 | foreach (CanEditObject check in CanEditObjectCheckFunctions) | 336 | foreach (CanEditObjectHandler check in CanEditObjectCheckFunctions) |
337 | { | 337 | { |
338 | if (check(objectID, editorID, m_scene) == false) | 338 | if (check(objectID, editorID, m_scene) == false) |
339 | { | 339 | { |
@@ -343,24 +343,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
343 | return true; | 343 | return true; |
344 | } | 344 | } |
345 | 345 | ||
346 | public delegate bool CanEditObjectInventory(UUID objectID, UUID editorID, Scene scene); | 346 | public delegate bool CanEditObjectInventoryHandler(UUID objectID, UUID editorID, Scene scene); |
347 | private List<CanEditObjectInventory> CanEditObjectInventoryCheckFunctions = new List<CanEditObjectInventory>(); | 347 | private List<CanEditObjectInventoryHandler> CanEditObjectInventoryCheckFunctions = new List<CanEditObjectInventoryHandler>(); |
348 | 348 | ||
349 | public void addCheckEditObjectInventory(CanEditObjectInventory delegateFunc) | 349 | public void AddEditObjectInventoryHandler(CanEditObjectInventoryHandler delegateFunc) |
350 | { | 350 | { |
351 | if (!CanEditObjectInventoryCheckFunctions.Contains(delegateFunc)) | 351 | if (!CanEditObjectInventoryCheckFunctions.Contains(delegateFunc)) |
352 | CanEditObjectInventoryCheckFunctions.Add(delegateFunc); | 352 | CanEditObjectInventoryCheckFunctions.Add(delegateFunc); |
353 | } | 353 | } |
354 | 354 | ||
355 | public void removeCheckEditObjectInventory(CanEditObjectInventory delegateFunc) | 355 | public void RemoveEditObjectInventoryHandler(CanEditObjectInventoryHandler delegateFunc) |
356 | { | 356 | { |
357 | if (CanEditObjectInventoryCheckFunctions.Contains(delegateFunc)) | 357 | if (CanEditObjectInventoryCheckFunctions.Contains(delegateFunc)) |
358 | CanEditObjectInventoryCheckFunctions.Remove(delegateFunc); | 358 | CanEditObjectInventoryCheckFunctions.Remove(delegateFunc); |
359 | } | 359 | } |
360 | 360 | ||
361 | public bool ExternalChecksCanEditObjectInventory(UUID objectID, UUID editorID) | 361 | public bool CanEditObjectInventory(UUID objectID, UUID editorID) |
362 | { | 362 | { |
363 | foreach (CanEditObjectInventory check in CanEditObjectInventoryCheckFunctions) | 363 | foreach (CanEditObjectInventoryHandler check in CanEditObjectInventoryCheckFunctions) |
364 | { | 364 | { |
365 | if (check(objectID, editorID, m_scene) == false) | 365 | if (check(objectID, editorID, m_scene) == false) |
366 | { | 366 | { |
@@ -373,24 +373,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
373 | #endregion | 373 | #endregion |
374 | 374 | ||
375 | #region MOVE OBJECT | 375 | #region MOVE OBJECT |
376 | public delegate bool CanMoveObject(UUID objectID, UUID moverID, Scene scene); | 376 | public delegate bool CanMoveObjectHandler(UUID objectID, UUID moverID, Scene scene); |
377 | private List<CanMoveObject> CanMoveObjectCheckFunctions = new List<CanMoveObject>(); | 377 | private List<CanMoveObjectHandler> CanMoveObjectCheckFunctions = new List<CanMoveObjectHandler>(); |
378 | 378 | ||
379 | public void addCheckMoveObject(CanMoveObject delegateFunc) | 379 | public void AddMoveObjectHandler(CanMoveObjectHandler delegateFunc) |
380 | { | 380 | { |
381 | if (!CanMoveObjectCheckFunctions.Contains(delegateFunc)) | 381 | if (!CanMoveObjectCheckFunctions.Contains(delegateFunc)) |
382 | CanMoveObjectCheckFunctions.Add(delegateFunc); | 382 | CanMoveObjectCheckFunctions.Add(delegateFunc); |
383 | } | 383 | } |
384 | 384 | ||
385 | public void removeCheckMoveObject(CanMoveObject delegateFunc) | 385 | public void RemoveMoveObjectHandler(CanMoveObjectHandler delegateFunc) |
386 | { | 386 | { |
387 | if (CanMoveObjectCheckFunctions.Contains(delegateFunc)) | 387 | if (CanMoveObjectCheckFunctions.Contains(delegateFunc)) |
388 | CanMoveObjectCheckFunctions.Remove(delegateFunc); | 388 | CanMoveObjectCheckFunctions.Remove(delegateFunc); |
389 | } | 389 | } |
390 | 390 | ||
391 | public bool ExternalChecksCanMoveObject(UUID objectID, UUID moverID) | 391 | public bool CanMoveObject(UUID objectID, UUID moverID) |
392 | { | 392 | { |
393 | foreach (CanMoveObject check in CanMoveObjectCheckFunctions) | 393 | foreach (CanMoveObjectHandler check in CanMoveObjectCheckFunctions) |
394 | { | 394 | { |
395 | if (check(objectID,moverID,m_scene) == false) | 395 | if (check(objectID,moverID,m_scene) == false) |
396 | { | 396 | { |
@@ -403,24 +403,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
403 | #endregion | 403 | #endregion |
404 | 404 | ||
405 | #region OBJECT ENTRY | 405 | #region OBJECT ENTRY |
406 | public delegate bool CanObjectEntry(UUID objectID, Vector3 newPoint, Scene scene); | 406 | public delegate bool CanObjectEntryHandler(UUID objectID, Vector3 newPoint, Scene scene); |
407 | private List<CanObjectEntry> CanObjectEntryCheckFunctions = new List<CanObjectEntry>(); | 407 | private List<CanObjectEntryHandler> CanObjectEntryCheckFunctions = new List<CanObjectEntryHandler>(); |
408 | 408 | ||
409 | public void addCheckObjectEntry(CanObjectEntry delegateFunc) | 409 | public void AddObjectEntryHandler(CanObjectEntryHandler delegateFunc) |
410 | { | 410 | { |
411 | if (!CanObjectEntryCheckFunctions.Contains(delegateFunc)) | 411 | if (!CanObjectEntryCheckFunctions.Contains(delegateFunc)) |
412 | CanObjectEntryCheckFunctions.Add(delegateFunc); | 412 | CanObjectEntryCheckFunctions.Add(delegateFunc); |
413 | } | 413 | } |
414 | 414 | ||
415 | public void removeCheckObjectEntry(CanObjectEntry delegateFunc) | 415 | public void RemoveObjectEntryHandler(CanObjectEntryHandler delegateFunc) |
416 | { | 416 | { |
417 | if (CanObjectEntryCheckFunctions.Contains(delegateFunc)) | 417 | if (CanObjectEntryCheckFunctions.Contains(delegateFunc)) |
418 | CanObjectEntryCheckFunctions.Remove(delegateFunc); | 418 | CanObjectEntryCheckFunctions.Remove(delegateFunc); |
419 | } | 419 | } |
420 | 420 | ||
421 | public bool ExternalChecksCanObjectEntry(UUID objectID, Vector3 newPoint) | 421 | public bool CanObjectEntry(UUID objectID, Vector3 newPoint) |
422 | { | 422 | { |
423 | foreach (CanObjectEntry check in CanObjectEntryCheckFunctions) | 423 | foreach (CanObjectEntryHandler check in CanObjectEntryCheckFunctions) |
424 | { | 424 | { |
425 | if (check(objectID, newPoint, m_scene) == false) | 425 | if (check(objectID, newPoint, m_scene) == false) |
426 | { | 426 | { |
@@ -433,24 +433,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
433 | #endregion | 433 | #endregion |
434 | 434 | ||
435 | #region RETURN OBJECT | 435 | #region RETURN OBJECT |
436 | public delegate bool CanReturnObject(UUID objectID, UUID returnerID, Scene scene); | 436 | public delegate bool CanReturnObjectHandler(UUID objectID, UUID returnerID, Scene scene); |
437 | private List<CanReturnObject> CanReturnObjectCheckFunctions = new List<CanReturnObject>(); | 437 | private List<CanReturnObjectHandler> CanReturnObjectCheckFunctions = new List<CanReturnObjectHandler>(); |
438 | 438 | ||
439 | public void addCheckReturnObject(CanReturnObject delegateFunc) | 439 | public void AddReturnObjectHandler(CanReturnObjectHandler delegateFunc) |
440 | { | 440 | { |
441 | if (!CanReturnObjectCheckFunctions.Contains(delegateFunc)) | 441 | if (!CanReturnObjectCheckFunctions.Contains(delegateFunc)) |
442 | CanReturnObjectCheckFunctions.Add(delegateFunc); | 442 | CanReturnObjectCheckFunctions.Add(delegateFunc); |
443 | } | 443 | } |
444 | 444 | ||
445 | public void removeCheckReturnObject(CanReturnObject delegateFunc) | 445 | public void RemoveReturnObjectHandler(CanReturnObjectHandler delegateFunc) |
446 | { | 446 | { |
447 | if (CanReturnObjectCheckFunctions.Contains(delegateFunc)) | 447 | if (CanReturnObjectCheckFunctions.Contains(delegateFunc)) |
448 | CanReturnObjectCheckFunctions.Remove(delegateFunc); | 448 | CanReturnObjectCheckFunctions.Remove(delegateFunc); |
449 | } | 449 | } |
450 | 450 | ||
451 | public bool ExternalChecksCanReturnObject(UUID objectID, UUID returnerID) | 451 | public bool CanReturnObject(UUID objectID, UUID returnerID) |
452 | { | 452 | { |
453 | foreach (CanReturnObject check in CanReturnObjectCheckFunctions) | 453 | foreach (CanReturnObjectHandler check in CanReturnObjectCheckFunctions) |
454 | { | 454 | { |
455 | if (check(objectID,returnerID,m_scene) == false) | 455 | if (check(objectID,returnerID,m_scene) == false) |
456 | { | 456 | { |
@@ -463,24 +463,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
463 | #endregion | 463 | #endregion |
464 | 464 | ||
465 | #region INSTANT MESSAGE | 465 | #region INSTANT MESSAGE |
466 | public delegate bool CanInstantMessage(UUID user, UUID target, Scene startScene); | 466 | public delegate bool CanInstantMessageHandler(UUID user, UUID target, Scene startScene); |
467 | private List<CanInstantMessage> CanInstantMessageCheckFunctions = new List<CanInstantMessage>(); | 467 | private List<CanInstantMessageHandler> CanInstantMessageCheckFunctions = new List<CanInstantMessageHandler>(); |
468 | 468 | ||
469 | public void addCheckInstantMessage(CanInstantMessage delegateFunc) | 469 | public void AddInstantMessageHandler(CanInstantMessageHandler delegateFunc) |
470 | { | 470 | { |
471 | if (!CanInstantMessageCheckFunctions.Contains(delegateFunc)) | 471 | if (!CanInstantMessageCheckFunctions.Contains(delegateFunc)) |
472 | CanInstantMessageCheckFunctions.Add(delegateFunc); | 472 | CanInstantMessageCheckFunctions.Add(delegateFunc); |
473 | } | 473 | } |
474 | 474 | ||
475 | public void removeCheckInstantMessage(CanInstantMessage delegateFunc) | 475 | public void RemoveInstantMessageHandler(CanInstantMessageHandler delegateFunc) |
476 | { | 476 | { |
477 | if (CanInstantMessageCheckFunctions.Contains(delegateFunc)) | 477 | if (CanInstantMessageCheckFunctions.Contains(delegateFunc)) |
478 | CanInstantMessageCheckFunctions.Remove(delegateFunc); | 478 | CanInstantMessageCheckFunctions.Remove(delegateFunc); |
479 | } | 479 | } |
480 | 480 | ||
481 | public bool ExternalChecksCanInstantMessage(UUID user, UUID target) | 481 | public bool CanInstantMessage(UUID user, UUID target) |
482 | { | 482 | { |
483 | foreach (CanInstantMessage check in CanInstantMessageCheckFunctions) | 483 | foreach (CanInstantMessageHandler check in CanInstantMessageCheckFunctions) |
484 | { | 484 | { |
485 | if (check(user, target, m_scene) == false) | 485 | if (check(user, target, m_scene) == false) |
486 | { | 486 | { |
@@ -493,24 +493,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
493 | #endregion | 493 | #endregion |
494 | 494 | ||
495 | #region INVENTORY TRANSFER | 495 | #region INVENTORY TRANSFER |
496 | public delegate bool CanInventoryTransfer(UUID user, UUID target, Scene startScene); | 496 | public delegate bool CanInventoryTransferHandler(UUID user, UUID target, Scene startScene); |
497 | private List<CanInventoryTransfer> CanInventoryTransferCheckFunctions = new List<CanInventoryTransfer>(); | 497 | private List<CanInventoryTransferHandler> CanInventoryTransferCheckFunctions = new List<CanInventoryTransferHandler>(); |
498 | 498 | ||
499 | public void addCheckInventoryTransfer(CanInventoryTransfer delegateFunc) | 499 | public void AddInventoryTransferHandler(CanInventoryTransferHandler delegateFunc) |
500 | { | 500 | { |
501 | if (!CanInventoryTransferCheckFunctions.Contains(delegateFunc)) | 501 | if (!CanInventoryTransferCheckFunctions.Contains(delegateFunc)) |
502 | CanInventoryTransferCheckFunctions.Add(delegateFunc); | 502 | CanInventoryTransferCheckFunctions.Add(delegateFunc); |
503 | } | 503 | } |
504 | 504 | ||
505 | public void removeCheckInventoryTransfer(CanInventoryTransfer delegateFunc) | 505 | public void RemoveInventoryTransferHandler(CanInventoryTransferHandler delegateFunc) |
506 | { | 506 | { |
507 | if (CanInventoryTransferCheckFunctions.Contains(delegateFunc)) | 507 | if (CanInventoryTransferCheckFunctions.Contains(delegateFunc)) |
508 | CanInventoryTransferCheckFunctions.Remove(delegateFunc); | 508 | CanInventoryTransferCheckFunctions.Remove(delegateFunc); |
509 | } | 509 | } |
510 | 510 | ||
511 | public bool ExternalChecksCanInventoryTransfer(UUID user, UUID target) | 511 | public bool CanInventoryTransfer(UUID user, UUID target) |
512 | { | 512 | { |
513 | foreach (CanInventoryTransfer check in CanInventoryTransferCheckFunctions) | 513 | foreach (CanInventoryTransferHandler check in CanInventoryTransferCheckFunctions) |
514 | { | 514 | { |
515 | if (check(user, target, m_scene) == false) | 515 | if (check(user, target, m_scene) == false) |
516 | { | 516 | { |
@@ -523,24 +523,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
523 | #endregion | 523 | #endregion |
524 | 524 | ||
525 | #region VIEW SCRIPT | 525 | #region VIEW SCRIPT |
526 | public delegate bool CanViewScript(UUID script, UUID objectID, UUID user, Scene scene); | 526 | public delegate bool CanViewScriptHandler(UUID script, UUID objectID, UUID user, Scene scene); |
527 | private List<CanViewScript> CanViewScriptCheckFunctions = new List<CanViewScript>(); | 527 | private List<CanViewScriptHandler> CanViewScriptCheckFunctions = new List<CanViewScriptHandler>(); |
528 | 528 | ||
529 | public void addCheckViewScript(CanViewScript delegateFunc) | 529 | public void AddViewScriptHandler(CanViewScriptHandler delegateFunc) |
530 | { | 530 | { |
531 | if (!CanViewScriptCheckFunctions.Contains(delegateFunc)) | 531 | if (!CanViewScriptCheckFunctions.Contains(delegateFunc)) |
532 | CanViewScriptCheckFunctions.Add(delegateFunc); | 532 | CanViewScriptCheckFunctions.Add(delegateFunc); |
533 | } | 533 | } |
534 | 534 | ||
535 | public void removeCheckViewScript(CanViewScript delegateFunc) | 535 | public void RemoveViewScriptHandler(CanViewScriptHandler delegateFunc) |
536 | { | 536 | { |
537 | if (CanViewScriptCheckFunctions.Contains(delegateFunc)) | 537 | if (CanViewScriptCheckFunctions.Contains(delegateFunc)) |
538 | CanViewScriptCheckFunctions.Remove(delegateFunc); | 538 | CanViewScriptCheckFunctions.Remove(delegateFunc); |
539 | } | 539 | } |
540 | 540 | ||
541 | public bool ExternalChecksCanViewScript(UUID script, UUID objectID, UUID user) | 541 | public bool CanViewScript(UUID script, UUID objectID, UUID user) |
542 | { | 542 | { |
543 | foreach (CanViewScript check in CanViewScriptCheckFunctions) | 543 | foreach (CanViewScriptHandler check in CanViewScriptCheckFunctions) |
544 | { | 544 | { |
545 | if (check(script, objectID, user, m_scene) == false) | 545 | if (check(script, objectID, user, m_scene) == false) |
546 | { | 546 | { |
@@ -550,24 +550,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
550 | return true; | 550 | return true; |
551 | } | 551 | } |
552 | 552 | ||
553 | public delegate bool CanViewNotecard(UUID script, UUID objectID, UUID user, Scene scene); | 553 | public delegate bool CanViewNotecardHandler(UUID script, UUID objectID, UUID user, Scene scene); |
554 | private List<CanViewNotecard> CanViewNotecardCheckFunctions = new List<CanViewNotecard>(); | 554 | private List<CanViewNotecardHandler> CanViewNotecardCheckFunctions = new List<CanViewNotecardHandler>(); |
555 | 555 | ||
556 | public void addCheckViewNotecard(CanViewNotecard delegateFunc) | 556 | public void AddViewNotecardHandler(CanViewNotecardHandler delegateFunc) |
557 | { | 557 | { |
558 | if (!CanViewNotecardCheckFunctions.Contains(delegateFunc)) | 558 | if (!CanViewNotecardCheckFunctions.Contains(delegateFunc)) |
559 | CanViewNotecardCheckFunctions.Add(delegateFunc); | 559 | CanViewNotecardCheckFunctions.Add(delegateFunc); |
560 | } | 560 | } |
561 | 561 | ||
562 | public void removeCheckViewNotecard(CanViewNotecard delegateFunc) | 562 | public void RemoveViewNotecardHandler(CanViewNotecardHandler delegateFunc) |
563 | { | 563 | { |
564 | if (CanViewNotecardCheckFunctions.Contains(delegateFunc)) | 564 | if (CanViewNotecardCheckFunctions.Contains(delegateFunc)) |
565 | CanViewNotecardCheckFunctions.Remove(delegateFunc); | 565 | CanViewNotecardCheckFunctions.Remove(delegateFunc); |
566 | } | 566 | } |
567 | 567 | ||
568 | public bool ExternalChecksCanViewNotecard(UUID script, UUID objectID, UUID user) | 568 | public bool CanViewNotecard(UUID script, UUID objectID, UUID user) |
569 | { | 569 | { |
570 | foreach (CanViewNotecard check in CanViewNotecardCheckFunctions) | 570 | foreach (CanViewNotecardHandler check in CanViewNotecardCheckFunctions) |
571 | { | 571 | { |
572 | if (check(script, objectID, user, m_scene) == false) | 572 | if (check(script, objectID, user, m_scene) == false) |
573 | { | 573 | { |
@@ -580,24 +580,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
580 | #endregion | 580 | #endregion |
581 | 581 | ||
582 | #region EDIT SCRIPT | 582 | #region EDIT SCRIPT |
583 | public delegate bool CanEditScript(UUID script, UUID objectID, UUID user, Scene scene); | 583 | public delegate bool CanEditScriptHandler(UUID script, UUID objectID, UUID user, Scene scene); |
584 | private List<CanEditScript> CanEditScriptCheckFunctions = new List<CanEditScript>(); | 584 | private List<CanEditScriptHandler> CanEditScriptCheckFunctions = new List<CanEditScriptHandler>(); |
585 | 585 | ||
586 | public void addCheckEditScript(CanEditScript delegateFunc) | 586 | public void AddEditScriptHandler(CanEditScriptHandler delegateFunc) |
587 | { | 587 | { |
588 | if (!CanEditScriptCheckFunctions.Contains(delegateFunc)) | 588 | if (!CanEditScriptCheckFunctions.Contains(delegateFunc)) |
589 | CanEditScriptCheckFunctions.Add(delegateFunc); | 589 | CanEditScriptCheckFunctions.Add(delegateFunc); |
590 | } | 590 | } |
591 | 591 | ||
592 | public void removeCheckEditScript(CanEditScript delegateFunc) | 592 | public void RemoveEditScriptHandler(CanEditScriptHandler delegateFunc) |
593 | { | 593 | { |
594 | if (CanEditScriptCheckFunctions.Contains(delegateFunc)) | 594 | if (CanEditScriptCheckFunctions.Contains(delegateFunc)) |
595 | CanEditScriptCheckFunctions.Remove(delegateFunc); | 595 | CanEditScriptCheckFunctions.Remove(delegateFunc); |
596 | } | 596 | } |
597 | 597 | ||
598 | public bool ExternalChecksCanEditScript(UUID script, UUID objectID, UUID user) | 598 | public bool CanEditScript(UUID script, UUID objectID, UUID user) |
599 | { | 599 | { |
600 | foreach (CanEditScript check in CanEditScriptCheckFunctions) | 600 | foreach (CanEditScriptHandler check in CanEditScriptCheckFunctions) |
601 | { | 601 | { |
602 | if (check(script, objectID, user, m_scene) == false) | 602 | if (check(script, objectID, user, m_scene) == false) |
603 | { | 603 | { |
@@ -607,24 +607,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
607 | return true; | 607 | return true; |
608 | } | 608 | } |
609 | 609 | ||
610 | public delegate bool CanEditNotecard(UUID notecard, UUID objectID, UUID user, Scene scene); | 610 | public delegate bool CanEditNotecardHandler(UUID notecard, UUID objectID, UUID user, Scene scene); |
611 | private List<CanEditNotecard> CanEditNotecardCheckFunctions = new List<CanEditNotecard>(); | 611 | private List<CanEditNotecardHandler> CanEditNotecardCheckFunctions = new List<CanEditNotecardHandler>(); |
612 | 612 | ||
613 | public void addCheckEditNotecard(CanEditNotecard delegateFunc) | 613 | public void AddEditNotecardHandler(CanEditNotecardHandler delegateFunc) |
614 | { | 614 | { |
615 | if (!CanEditNotecardCheckFunctions.Contains(delegateFunc)) | 615 | if (!CanEditNotecardCheckFunctions.Contains(delegateFunc)) |
616 | CanEditNotecardCheckFunctions.Add(delegateFunc); | 616 | CanEditNotecardCheckFunctions.Add(delegateFunc); |
617 | } | 617 | } |
618 | 618 | ||
619 | public void removeCheckEditNotecard(CanEditNotecard delegateFunc) | 619 | public void RemoveEditNotecardHandler(CanEditNotecardHandler delegateFunc) |
620 | { | 620 | { |
621 | if (CanEditNotecardCheckFunctions.Contains(delegateFunc)) | 621 | if (CanEditNotecardCheckFunctions.Contains(delegateFunc)) |
622 | CanEditNotecardCheckFunctions.Remove(delegateFunc); | 622 | CanEditNotecardCheckFunctions.Remove(delegateFunc); |
623 | } | 623 | } |
624 | 624 | ||
625 | public bool ExternalChecksCanEditNotecard(UUID script, UUID objectID, UUID user) | 625 | public bool CanEditNotecard(UUID script, UUID objectID, UUID user) |
626 | { | 626 | { |
627 | foreach (CanEditNotecard check in CanEditNotecardCheckFunctions) | 627 | foreach (CanEditNotecardHandler check in CanEditNotecardCheckFunctions) |
628 | { | 628 | { |
629 | if (check(script, objectID, user, m_scene) == false) | 629 | if (check(script, objectID, user, m_scene) == false) |
630 | { | 630 | { |
@@ -637,24 +637,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
637 | #endregion | 637 | #endregion |
638 | 638 | ||
639 | #region RUN SCRIPT (When Script Placed in Object) | 639 | #region RUN SCRIPT (When Script Placed in Object) |
640 | public delegate bool CanRunScript(UUID script, UUID objectID, UUID user, Scene scene); | 640 | public delegate bool CanRunScriptHandler(UUID script, UUID objectID, UUID user, Scene scene); |
641 | private List<CanRunScript> CanRunScriptCheckFunctions = new List<CanRunScript>(); | 641 | private List<CanRunScriptHandler> CanRunScriptCheckFunctions = new List<CanRunScriptHandler>(); |
642 | 642 | ||
643 | public void addCheckRunScript(CanRunScript delegateFunc) | 643 | public void AddRunScriptHandler(CanRunScriptHandler delegateFunc) |
644 | { | 644 | { |
645 | if (!CanRunScriptCheckFunctions.Contains(delegateFunc)) | 645 | if (!CanRunScriptCheckFunctions.Contains(delegateFunc)) |
646 | CanRunScriptCheckFunctions.Add(delegateFunc); | 646 | CanRunScriptCheckFunctions.Add(delegateFunc); |
647 | } | 647 | } |
648 | 648 | ||
649 | public void removeCheckRunScript(CanRunScript delegateFunc) | 649 | public void RemoveRunScriptHandler(CanRunScriptHandler delegateFunc) |
650 | { | 650 | { |
651 | if (CanRunScriptCheckFunctions.Contains(delegateFunc)) | 651 | if (CanRunScriptCheckFunctions.Contains(delegateFunc)) |
652 | CanRunScriptCheckFunctions.Remove(delegateFunc); | 652 | CanRunScriptCheckFunctions.Remove(delegateFunc); |
653 | } | 653 | } |
654 | 654 | ||
655 | public bool ExternalChecksCanRunScript(UUID script, UUID objectID, UUID user) | 655 | public bool CanRunScript(UUID script, UUID objectID, UUID user) |
656 | { | 656 | { |
657 | foreach (CanRunScript check in CanRunScriptCheckFunctions) | 657 | foreach (CanRunScriptHandler check in CanRunScriptCheckFunctions) |
658 | { | 658 | { |
659 | if (check(script, objectID, user, m_scene) == false) | 659 | if (check(script, objectID, user, m_scene) == false) |
660 | { | 660 | { |
@@ -667,24 +667,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
667 | #endregion | 667 | #endregion |
668 | 668 | ||
669 | #region START SCRIPT (When Script run box is Checked after placed in object) | 669 | #region START SCRIPT (When Script run box is Checked after placed in object) |
670 | public delegate bool CanStartScript(UUID script, UUID user, Scene scene); | 670 | public delegate bool CanStartScriptHandler(UUID script, UUID user, Scene scene); |
671 | private List<CanStartScript> CanStartScriptCheckFunctions = new List<CanStartScript>(); | 671 | private List<CanStartScriptHandler> CanStartScriptCheckFunctions = new List<CanStartScriptHandler>(); |
672 | 672 | ||
673 | public void addCheckStartScript(CanStartScript delegateFunc) | 673 | public void AddStartScriptHandler(CanStartScriptHandler delegateFunc) |
674 | { | 674 | { |
675 | if (!CanStartScriptCheckFunctions.Contains(delegateFunc)) | 675 | if (!CanStartScriptCheckFunctions.Contains(delegateFunc)) |
676 | CanStartScriptCheckFunctions.Add(delegateFunc); | 676 | CanStartScriptCheckFunctions.Add(delegateFunc); |
677 | } | 677 | } |
678 | 678 | ||
679 | public void removeCheckStartScript(CanStartScript delegateFunc) | 679 | public void RemoveStartScriptHandler(CanStartScriptHandler delegateFunc) |
680 | { | 680 | { |
681 | if (CanStartScriptCheckFunctions.Contains(delegateFunc)) | 681 | if (CanStartScriptCheckFunctions.Contains(delegateFunc)) |
682 | CanStartScriptCheckFunctions.Remove(delegateFunc); | 682 | CanStartScriptCheckFunctions.Remove(delegateFunc); |
683 | } | 683 | } |
684 | 684 | ||
685 | public bool ExternalChecksCanStartScript(UUID script, UUID user) | 685 | public bool CanStartScript(UUID script, UUID user) |
686 | { | 686 | { |
687 | foreach (CanStartScript check in CanStartScriptCheckFunctions) | 687 | foreach (CanStartScriptHandler check in CanStartScriptCheckFunctions) |
688 | { | 688 | { |
689 | if (check(script, user, m_scene) == false) | 689 | if (check(script, user, m_scene) == false) |
690 | { | 690 | { |
@@ -697,24 +697,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
697 | #endregion | 697 | #endregion |
698 | 698 | ||
699 | #region STOP SCRIPT (When Script run box is unchecked after placed in object) | 699 | #region STOP SCRIPT (When Script run box is unchecked after placed in object) |
700 | public delegate bool CanStopScript(UUID script, UUID user, Scene scene); | 700 | public delegate bool CanStopScriptHandler(UUID script, UUID user, Scene scene); |
701 | private List<CanStopScript> CanStopScriptCheckFunctions = new List<CanStopScript>(); | 701 | private List<CanStopScriptHandler> CanStopScriptCheckFunctions = new List<CanStopScriptHandler>(); |
702 | 702 | ||
703 | public void addCheckStopScript(CanStopScript delegateFunc) | 703 | public void AddStopScriptHandler(CanStopScriptHandler delegateFunc) |
704 | { | 704 | { |
705 | if (!CanStopScriptCheckFunctions.Contains(delegateFunc)) | 705 | if (!CanStopScriptCheckFunctions.Contains(delegateFunc)) |
706 | CanStopScriptCheckFunctions.Add(delegateFunc); | 706 | CanStopScriptCheckFunctions.Add(delegateFunc); |
707 | } | 707 | } |
708 | 708 | ||
709 | public void removeCheckStopScript(CanStopScript delegateFunc) | 709 | public void RemoveStopScriptHandler(CanStopScriptHandler delegateFunc) |
710 | { | 710 | { |
711 | if (CanStopScriptCheckFunctions.Contains(delegateFunc)) | 711 | if (CanStopScriptCheckFunctions.Contains(delegateFunc)) |
712 | CanStopScriptCheckFunctions.Remove(delegateFunc); | 712 | CanStopScriptCheckFunctions.Remove(delegateFunc); |
713 | } | 713 | } |
714 | 714 | ||
715 | public bool ExternalChecksCanStopScript(UUID script, UUID user) | 715 | public bool CanStopScript(UUID script, UUID user) |
716 | { | 716 | { |
717 | foreach (CanStopScript check in CanStopScriptCheckFunctions) | 717 | foreach (CanStopScriptHandler check in CanStopScriptCheckFunctions) |
718 | { | 718 | { |
719 | if (check(script, user, m_scene) == false) | 719 | if (check(script, user, m_scene) == false) |
720 | { | 720 | { |
@@ -727,24 +727,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
727 | #endregion | 727 | #endregion |
728 | 728 | ||
729 | #region RESET SCRIPT | 729 | #region RESET SCRIPT |
730 | public delegate bool CanResetScript(UUID script, UUID user, Scene scene); | 730 | public delegate bool CanResetScriptHandler(UUID script, UUID user, Scene scene); |
731 | private List<CanResetScript> CanResetScriptCheckFunctions = new List<CanResetScript>(); | 731 | private List<CanResetScriptHandler> CanResetScriptCheckFunctions = new List<CanResetScriptHandler>(); |
732 | 732 | ||
733 | public void addCheckResetScript(CanResetScript delegateFunc) | 733 | public void AddResetScriptHandler(CanResetScriptHandler delegateFunc) |
734 | { | 734 | { |
735 | if (!CanResetScriptCheckFunctions.Contains(delegateFunc)) | 735 | if (!CanResetScriptCheckFunctions.Contains(delegateFunc)) |
736 | CanResetScriptCheckFunctions.Add(delegateFunc); | 736 | CanResetScriptCheckFunctions.Add(delegateFunc); |
737 | } | 737 | } |
738 | 738 | ||
739 | public void removeCheckResetScript(CanResetScript delegateFunc) | 739 | public void RemoveResetScriptHandler(CanResetScriptHandler delegateFunc) |
740 | { | 740 | { |
741 | if (CanResetScriptCheckFunctions.Contains(delegateFunc)) | 741 | if (CanResetScriptCheckFunctions.Contains(delegateFunc)) |
742 | CanResetScriptCheckFunctions.Remove(delegateFunc); | 742 | CanResetScriptCheckFunctions.Remove(delegateFunc); |
743 | } | 743 | } |
744 | 744 | ||
745 | public bool ExternalChecksCanResetScript(UUID script, UUID user) | 745 | public bool CanResetScript(UUID script, UUID user) |
746 | { | 746 | { |
747 | foreach (CanResetScript check in CanResetScriptCheckFunctions) | 747 | foreach (CanResetScriptHandler check in CanResetScriptCheckFunctions) |
748 | { | 748 | { |
749 | if (check(script, user, m_scene) == false) | 749 | if (check(script, user, m_scene) == false) |
750 | { | 750 | { |
@@ -757,24 +757,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
757 | #endregion | 757 | #endregion |
758 | 758 | ||
759 | #region TERRAFORM LAND | 759 | #region TERRAFORM LAND |
760 | public delegate bool CanTerraformLand(UUID user, Vector3 position, Scene requestFromScene); | 760 | public delegate bool CanTerraformLandHandler(UUID user, Vector3 position, Scene requestFromScene); |
761 | private List<CanTerraformLand> CanTerraformLandCheckFunctions = new List<CanTerraformLand>(); | 761 | private List<CanTerraformLandHandler> CanTerraformLandCheckFunctions = new List<CanTerraformLandHandler>(); |
762 | 762 | ||
763 | public void addCheckTerraformLand(CanTerraformLand delegateFunc) | 763 | public void AddTerraformLandHandler(CanTerraformLandHandler delegateFunc) |
764 | { | 764 | { |
765 | if (!CanTerraformLandCheckFunctions.Contains(delegateFunc)) | 765 | if (!CanTerraformLandCheckFunctions.Contains(delegateFunc)) |
766 | CanTerraformLandCheckFunctions.Add(delegateFunc); | 766 | CanTerraformLandCheckFunctions.Add(delegateFunc); |
767 | } | 767 | } |
768 | 768 | ||
769 | public void removeCheckTerraformLand(CanTerraformLand delegateFunc) | 769 | public void RemoveTerraformLandHandler(CanTerraformLandHandler delegateFunc) |
770 | { | 770 | { |
771 | if (CanTerraformLandCheckFunctions.Contains(delegateFunc)) | 771 | if (CanTerraformLandCheckFunctions.Contains(delegateFunc)) |
772 | CanTerraformLandCheckFunctions.Remove(delegateFunc); | 772 | CanTerraformLandCheckFunctions.Remove(delegateFunc); |
773 | } | 773 | } |
774 | 774 | ||
775 | public bool ExternalChecksCanTerraformLand(UUID user, Vector3 pos) | 775 | public bool CanTerraformLand(UUID user, Vector3 pos) |
776 | { | 776 | { |
777 | foreach (CanTerraformLand check in CanTerraformLandCheckFunctions) | 777 | foreach (CanTerraformLandHandler check in CanTerraformLandCheckFunctions) |
778 | { | 778 | { |
779 | if (check(user, pos, m_scene) == false) | 779 | if (check(user, pos, m_scene) == false) |
780 | { | 780 | { |
@@ -787,24 +787,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
787 | #endregion | 787 | #endregion |
788 | 788 | ||
789 | #region RUN CONSOLE COMMAND | 789 | #region RUN CONSOLE COMMAND |
790 | public delegate bool CanRunConsoleCommand(UUID user, Scene requestFromScene); | 790 | public delegate bool CanRunConsoleCommandHandler(UUID user, Scene requestFromScene); |
791 | private List<CanRunConsoleCommand> CanRunConsoleCommandCheckFunctions = new List<CanRunConsoleCommand>(); | 791 | private List<CanRunConsoleCommandHandler> CanRunConsoleCommandCheckFunctions = new List<CanRunConsoleCommandHandler>(); |
792 | 792 | ||
793 | public void addCheckRunConsoleCommand(CanRunConsoleCommand delegateFunc) | 793 | public void AddRunConsoleCommandHandler(CanRunConsoleCommandHandler delegateFunc) |
794 | { | 794 | { |
795 | if (!CanRunConsoleCommandCheckFunctions.Contains(delegateFunc)) | 795 | if (!CanRunConsoleCommandCheckFunctions.Contains(delegateFunc)) |
796 | CanRunConsoleCommandCheckFunctions.Add(delegateFunc); | 796 | CanRunConsoleCommandCheckFunctions.Add(delegateFunc); |
797 | } | 797 | } |
798 | 798 | ||
799 | public void removeCheckRunConsoleCommand(CanRunConsoleCommand delegateFunc) | 799 | public void RemoveRunConsoleCommandHandler(CanRunConsoleCommandHandler delegateFunc) |
800 | { | 800 | { |
801 | if (CanRunConsoleCommandCheckFunctions.Contains(delegateFunc)) | 801 | if (CanRunConsoleCommandCheckFunctions.Contains(delegateFunc)) |
802 | CanRunConsoleCommandCheckFunctions.Remove(delegateFunc); | 802 | CanRunConsoleCommandCheckFunctions.Remove(delegateFunc); |
803 | } | 803 | } |
804 | 804 | ||
805 | public bool ExternalChecksCanRunConsoleCommand(UUID user) | 805 | public bool CanRunConsoleCommand(UUID user) |
806 | { | 806 | { |
807 | foreach (CanRunConsoleCommand check in CanRunConsoleCommandCheckFunctions) | 807 | foreach (CanRunConsoleCommandHandler check in CanRunConsoleCommandCheckFunctions) |
808 | { | 808 | { |
809 | if (check(user, m_scene) == false) | 809 | if (check(user, m_scene) == false) |
810 | { | 810 | { |
@@ -817,24 +817,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
817 | #endregion | 817 | #endregion |
818 | 818 | ||
819 | #region CAN ISSUE ESTATE COMMAND | 819 | #region CAN ISSUE ESTATE COMMAND |
820 | public delegate bool CanIssueEstateCommand(UUID user, Scene requestFromScene, bool ownerCommand); | 820 | public delegate bool CanIssueEstateCommandHandler(UUID user, Scene requestFromScene, bool ownerCommand); |
821 | private List<CanIssueEstateCommand> CanIssueEstateCommandCheckFunctions = new List<CanIssueEstateCommand>(); | 821 | private List<CanIssueEstateCommandHandler> CanIssueEstateCommandCheckFunctions = new List<CanIssueEstateCommandHandler>(); |
822 | 822 | ||
823 | public void addCheckIssueEstateCommand(CanIssueEstateCommand delegateFunc) | 823 | public void AddIssueEstateCommandHandler(CanIssueEstateCommandHandler delegateFunc) |
824 | { | 824 | { |
825 | if (!CanIssueEstateCommandCheckFunctions.Contains(delegateFunc)) | 825 | if (!CanIssueEstateCommandCheckFunctions.Contains(delegateFunc)) |
826 | CanIssueEstateCommandCheckFunctions.Add(delegateFunc); | 826 | CanIssueEstateCommandCheckFunctions.Add(delegateFunc); |
827 | } | 827 | } |
828 | 828 | ||
829 | public void removeCheckIssueEstateCommand(CanIssueEstateCommand delegateFunc) | 829 | public void RemoveIssueEstateCommandHandler(CanIssueEstateCommandHandler delegateFunc) |
830 | { | 830 | { |
831 | if (CanIssueEstateCommandCheckFunctions.Contains(delegateFunc)) | 831 | if (CanIssueEstateCommandCheckFunctions.Contains(delegateFunc)) |
832 | CanIssueEstateCommandCheckFunctions.Remove(delegateFunc); | 832 | CanIssueEstateCommandCheckFunctions.Remove(delegateFunc); |
833 | } | 833 | } |
834 | 834 | ||
835 | public bool ExternalChecksCanIssueEstateCommand(UUID user, bool ownerCommand) | 835 | public bool CanIssueEstateCommand(UUID user, bool ownerCommand) |
836 | { | 836 | { |
837 | foreach (CanIssueEstateCommand check in CanIssueEstateCommandCheckFunctions) | 837 | foreach (CanIssueEstateCommandHandler check in CanIssueEstateCommandCheckFunctions) |
838 | { | 838 | { |
839 | if (check(user, m_scene, ownerCommand) == false) | 839 | if (check(user, m_scene, ownerCommand) == false) |
840 | { | 840 | { |
@@ -846,24 +846,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
846 | #endregion | 846 | #endregion |
847 | 847 | ||
848 | #region CAN BE GODLIKE | 848 | #region CAN BE GODLIKE |
849 | public delegate bool CanBeGodLike(UUID user, Scene requestFromScene); | 849 | public delegate bool IsGodHandler(UUID user, Scene requestFromScene); |
850 | private List<CanBeGodLike> CanBeGodLikeCheckFunctions = new List<CanBeGodLike>(); | 850 | private List<IsGodHandler> IsGodCheckFunctions = new List<IsGodHandler>(); |
851 | 851 | ||
852 | public void addCheckBeGodLike(CanBeGodLike delegateFunc) | 852 | public void AddIsGodHandler(IsGodHandler delegateFunc) |
853 | { | 853 | { |
854 | if (!CanBeGodLikeCheckFunctions.Contains(delegateFunc)) | 854 | if (!IsGodCheckFunctions.Contains(delegateFunc)) |
855 | CanBeGodLikeCheckFunctions.Add(delegateFunc); | 855 | IsGodCheckFunctions.Add(delegateFunc); |
856 | } | 856 | } |
857 | 857 | ||
858 | public void removeCheckBeGodLike(CanBeGodLike delegateFunc) | 858 | public void RemoveIsGodHandler(IsGodHandler delegateFunc) |
859 | { | 859 | { |
860 | if (CanBeGodLikeCheckFunctions.Contains(delegateFunc)) | 860 | if (IsGodCheckFunctions.Contains(delegateFunc)) |
861 | CanBeGodLikeCheckFunctions.Remove(delegateFunc); | 861 | IsGodCheckFunctions.Remove(delegateFunc); |
862 | } | 862 | } |
863 | 863 | ||
864 | public bool ExternalChecksCanBeGodLike(UUID user) | 864 | public bool IsGod(UUID user) |
865 | { | 865 | { |
866 | foreach (CanBeGodLike check in CanBeGodLikeCheckFunctions) | 866 | foreach (IsGodHandler check in IsGodCheckFunctions) |
867 | { | 867 | { |
868 | if (check(user, m_scene) == false) | 868 | if (check(user, m_scene) == false) |
869 | { | 869 | { |
@@ -875,24 +875,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
875 | #endregion | 875 | #endregion |
876 | 876 | ||
877 | #region EDIT PARCEL | 877 | #region EDIT PARCEL |
878 | public delegate bool CanEditParcel(UUID user, ILandObject parcel, Scene scene); | 878 | public delegate bool CanEditParcelHandler(UUID user, ILandObject parcel, Scene scene); |
879 | private List<CanEditParcel> CanEditParcelCheckFunctions = new List<CanEditParcel>(); | 879 | private List<CanEditParcelHandler> CanEditParcelCheckFunctions = new List<CanEditParcelHandler>(); |
880 | 880 | ||
881 | public void addCheckEditParcel(CanEditParcel delegateFunc) | 881 | public void AddEditParcelHandler(CanEditParcelHandler delegateFunc) |
882 | { | 882 | { |
883 | if (!CanEditParcelCheckFunctions.Contains(delegateFunc)) | 883 | if (!CanEditParcelCheckFunctions.Contains(delegateFunc)) |
884 | CanEditParcelCheckFunctions.Add(delegateFunc); | 884 | CanEditParcelCheckFunctions.Add(delegateFunc); |
885 | } | 885 | } |
886 | 886 | ||
887 | public void removeCheckEditParcel(CanEditParcel delegateFunc) | 887 | public void RemoveEditParcelHandler(CanEditParcelHandler delegateFunc) |
888 | { | 888 | { |
889 | if (CanEditParcelCheckFunctions.Contains(delegateFunc)) | 889 | if (CanEditParcelCheckFunctions.Contains(delegateFunc)) |
890 | CanEditParcelCheckFunctions.Remove(delegateFunc); | 890 | CanEditParcelCheckFunctions.Remove(delegateFunc); |
891 | } | 891 | } |
892 | 892 | ||
893 | public bool ExternalChecksCanEditParcel(UUID user, ILandObject parcel) | 893 | public bool CanEditParcel(UUID user, ILandObject parcel) |
894 | { | 894 | { |
895 | foreach (CanEditParcel check in CanEditParcelCheckFunctions) | 895 | foreach (CanEditParcelHandler check in CanEditParcelCheckFunctions) |
896 | { | 896 | { |
897 | if (check(user, parcel, m_scene) == false) | 897 | if (check(user, parcel, m_scene) == false) |
898 | { | 898 | { |
@@ -904,24 +904,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
904 | #endregion | 904 | #endregion |
905 | 905 | ||
906 | #region SELL PARCEL | 906 | #region SELL PARCEL |
907 | public delegate bool CanSellParcel(UUID user, ILandObject parcel, Scene scene); | 907 | public delegate bool CanSellParcelHandler(UUID user, ILandObject parcel, Scene scene); |
908 | private List<CanSellParcel> CanSellParcelCheckFunctions = new List<CanSellParcel>(); | 908 | private List<CanSellParcelHandler> CanSellParcelCheckFunctions = new List<CanSellParcelHandler>(); |
909 | 909 | ||
910 | public void addCheckSellParcel(CanSellParcel delegateFunc) | 910 | public void AddSellParcelHandler(CanSellParcelHandler delegateFunc) |
911 | { | 911 | { |
912 | if (!CanSellParcelCheckFunctions.Contains(delegateFunc)) | 912 | if (!CanSellParcelCheckFunctions.Contains(delegateFunc)) |
913 | CanSellParcelCheckFunctions.Add(delegateFunc); | 913 | CanSellParcelCheckFunctions.Add(delegateFunc); |
914 | } | 914 | } |
915 | 915 | ||
916 | public void removeCheckSellParcel(CanSellParcel delegateFunc) | 916 | public void RemoveSellParcelHandler(CanSellParcelHandler delegateFunc) |
917 | { | 917 | { |
918 | if (CanSellParcelCheckFunctions.Contains(delegateFunc)) | 918 | if (CanSellParcelCheckFunctions.Contains(delegateFunc)) |
919 | CanSellParcelCheckFunctions.Remove(delegateFunc); | 919 | CanSellParcelCheckFunctions.Remove(delegateFunc); |
920 | } | 920 | } |
921 | 921 | ||
922 | public bool ExternalChecksCanSellParcel(UUID user, ILandObject parcel) | 922 | public bool CanSellParcel(UUID user, ILandObject parcel) |
923 | { | 923 | { |
924 | foreach (CanSellParcel check in CanSellParcelCheckFunctions) | 924 | foreach (CanSellParcelHandler check in CanSellParcelCheckFunctions) |
925 | { | 925 | { |
926 | if (check(user, parcel, m_scene) == false) | 926 | if (check(user, parcel, m_scene) == false) |
927 | { | 927 | { |
@@ -933,24 +933,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
933 | #endregion | 933 | #endregion |
934 | 934 | ||
935 | #region ABANDON PARCEL | 935 | #region ABANDON PARCEL |
936 | public delegate bool CanAbandonParcel(UUID user, ILandObject parcel, Scene scene); | 936 | public delegate bool CanAbandonParcelHandler(UUID user, ILandObject parcel, Scene scene); |
937 | private List<CanAbandonParcel> CanAbandonParcelCheckFunctions = new List<CanAbandonParcel>(); | 937 | private List<CanAbandonParcelHandler> CanAbandonParcelCheckFunctions = new List<CanAbandonParcelHandler>(); |
938 | 938 | ||
939 | public void addCheckAbandonParcel(CanAbandonParcel delegateFunc) | 939 | public void AddAbandonParcelHandler(CanAbandonParcelHandler delegateFunc) |
940 | { | 940 | { |
941 | if (!CanAbandonParcelCheckFunctions.Contains(delegateFunc)) | 941 | if (!CanAbandonParcelCheckFunctions.Contains(delegateFunc)) |
942 | CanAbandonParcelCheckFunctions.Add(delegateFunc); | 942 | CanAbandonParcelCheckFunctions.Add(delegateFunc); |
943 | } | 943 | } |
944 | 944 | ||
945 | public void removeCheckAbandonParcel(CanAbandonParcel delegateFunc) | 945 | public void RemoveAbandonParcelHandler(CanAbandonParcelHandler delegateFunc) |
946 | { | 946 | { |
947 | if (CanAbandonParcelCheckFunctions.Contains(delegateFunc)) | 947 | if (CanAbandonParcelCheckFunctions.Contains(delegateFunc)) |
948 | CanAbandonParcelCheckFunctions.Remove(delegateFunc); | 948 | CanAbandonParcelCheckFunctions.Remove(delegateFunc); |
949 | } | 949 | } |
950 | 950 | ||
951 | public bool ExternalChecksCanAbandonParcel(UUID user, ILandObject parcel) | 951 | public bool CanAbandonParcel(UUID user, ILandObject parcel) |
952 | { | 952 | { |
953 | foreach (CanAbandonParcel check in CanAbandonParcelCheckFunctions) | 953 | foreach (CanAbandonParcelHandler check in CanAbandonParcelCheckFunctions) |
954 | { | 954 | { |
955 | if (check(user, parcel, m_scene) == false) | 955 | if (check(user, parcel, m_scene) == false) |
956 | { | 956 | { |
@@ -961,24 +961,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
961 | } | 961 | } |
962 | #endregion | 962 | #endregion |
963 | 963 | ||
964 | public delegate bool CanReclaimParcel(UUID user, ILandObject parcel, Scene scene); | 964 | public delegate bool CanReclaimParcelHandler(UUID user, ILandObject parcel, Scene scene); |
965 | private List<CanReclaimParcel> CanReclaimParcelCheckFunctions = new List<CanReclaimParcel>(); | 965 | private List<CanReclaimParcelHandler> CanReclaimParcelCheckFunctions = new List<CanReclaimParcelHandler>(); |
966 | 966 | ||
967 | public void addCheckReclaimParcel(CanReclaimParcel delegateFunc) | 967 | public void AddReclaimParcelHandler(CanReclaimParcelHandler delegateFunc) |
968 | { | 968 | { |
969 | if (!CanReclaimParcelCheckFunctions.Contains(delegateFunc)) | 969 | if (!CanReclaimParcelCheckFunctions.Contains(delegateFunc)) |
970 | CanReclaimParcelCheckFunctions.Add(delegateFunc); | 970 | CanReclaimParcelCheckFunctions.Add(delegateFunc); |
971 | } | 971 | } |
972 | 972 | ||
973 | public void removeCheckReclaimParcel(CanReclaimParcel delegateFunc) | 973 | public void RemoveReclaimParcelHandler(CanReclaimParcelHandler delegateFunc) |
974 | { | 974 | { |
975 | if (CanReclaimParcelCheckFunctions.Contains(delegateFunc)) | 975 | if (CanReclaimParcelCheckFunctions.Contains(delegateFunc)) |
976 | CanReclaimParcelCheckFunctions.Remove(delegateFunc); | 976 | CanReclaimParcelCheckFunctions.Remove(delegateFunc); |
977 | } | 977 | } |
978 | 978 | ||
979 | public bool ExternalChecksCanReclaimParcel(UUID user, ILandObject parcel) | 979 | public bool CanReclaimParcel(UUID user, ILandObject parcel) |
980 | { | 980 | { |
981 | foreach (CanReclaimParcel check in CanReclaimParcelCheckFunctions) | 981 | foreach (CanReclaimParcelHandler check in CanReclaimParcelCheckFunctions) |
982 | { | 982 | { |
983 | if (check(user, parcel, m_scene) == false) | 983 | if (check(user, parcel, m_scene) == false) |
984 | { | 984 | { |
@@ -987,24 +987,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
987 | } | 987 | } |
988 | return true; | 988 | return true; |
989 | } | 989 | } |
990 | public delegate bool CanBuyLand(UUID user, ILandObject parcel, Scene scene); | 990 | public delegate bool CanBuyLandHandler(UUID user, ILandObject parcel, Scene scene); |
991 | private List<CanBuyLand> CanBuyLandCheckFunctions = new List<CanBuyLand>(); | 991 | private List<CanBuyLandHandler> CanBuyLandCheckFunctions = new List<CanBuyLandHandler>(); |
992 | 992 | ||
993 | public void addCheckCanBuyLand(CanBuyLand delegateFunc) | 993 | public void AddCanBuyLandHandler(CanBuyLandHandler delegateFunc) |
994 | { | 994 | { |
995 | if (!CanBuyLandCheckFunctions.Contains(delegateFunc)) | 995 | if (!CanBuyLandCheckFunctions.Contains(delegateFunc)) |
996 | CanBuyLandCheckFunctions.Add(delegateFunc); | 996 | CanBuyLandCheckFunctions.Add(delegateFunc); |
997 | } | 997 | } |
998 | 998 | ||
999 | public void removeCheckCanBuyLand(CanBuyLand delegateFunc) | 999 | public void RemoveCanBuyLandHandler(CanBuyLandHandler delegateFunc) |
1000 | { | 1000 | { |
1001 | if (CanBuyLandCheckFunctions.Contains(delegateFunc)) | 1001 | if (CanBuyLandCheckFunctions.Contains(delegateFunc)) |
1002 | CanBuyLandCheckFunctions.Remove(delegateFunc); | 1002 | CanBuyLandCheckFunctions.Remove(delegateFunc); |
1003 | } | 1003 | } |
1004 | 1004 | ||
1005 | public bool ExternalChecksCanBuyLand(UUID user, ILandObject parcel) | 1005 | public bool CanBuyLand(UUID user, ILandObject parcel) |
1006 | { | 1006 | { |
1007 | foreach (CanBuyLand check in CanBuyLandCheckFunctions) | 1007 | foreach (CanBuyLandHandler check in CanBuyLandCheckFunctions) |
1008 | { | 1008 | { |
1009 | if (check(user, parcel, m_scene) == false) | 1009 | if (check(user, parcel, m_scene) == false) |
1010 | { | 1010 | { |
@@ -1014,24 +1014,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
1014 | return true; | 1014 | return true; |
1015 | } | 1015 | } |
1016 | 1016 | ||
1017 | public delegate bool CanLinkObject(UUID user, UUID objectID); | 1017 | public delegate bool CanLinkObjectHandler(UUID user, UUID objectID); |
1018 | private List<CanLinkObject> CanLinkObjectCheckFunctions = new List<CanLinkObject>(); | 1018 | private List<CanLinkObjectHandler> CanLinkObjectCheckFunctions = new List<CanLinkObjectHandler>(); |
1019 | 1019 | ||
1020 | public void addCheckCanLinkObject(CanLinkObject delegateFunc) | 1020 | public void AddCanLinkObjectHandler(CanLinkObjectHandler delegateFunc) |
1021 | { | 1021 | { |
1022 | if (!CanLinkObjectCheckFunctions.Contains(delegateFunc)) | 1022 | if (!CanLinkObjectCheckFunctions.Contains(delegateFunc)) |
1023 | CanLinkObjectCheckFunctions.Add(delegateFunc); | 1023 | CanLinkObjectCheckFunctions.Add(delegateFunc); |
1024 | } | 1024 | } |
1025 | 1025 | ||
1026 | public void removeCheckCanLinkObject(CanLinkObject delegateFunc) | 1026 | public void RemoveCanLinkObjectHandler(CanLinkObjectHandler delegateFunc) |
1027 | { | 1027 | { |
1028 | if (CanLinkObjectCheckFunctions.Contains(delegateFunc)) | 1028 | if (CanLinkObjectCheckFunctions.Contains(delegateFunc)) |
1029 | CanLinkObjectCheckFunctions.Remove(delegateFunc); | 1029 | CanLinkObjectCheckFunctions.Remove(delegateFunc); |
1030 | } | 1030 | } |
1031 | 1031 | ||
1032 | public bool ExternalChecksCanLinkObject(UUID user, UUID objectID) | 1032 | public bool CanLinkObject(UUID user, UUID objectID) |
1033 | { | 1033 | { |
1034 | foreach (CanLinkObject check in CanLinkObjectCheckFunctions) | 1034 | foreach (CanLinkObjectHandler check in CanLinkObjectCheckFunctions) |
1035 | { | 1035 | { |
1036 | if (check(user, objectID) == false) | 1036 | if (check(user, objectID) == false) |
1037 | { | 1037 | { |
@@ -1041,24 +1041,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
1041 | return true; | 1041 | return true; |
1042 | } | 1042 | } |
1043 | 1043 | ||
1044 | public delegate bool CanDelinkObject(UUID user, UUID objectID); | 1044 | public delegate bool CanDelinkObjectHandler(UUID user, UUID objectID); |
1045 | private List<CanDelinkObject> CanDelinkObjectCheckFunctions = new List<CanDelinkObject>(); | 1045 | private List<CanDelinkObjectHandler> CanDelinkObjectCheckFunctions = new List<CanDelinkObjectHandler>(); |
1046 | 1046 | ||
1047 | public void addCheckCanDelinkObject(CanDelinkObject delegateFunc) | 1047 | public void AddCanDelinkObjectHandler(CanDelinkObjectHandler delegateFunc) |
1048 | { | 1048 | { |
1049 | if (!CanDelinkObjectCheckFunctions.Contains(delegateFunc)) | 1049 | if (!CanDelinkObjectCheckFunctions.Contains(delegateFunc)) |
1050 | CanDelinkObjectCheckFunctions.Add(delegateFunc); | 1050 | CanDelinkObjectCheckFunctions.Add(delegateFunc); |
1051 | } | 1051 | } |
1052 | 1052 | ||
1053 | public void removeCheckCanDelinkObject(CanDelinkObject delegateFunc) | 1053 | public void RemoveCanDelinkObjectHandler(CanDelinkObjectHandler delegateFunc) |
1054 | { | 1054 | { |
1055 | if (CanDelinkObjectCheckFunctions.Contains(delegateFunc)) | 1055 | if (CanDelinkObjectCheckFunctions.Contains(delegateFunc)) |
1056 | CanDelinkObjectCheckFunctions.Remove(delegateFunc); | 1056 | CanDelinkObjectCheckFunctions.Remove(delegateFunc); |
1057 | } | 1057 | } |
1058 | 1058 | ||
1059 | public bool ExternalChecksCanDelinkObject(UUID user, UUID objectID) | 1059 | public bool CanDelinkObject(UUID user, UUID objectID) |
1060 | { | 1060 | { |
1061 | foreach (CanDelinkObject check in CanDelinkObjectCheckFunctions) | 1061 | foreach (CanDelinkObjectHandler check in CanDelinkObjectCheckFunctions) |
1062 | { | 1062 | { |
1063 | if (check(user, objectID) == false) | 1063 | if (check(user, objectID) == false) |
1064 | { | 1064 | { |
@@ -1070,18 +1070,18 @@ namespace OpenSim.Region.Environment.Scenes | |||
1070 | 1070 | ||
1071 | #endregion | 1071 | #endregion |
1072 | 1072 | ||
1073 | public delegate bool CanCreateObjectInventory(int invType, UUID objectID, UUID userID); | 1073 | public delegate bool CanCreateObjectInventoryHandler(int invType, UUID objectID, UUID userID); |
1074 | private List<CanCreateObjectInventory> CanCreateObjectInventoryCheckFunctions | 1074 | private List<CanCreateObjectInventoryHandler> CanCreateObjectInventoryCheckFunctions |
1075 | = new List<CanCreateObjectInventory>(); | 1075 | = new List<CanCreateObjectInventoryHandler>(); |
1076 | 1076 | ||
1077 | 1077 | ||
1078 | public void addCheckCanCreateObjectInventory(CanCreateObjectInventory delegateFunc) | 1078 | public void AddCanCreateObjectInventoryHandler(CanCreateObjectInventoryHandler delegateFunc) |
1079 | { | 1079 | { |
1080 | if (!CanCreateObjectInventoryCheckFunctions.Contains(delegateFunc)) | 1080 | if (!CanCreateObjectInventoryCheckFunctions.Contains(delegateFunc)) |
1081 | CanCreateObjectInventoryCheckFunctions.Add(delegateFunc); | 1081 | CanCreateObjectInventoryCheckFunctions.Add(delegateFunc); |
1082 | } | 1082 | } |
1083 | 1083 | ||
1084 | public void removeCheckCanCreateObjectInventory(CanCreateObjectInventory delegateFunc) | 1084 | public void RemoveCanCreateObjectInventoryHandler(CanCreateObjectInventoryHandler delegateFunc) |
1085 | { | 1085 | { |
1086 | if (CanCreateObjectInventoryCheckFunctions.Contains(delegateFunc)) | 1086 | if (CanCreateObjectInventoryCheckFunctions.Contains(delegateFunc)) |
1087 | CanCreateObjectInventoryCheckFunctions.Remove(delegateFunc); | 1087 | CanCreateObjectInventoryCheckFunctions.Remove(delegateFunc); |
@@ -1095,9 +1095,9 @@ namespace OpenSim.Region.Environment.Scenes | |||
1095 | /// <param name="objectID"></param> | 1095 | /// <param name="objectID"></param> |
1096 | /// <param name="userID"></param> | 1096 | /// <param name="userID"></param> |
1097 | /// <returns></returns> | 1097 | /// <returns></returns> |
1098 | public bool ExternalChecksCanCreateObjectInventory(int invType, UUID objectID, UUID userID) | 1098 | public bool CanCreateObjectInventory(int invType, UUID objectID, UUID userID) |
1099 | { | 1099 | { |
1100 | foreach (CanCreateObjectInventory check in CanCreateObjectInventoryCheckFunctions) | 1100 | foreach (CanCreateObjectInventoryHandler check in CanCreateObjectInventoryCheckFunctions) |
1101 | { | 1101 | { |
1102 | if (check(invType, objectID, userID) == false) | 1102 | if (check(invType, objectID, userID) == false) |
1103 | { | 1103 | { |
@@ -1108,24 +1108,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
1108 | return true; | 1108 | return true; |
1109 | } | 1109 | } |
1110 | 1110 | ||
1111 | public delegate bool CanCopyObjectInventory(UUID itemID, UUID objectID, UUID userID); | 1111 | public delegate bool CanCopyObjectInventoryHandler(UUID itemID, UUID objectID, UUID userID); |
1112 | private List<CanCopyObjectInventory> CanCopyObjectInventoryCheckFunctions = new List<CanCopyObjectInventory>(); | 1112 | private List<CanCopyObjectInventoryHandler> CanCopyObjectInventoryCheckFunctions = new List<CanCopyObjectInventoryHandler>(); |
1113 | 1113 | ||
1114 | public void addCheckCanCopyObjectInventory(CanCopyObjectInventory delegateFunc) | 1114 | public void AddCanCopyObjectInventoryHandler(CanCopyObjectInventoryHandler delegateFunc) |
1115 | { | 1115 | { |
1116 | if (!CanCopyObjectInventoryCheckFunctions.Contains(delegateFunc)) | 1116 | if (!CanCopyObjectInventoryCheckFunctions.Contains(delegateFunc)) |
1117 | CanCopyObjectInventoryCheckFunctions.Add(delegateFunc); | 1117 | CanCopyObjectInventoryCheckFunctions.Add(delegateFunc); |
1118 | } | 1118 | } |
1119 | 1119 | ||
1120 | public void removeCheckCanCopyObjectInventory(CanCopyObjectInventory delegateFunc) | 1120 | public void RemoveCanCopyObjectInventoryHandler(CanCopyObjectInventoryHandler delegateFunc) |
1121 | { | 1121 | { |
1122 | if (CanCopyObjectInventoryCheckFunctions.Contains(delegateFunc)) | 1122 | if (CanCopyObjectInventoryCheckFunctions.Contains(delegateFunc)) |
1123 | CanCopyObjectInventoryCheckFunctions.Remove(delegateFunc); | 1123 | CanCopyObjectInventoryCheckFunctions.Remove(delegateFunc); |
1124 | } | 1124 | } |
1125 | 1125 | ||
1126 | public bool ExternalChecksCanCopyObjectInventory(UUID itemID, UUID objectID, UUID userID) | 1126 | public bool CanCopyObjectInventory(UUID itemID, UUID objectID, UUID userID) |
1127 | { | 1127 | { |
1128 | foreach (CanCopyObjectInventory check in CanCopyObjectInventoryCheckFunctions) | 1128 | foreach (CanCopyObjectInventoryHandler check in CanCopyObjectInventoryCheckFunctions) |
1129 | { | 1129 | { |
1130 | if (check(itemID, objectID, userID) == false) | 1130 | if (check(itemID, objectID, userID) == false) |
1131 | { | 1131 | { |
@@ -1135,25 +1135,25 @@ namespace OpenSim.Region.Environment.Scenes | |||
1135 | return true; | 1135 | return true; |
1136 | } | 1136 | } |
1137 | 1137 | ||
1138 | public delegate bool CanDeleteObjectInventory(UUID itemID, UUID objectID, UUID userID); | 1138 | public delegate bool CanDeleteObjectInventoryHandler(UUID itemID, UUID objectID, UUID userID); |
1139 | private List<CanDeleteObjectInventory> CanDeleteObjectInventoryCheckFunctions | 1139 | private List<CanDeleteObjectInventoryHandler> CanDeleteObjectInventoryCheckFunctions |
1140 | = new List<CanDeleteObjectInventory>(); | 1140 | = new List<CanDeleteObjectInventoryHandler>(); |
1141 | 1141 | ||
1142 | public void addCheckCanDeleteObjectInventory(CanDeleteObjectInventory delegateFunc) | 1142 | public void AddCanDeleteObjectInventoryHandler(CanDeleteObjectInventoryHandler delegateFunc) |
1143 | { | 1143 | { |
1144 | if (!CanDeleteObjectInventoryCheckFunctions.Contains(delegateFunc)) | 1144 | if (!CanDeleteObjectInventoryCheckFunctions.Contains(delegateFunc)) |
1145 | CanDeleteObjectInventoryCheckFunctions.Add(delegateFunc); | 1145 | CanDeleteObjectInventoryCheckFunctions.Add(delegateFunc); |
1146 | } | 1146 | } |
1147 | 1147 | ||
1148 | public void removeCheckCanDeleteObjectInventory(CanDeleteObjectInventory delegateFunc) | 1148 | public void RemoveCanDeleteObjectInventoryHandler(CanDeleteObjectInventoryHandler delegateFunc) |
1149 | { | 1149 | { |
1150 | if (CanDeleteObjectInventoryCheckFunctions.Contains(delegateFunc)) | 1150 | if (CanDeleteObjectInventoryCheckFunctions.Contains(delegateFunc)) |
1151 | CanDeleteObjectInventoryCheckFunctions.Remove(delegateFunc); | 1151 | CanDeleteObjectInventoryCheckFunctions.Remove(delegateFunc); |
1152 | } | 1152 | } |
1153 | 1153 | ||
1154 | public bool ExternalChecksCanDeleteObjectInventory(UUID itemID, UUID objectID, UUID userID) | 1154 | public bool CanDeleteObjectInventory(UUID itemID, UUID objectID, UUID userID) |
1155 | { | 1155 | { |
1156 | foreach (CanDeleteObjectInventory check in CanDeleteObjectInventoryCheckFunctions) | 1156 | foreach (CanDeleteObjectInventoryHandler check in CanDeleteObjectInventoryCheckFunctions) |
1157 | { | 1157 | { |
1158 | if (check(itemID, objectID, userID) == false) | 1158 | if (check(itemID, objectID, userID) == false) |
1159 | { | 1159 | { |
@@ -1164,17 +1164,17 @@ namespace OpenSim.Region.Environment.Scenes | |||
1164 | return true; | 1164 | return true; |
1165 | } | 1165 | } |
1166 | 1166 | ||
1167 | public delegate bool CanCreateUserInventory(int invType, UUID userID); | 1167 | public delegate bool CanCreateUserInventoryHandler(int invType, UUID userID); |
1168 | private List<CanCreateUserInventory> CanCreateUserInventoryCheckFunctions | 1168 | private List<CanCreateUserInventoryHandler> CanCreateUserInventoryCheckFunctions |
1169 | = new List<CanCreateUserInventory>(); | 1169 | = new List<CanCreateUserInventoryHandler>(); |
1170 | 1170 | ||
1171 | public void addCheckCanCreateUserInventory(CanCreateUserInventory delegateFunc) | 1171 | public void AddCanCreateUserInventoryHandler(CanCreateUserInventoryHandler delegateFunc) |
1172 | { | 1172 | { |
1173 | if (!CanCreateUserInventoryCheckFunctions.Contains(delegateFunc)) | 1173 | if (!CanCreateUserInventoryCheckFunctions.Contains(delegateFunc)) |
1174 | CanCreateUserInventoryCheckFunctions.Add(delegateFunc); | 1174 | CanCreateUserInventoryCheckFunctions.Add(delegateFunc); |
1175 | } | 1175 | } |
1176 | 1176 | ||
1177 | public void removeCheckCanCreateUserInventory(CanCreateUserInventory delegateFunc) | 1177 | public void RemoveCanCreateUserInventoryHandler(CanCreateUserInventoryHandler delegateFunc) |
1178 | { | 1178 | { |
1179 | if (CanCreateUserInventoryCheckFunctions.Contains(delegateFunc)) | 1179 | if (CanCreateUserInventoryCheckFunctions.Contains(delegateFunc)) |
1180 | CanCreateUserInventoryCheckFunctions.Remove(delegateFunc); | 1180 | CanCreateUserInventoryCheckFunctions.Remove(delegateFunc); |
@@ -1186,9 +1186,9 @@ namespace OpenSim.Region.Environment.Scenes | |||
1186 | /// <param name="invType"></param> | 1186 | /// <param name="invType"></param> |
1187 | /// <param name="userID"></param> | 1187 | /// <param name="userID"></param> |
1188 | /// <returns></returns> | 1188 | /// <returns></returns> |
1189 | public bool ExternalChecksCanCreateUserInventory(int invType, UUID userID) | 1189 | public bool CanCreateUserInventory(int invType, UUID userID) |
1190 | { | 1190 | { |
1191 | foreach (CanCreateUserInventory check in CanCreateUserInventoryCheckFunctions) | 1191 | foreach (CanCreateUserInventoryHandler check in CanCreateUserInventoryCheckFunctions) |
1192 | { | 1192 | { |
1193 | if (check(invType, userID) == false) | 1193 | if (check(invType, userID) == false) |
1194 | { | 1194 | { |
@@ -1199,17 +1199,17 @@ namespace OpenSim.Region.Environment.Scenes | |||
1199 | return true; | 1199 | return true; |
1200 | } | 1200 | } |
1201 | 1201 | ||
1202 | public delegate bool CanEditUserInventory(UUID itemID, UUID userID); | 1202 | public delegate bool CanEditUserInventoryHandler(UUID itemID, UUID userID); |
1203 | private List<CanEditUserInventory> CanEditUserInventoryCheckFunctions | 1203 | private List<CanEditUserInventoryHandler> CanEditUserInventoryCheckFunctions |
1204 | = new List<CanEditUserInventory>(); | 1204 | = new List<CanEditUserInventoryHandler>(); |
1205 | 1205 | ||
1206 | public void addCheckCanEditUserInventory(CanEditUserInventory delegateFunc) | 1206 | public void AddCanEditUserInventoryHandler(CanEditUserInventoryHandler delegateFunc) |
1207 | { | 1207 | { |
1208 | if (!CanEditUserInventoryCheckFunctions.Contains(delegateFunc)) | 1208 | if (!CanEditUserInventoryCheckFunctions.Contains(delegateFunc)) |
1209 | CanEditUserInventoryCheckFunctions.Add(delegateFunc); | 1209 | CanEditUserInventoryCheckFunctions.Add(delegateFunc); |
1210 | } | 1210 | } |
1211 | 1211 | ||
1212 | public void removeCheckCanEditUserInventory(CanEditUserInventory delegateFunc) | 1212 | public void RemoveCanEditUserInventoryHandler(CanEditUserInventoryHandler delegateFunc) |
1213 | { | 1213 | { |
1214 | if (CanEditUserInventoryCheckFunctions.Contains(delegateFunc)) | 1214 | if (CanEditUserInventoryCheckFunctions.Contains(delegateFunc)) |
1215 | CanEditUserInventoryCheckFunctions.Remove(delegateFunc); | 1215 | CanEditUserInventoryCheckFunctions.Remove(delegateFunc); |
@@ -1221,9 +1221,9 @@ namespace OpenSim.Region.Environment.Scenes | |||
1221 | /// <param name="itemID"></param> | 1221 | /// <param name="itemID"></param> |
1222 | /// <param name="userID"></param> | 1222 | /// <param name="userID"></param> |
1223 | /// <returns></returns> | 1223 | /// <returns></returns> |
1224 | public bool ExternalChecksCanEditUserInventory(UUID itemID, UUID userID) | 1224 | public bool CanEditUserInventory(UUID itemID, UUID userID) |
1225 | { | 1225 | { |
1226 | foreach (CanEditUserInventory check in CanEditUserInventoryCheckFunctions) | 1226 | foreach (CanEditUserInventoryHandler check in CanEditUserInventoryCheckFunctions) |
1227 | { | 1227 | { |
1228 | if (check(itemID, userID) == false) | 1228 | if (check(itemID, userID) == false) |
1229 | { | 1229 | { |
@@ -1234,17 +1234,17 @@ namespace OpenSim.Region.Environment.Scenes | |||
1234 | return true; | 1234 | return true; |
1235 | } | 1235 | } |
1236 | 1236 | ||
1237 | public delegate bool CanCopyUserInventory(UUID itemID, UUID userID); | 1237 | public delegate bool CanCopyUserInventoryHandler(UUID itemID, UUID userID); |
1238 | private List<CanCopyUserInventory> CanCopyUserInventoryCheckFunctions | 1238 | private List<CanCopyUserInventoryHandler> CanCopyUserInventoryCheckFunctions |
1239 | = new List<CanCopyUserInventory>(); | 1239 | = new List<CanCopyUserInventoryHandler>(); |
1240 | 1240 | ||
1241 | public void addCheckCanCopyUserInventory(CanCopyUserInventory delegateFunc) | 1241 | public void AddCanCopyUserInventoryHandler(CanCopyUserInventoryHandler delegateFunc) |
1242 | { | 1242 | { |
1243 | if (!CanCopyUserInventoryCheckFunctions.Contains(delegateFunc)) | 1243 | if (!CanCopyUserInventoryCheckFunctions.Contains(delegateFunc)) |
1244 | CanCopyUserInventoryCheckFunctions.Add(delegateFunc); | 1244 | CanCopyUserInventoryCheckFunctions.Add(delegateFunc); |
1245 | } | 1245 | } |
1246 | 1246 | ||
1247 | public void removeCheckCanCopyUserInventory(CanCopyUserInventory delegateFunc) | 1247 | public void RemoveCanCopyUserInventoryHandler(CanCopyUserInventoryHandler delegateFunc) |
1248 | { | 1248 | { |
1249 | if (CanCopyUserInventoryCheckFunctions.Contains(delegateFunc)) | 1249 | if (CanCopyUserInventoryCheckFunctions.Contains(delegateFunc)) |
1250 | CanCopyUserInventoryCheckFunctions.Remove(delegateFunc); | 1250 | CanCopyUserInventoryCheckFunctions.Remove(delegateFunc); |
@@ -1256,9 +1256,9 @@ namespace OpenSim.Region.Environment.Scenes | |||
1256 | /// <param name="itemID"></param> | 1256 | /// <param name="itemID"></param> |
1257 | /// <param name="userID"></param> | 1257 | /// <param name="userID"></param> |
1258 | /// <returns></returns> | 1258 | /// <returns></returns> |
1259 | public bool ExternalChecksCanCopyUserInventory(UUID itemID, UUID userID) | 1259 | public bool CanCopyUserInventory(UUID itemID, UUID userID) |
1260 | { | 1260 | { |
1261 | foreach (CanCopyUserInventory check in CanCopyUserInventoryCheckFunctions) | 1261 | foreach (CanCopyUserInventoryHandler check in CanCopyUserInventoryCheckFunctions) |
1262 | { | 1262 | { |
1263 | if (check(itemID, userID) == false) | 1263 | if (check(itemID, userID) == false) |
1264 | { | 1264 | { |
@@ -1269,17 +1269,17 @@ namespace OpenSim.Region.Environment.Scenes | |||
1269 | return true; | 1269 | return true; |
1270 | } | 1270 | } |
1271 | 1271 | ||
1272 | public delegate bool CanDeleteUserInventory(UUID itemID, UUID userID); | 1272 | public delegate bool CanDeleteUserInventoryHandler(UUID itemID, UUID userID); |
1273 | private List<CanDeleteUserInventory> CanDeleteUserInventoryCheckFunctions | 1273 | private List<CanDeleteUserInventoryHandler> CanDeleteUserInventoryCheckFunctions |
1274 | = new List<CanDeleteUserInventory>(); | 1274 | = new List<CanDeleteUserInventoryHandler>(); |
1275 | 1275 | ||
1276 | public void addCheckCanDeleteUserInventory(CanDeleteUserInventory delegateFunc) | 1276 | public void AddCanDeleteUserInventoryHandler(CanDeleteUserInventoryHandler delegateFunc) |
1277 | { | 1277 | { |
1278 | if (!CanDeleteUserInventoryCheckFunctions.Contains(delegateFunc)) | 1278 | if (!CanDeleteUserInventoryCheckFunctions.Contains(delegateFunc)) |
1279 | CanDeleteUserInventoryCheckFunctions.Add(delegateFunc); | 1279 | CanDeleteUserInventoryCheckFunctions.Add(delegateFunc); |
1280 | } | 1280 | } |
1281 | 1281 | ||
1282 | public void removeCheckCanDeleteUserInventory(CanDeleteUserInventory delegateFunc) | 1282 | public void RemoveCanDeleteUserInventoryHandler(CanDeleteUserInventoryHandler delegateFunc) |
1283 | { | 1283 | { |
1284 | if (CanDeleteUserInventoryCheckFunctions.Contains(delegateFunc)) | 1284 | if (CanDeleteUserInventoryCheckFunctions.Contains(delegateFunc)) |
1285 | CanDeleteUserInventoryCheckFunctions.Remove(delegateFunc); | 1285 | CanDeleteUserInventoryCheckFunctions.Remove(delegateFunc); |
@@ -1291,9 +1291,9 @@ namespace OpenSim.Region.Environment.Scenes | |||
1291 | /// <param name="itemID"></param> | 1291 | /// <param name="itemID"></param> |
1292 | /// <param name="userID"></param> | 1292 | /// <param name="userID"></param> |
1293 | /// <returns></returns> | 1293 | /// <returns></returns> |
1294 | public bool ExternalChecksCanDeleteUserInventory(UUID itemID, UUID userID) | 1294 | public bool CanDeleteUserInventory(UUID itemID, UUID userID) |
1295 | { | 1295 | { |
1296 | foreach (CanDeleteUserInventory check in CanDeleteUserInventoryCheckFunctions) | 1296 | foreach (CanDeleteUserInventoryHandler check in CanDeleteUserInventoryCheckFunctions) |
1297 | { | 1297 | { |
1298 | if (check(itemID, userID) == false) | 1298 | if (check(itemID, userID) == false) |
1299 | { | 1299 | { |
@@ -1304,24 +1304,24 @@ namespace OpenSim.Region.Environment.Scenes | |||
1304 | return true; | 1304 | return true; |
1305 | } | 1305 | } |
1306 | 1306 | ||
1307 | public delegate bool CanTeleport(UUID userID); | 1307 | public delegate bool CanTeleportHandler(UUID userID); |
1308 | private List<CanTeleport> CanTeleportCheckFunctions = new List<CanTeleport>(); | 1308 | private List<CanTeleportHandler> CanTeleportCheckFunctions = new List<CanTeleportHandler>(); |
1309 | 1309 | ||
1310 | public void addCheckCanTeleport(CanTeleport delegateFunc) | 1310 | public void AddCanTeleportHandler(CanTeleportHandler delegateFunc) |
1311 | { | 1311 | { |
1312 | if (!CanTeleportCheckFunctions.Contains(delegateFunc)) | 1312 | if (!CanTeleportCheckFunctions.Contains(delegateFunc)) |
1313 | CanTeleportCheckFunctions.Add(delegateFunc); | 1313 | CanTeleportCheckFunctions.Add(delegateFunc); |
1314 | } | 1314 | } |
1315 | 1315 | ||
1316 | public void removeCheckCanTeleport(CanTeleport delegateFunc) | 1316 | public void RemoveCanTeleportHandler(CanTeleportHandler delegateFunc) |
1317 | { | 1317 | { |
1318 | if (CanTeleportCheckFunctions.Contains(delegateFunc)) | 1318 | if (CanTeleportCheckFunctions.Contains(delegateFunc)) |
1319 | CanTeleportCheckFunctions.Remove(delegateFunc); | 1319 | CanTeleportCheckFunctions.Remove(delegateFunc); |
1320 | } | 1320 | } |
1321 | 1321 | ||
1322 | public bool ExternalChecksCanTeleport(UUID userID) | 1322 | public bool CanTeleport(UUID userID) |
1323 | { | 1323 | { |
1324 | foreach (CanTeleport check in CanTeleportCheckFunctions) | 1324 | foreach (CanTeleportHandler check in CanTeleportCheckFunctions) |
1325 | { | 1325 | { |
1326 | if (check(userID) == false) | 1326 | if (check(userID) == false) |
1327 | { | 1327 | { |