aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs
diff options
context:
space:
mode:
authorJeff Ames2008-05-09 16:24:28 +0000
committerJeff Ames2008-05-09 16:24:28 +0000
commitf9c6cc36e153baeddc873b6c69698dcfa63161f0 (patch)
tree4a1e95fa6acfb6150c3ffe6391558d8166a70a1b /OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs
parent* Minor: Insert utility function to format raw xml strings into indented xml ... (diff)
downloadopensim-SC_OLD-f9c6cc36e153baeddc873b6c69698dcfa63161f0.zip
opensim-SC_OLD-f9c6cc36e153baeddc873b6c69698dcfa63161f0.tar.gz
opensim-SC_OLD-f9c6cc36e153baeddc873b6c69698dcfa63161f0.tar.bz2
opensim-SC_OLD-f9c6cc36e153baeddc873b6c69698dcfa63161f0.tar.xz
Update svn properties.
Diffstat (limited to 'OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs')
-rw-r--r--OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs1210
1 files changed, 605 insertions, 605 deletions
diff --git a/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs b/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs
index 4e579b6..e7e4caf 100644
--- a/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs
+++ b/OpenSim/Region/Environment/Scenes/SceneExternalChecks.cs
@@ -1,605 +1,605 @@
1/* 1/*
2 * Copyright (c) Contributors, http://opensimulator.org/ 2 * Copyright (c) Contributors, http://opensimulator.org/
3 * See CONTRIBUTORS.TXT for a full list of copyright holders. 3 * See CONTRIBUTORS.TXT for a full list of copyright holders.
4 * 4 *
5 * Redistribution and use in source and binary forms, with or without 5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met: 6 * modification, are permitted provided that the following conditions are met:
7 * * Redistributions of source code must retain the above copyright 7 * * Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer. 8 * notice, this list of conditions and the following disclaimer.
9 * * Redistributions in binary form must reproduce the above copyright 9 * * Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the 10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution. 11 * documentation and/or other materials provided with the distribution.
12 * * Neither the name of the OpenSim Project nor the 12 * * Neither the name of the OpenSim Project nor the
13 * names of its contributors may be used to endorse or promote products 13 * names of its contributors may be used to endorse or promote products
14 * derived from this software without specific prior written permission. 14 * derived from this software without specific prior written permission.
15 * 15 *
16 * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY 16 * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY 19 * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */ 26 */
27 27
28using System; 28using System;
29using System.Collections.Generic; 29using System.Collections.Generic;
30using System.Text; 30using System.Text;
31using libsecondlife; 31using libsecondlife;
32using OpenSim.Framework; 32using OpenSim.Framework;
33using OpenSim.Region.Environment.Interfaces; 33using OpenSim.Region.Environment.Interfaces;
34 34
35namespace OpenSim.Region.Environment.Scenes 35namespace OpenSim.Region.Environment.Scenes
36{ 36{
37 public class SceneExternalChecks 37 public class SceneExternalChecks
38 { 38 {
39 private Scene m_scene; 39 private Scene m_scene;
40 40
41 public SceneExternalChecks(Scene scene) 41 public SceneExternalChecks(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 #region REZ OBJECT 48 #region REZ OBJECT
49 public delegate bool CanRezObject(int objectCount, LLUUID owner, LLVector3 objectPosition, Scene scene); 49 public delegate bool CanRezObject(int objectCount, LLUUID owner, LLVector3 objectPosition, Scene scene);
50 private List<CanRezObject> CanRezObjectCheckFunctions = new List<CanRezObject>(); 50 private List<CanRezObject> CanRezObjectCheckFunctions = new List<CanRezObject>();
51 51
52 public void addCheckRezObject(CanRezObject delegateFunc) 52 public void addCheckRezObject(CanRezObject delegateFunc)
53 { 53 {
54 if(!CanRezObjectCheckFunctions.Contains(delegateFunc)) 54 if(!CanRezObjectCheckFunctions.Contains(delegateFunc))
55 CanRezObjectCheckFunctions.Add(delegateFunc); 55 CanRezObjectCheckFunctions.Add(delegateFunc);
56 } 56 }
57 public void removeCheckRezObject(CanRezObject delegateFunc) 57 public void removeCheckRezObject(CanRezObject delegateFunc)
58 { 58 {
59 if (CanRezObjectCheckFunctions.Contains(delegateFunc)) 59 if (CanRezObjectCheckFunctions.Contains(delegateFunc))
60 CanRezObjectCheckFunctions.Remove(delegateFunc); 60 CanRezObjectCheckFunctions.Remove(delegateFunc);
61 } 61 }
62 62
63 public bool ExternalChecksCanRezObject(int objectCount, LLUUID owner, LLVector3 objectPosition) 63 public bool ExternalChecksCanRezObject(int objectCount, LLUUID owner, LLVector3 objectPosition)
64 { 64 {
65 foreach (CanRezObject check in CanRezObjectCheckFunctions) 65 foreach (CanRezObject check in CanRezObjectCheckFunctions)
66 { 66 {
67 if (check(objectCount, owner,objectPosition, m_scene) == false) 67 if (check(objectCount, owner,objectPosition, m_scene) == false)
68 { 68 {
69 return false; 69 return false;
70 } 70 }
71 } 71 }
72 return true; 72 return true;
73 } 73 }
74 74
75 #endregion 75 #endregion
76 76
77 #region DEREZ OBJECT 77 #region DEREZ OBJECT
78 public delegate bool CanDeRezObject(LLUUID objectID, LLUUID deleter, Scene scene); 78 public delegate bool CanDeRezObject(LLUUID objectID, LLUUID deleter, Scene scene);
79 private List<CanDeRezObject> CanDeRezObjectCheckFunctions = new List<CanDeRezObject>(); 79 private List<CanDeRezObject> CanDeRezObjectCheckFunctions = new List<CanDeRezObject>();
80 80
81 public void addCheckDeRezObject(CanDeRezObject delegateFunc) 81 public void addCheckDeRezObject(CanDeRezObject delegateFunc)
82 { 82 {
83 if (!CanDeRezObjectCheckFunctions.Contains(delegateFunc)) 83 if (!CanDeRezObjectCheckFunctions.Contains(delegateFunc))
84 CanDeRezObjectCheckFunctions.Add(delegateFunc); 84 CanDeRezObjectCheckFunctions.Add(delegateFunc);
85 } 85 }
86 public void removeCheckDeRezObject(CanDeRezObject delegateFunc) 86 public void removeCheckDeRezObject(CanDeRezObject delegateFunc)
87 { 87 {
88 if (CanDeRezObjectCheckFunctions.Contains(delegateFunc)) 88 if (CanDeRezObjectCheckFunctions.Contains(delegateFunc))
89 CanDeRezObjectCheckFunctions.Remove(delegateFunc); 89 CanDeRezObjectCheckFunctions.Remove(delegateFunc);
90 } 90 }
91 91
92 public bool ExternalChecksCanDeRezObject(LLUUID objectID, LLUUID deleter) 92 public bool ExternalChecksCanDeRezObject(LLUUID objectID, LLUUID deleter)
93 { 93 {
94 foreach (CanDeRezObject check in CanDeRezObjectCheckFunctions) 94 foreach (CanDeRezObject check in CanDeRezObjectCheckFunctions)
95 { 95 {
96 if (check(objectID,deleter,m_scene) == false) 96 if (check(objectID,deleter,m_scene) == false)
97 { 97 {
98 return false; 98 return false;
99 } 99 }
100 } 100 }
101 return true; 101 return true;
102 } 102 }
103 103
104 #endregion 104 #endregion
105 105
106 #region TAKE OBJECT 106 #region TAKE OBJECT
107 public delegate bool CanTakeObject(LLUUID objectID, LLUUID stealer, Scene scene); 107 public delegate bool CanTakeObject(LLUUID objectID, LLUUID stealer, Scene scene);
108 private List<CanTakeObject> CanTakeObjectCheckFunctions = new List<CanTakeObject>(); 108 private List<CanTakeObject> CanTakeObjectCheckFunctions = new List<CanTakeObject>();
109 109
110 public void addCheckTakeObject(CanTakeObject delegateFunc) 110 public void addCheckTakeObject(CanTakeObject delegateFunc)
111 { 111 {
112 if (!CanTakeObjectCheckFunctions.Contains(delegateFunc)) 112 if (!CanTakeObjectCheckFunctions.Contains(delegateFunc))
113 CanTakeObjectCheckFunctions.Add(delegateFunc); 113 CanTakeObjectCheckFunctions.Add(delegateFunc);
114 } 114 }
115 public void removeCheckTakeObject(CanTakeObject delegateFunc) 115 public void removeCheckTakeObject(CanTakeObject delegateFunc)
116 { 116 {
117 if (CanTakeObjectCheckFunctions.Contains(delegateFunc)) 117 if (CanTakeObjectCheckFunctions.Contains(delegateFunc))
118 CanTakeObjectCheckFunctions.Remove(delegateFunc); 118 CanTakeObjectCheckFunctions.Remove(delegateFunc);
119 } 119 }
120 120
121 public bool ExternalChecksCanTakeObject(LLUUID objectID, LLUUID stealer) 121 public bool ExternalChecksCanTakeObject(LLUUID objectID, LLUUID stealer)
122 { 122 {
123 foreach (CanTakeObject check in CanTakeObjectCheckFunctions) 123 foreach (CanTakeObject check in CanTakeObjectCheckFunctions)
124 { 124 {
125 if (check(objectID, stealer, m_scene) == false) 125 if (check(objectID, stealer, m_scene) == false)
126 { 126 {
127 return false; 127 return false;
128 } 128 }
129 } 129 }
130 return true; 130 return true;
131 } 131 }
132 132
133 #endregion 133 #endregion
134 134
135 #region COPY OBJECT 135 #region COPY OBJECT
136 public delegate bool CanCopyObject(int objectCount, LLUUID objectID, LLUUID owner, Scene scene, LLVector3 objectPosition); 136 public delegate bool CanCopyObject(int objectCount, LLUUID objectID, LLUUID owner, Scene scene, LLVector3 objectPosition);
137 private List<CanCopyObject> CanCopyObjectCheckFunctions = new List<CanCopyObject>(); 137 private List<CanCopyObject> CanCopyObjectCheckFunctions = new List<CanCopyObject>();
138 138
139 public void addCheckCopyObject(CanCopyObject delegateFunc) 139 public void addCheckCopyObject(CanCopyObject delegateFunc)
140 { 140 {
141 if (!CanCopyObjectCheckFunctions.Contains(delegateFunc)) 141 if (!CanCopyObjectCheckFunctions.Contains(delegateFunc))
142 CanCopyObjectCheckFunctions.Add(delegateFunc); 142 CanCopyObjectCheckFunctions.Add(delegateFunc);
143 } 143 }
144 public void removeCheckCopyObject(CanCopyObject delegateFunc) 144 public void removeCheckCopyObject(CanCopyObject delegateFunc)
145 { 145 {
146 if (CanCopyObjectCheckFunctions.Contains(delegateFunc)) 146 if (CanCopyObjectCheckFunctions.Contains(delegateFunc))
147 CanCopyObjectCheckFunctions.Remove(delegateFunc); 147 CanCopyObjectCheckFunctions.Remove(delegateFunc);
148 } 148 }
149 149
150 public bool ExternalChecksCanCopyObject(int objectCount, LLUUID objectID, LLUUID owner, LLVector3 objectPosition) 150 public bool ExternalChecksCanCopyObject(int objectCount, LLUUID objectID, LLUUID owner, LLVector3 objectPosition)
151 { 151 {
152 foreach (CanCopyObject check in CanCopyObjectCheckFunctions) 152 foreach (CanCopyObject check in CanCopyObjectCheckFunctions)
153 { 153 {
154 if (check(objectCount, objectID, owner, m_scene, objectPosition) == false) 154 if (check(objectCount, objectID, owner, m_scene, objectPosition) == false)
155 { 155 {
156 return false; 156 return false;
157 } 157 }
158 } 158 }
159 return true; 159 return true;
160 } 160 }
161 161
162 #endregion 162 #endregion
163 163
164 #region EDIT OBJECT 164 #region EDIT OBJECT
165 public delegate bool CanEditObject(LLUUID objectID, LLUUID editorID, Scene scene); 165 public delegate bool CanEditObject(LLUUID objectID, LLUUID editorID, Scene scene);
166 private List<CanEditObject> CanEditObjectCheckFunctions = new List<CanEditObject>(); 166 private List<CanEditObject> CanEditObjectCheckFunctions = new List<CanEditObject>();
167 167
168 public void addCheckEditObject(CanEditObject delegateFunc) 168 public void addCheckEditObject(CanEditObject delegateFunc)
169 { 169 {
170 if (!CanEditObjectCheckFunctions.Contains(delegateFunc)) 170 if (!CanEditObjectCheckFunctions.Contains(delegateFunc))
171 CanEditObjectCheckFunctions.Add(delegateFunc); 171 CanEditObjectCheckFunctions.Add(delegateFunc);
172 } 172 }
173 public void removeCheckEditObject(CanEditObject delegateFunc) 173 public void removeCheckEditObject(CanEditObject delegateFunc)
174 { 174 {
175 if (CanEditObjectCheckFunctions.Contains(delegateFunc)) 175 if (CanEditObjectCheckFunctions.Contains(delegateFunc))
176 CanEditObjectCheckFunctions.Remove(delegateFunc); 176 CanEditObjectCheckFunctions.Remove(delegateFunc);
177 } 177 }
178 178
179 public bool ExternalChecksCanEditObject(LLUUID objectID, LLUUID editorID) 179 public bool ExternalChecksCanEditObject(LLUUID objectID, LLUUID editorID)
180 { 180 {
181 foreach (CanEditObject check in CanEditObjectCheckFunctions) 181 foreach (CanEditObject check in CanEditObjectCheckFunctions)
182 { 182 {
183 if (check(objectID, editorID, m_scene) == false) 183 if (check(objectID, editorID, m_scene) == false)
184 { 184 {
185 return false; 185 return false;
186 } 186 }
187 } 187 }
188 return true; 188 return true;
189 } 189 }
190 190
191 #endregion 191 #endregion
192 192
193 #region MOVE OBJECT 193 #region MOVE OBJECT
194 public delegate bool CanMoveObject(LLUUID objectID, LLUUID moverID, Scene scene); 194 public delegate bool CanMoveObject(LLUUID objectID, LLUUID moverID, Scene scene);
195 private List<CanMoveObject> CanMoveObjectCheckFunctions = new List<CanMoveObject>(); 195 private List<CanMoveObject> CanMoveObjectCheckFunctions = new List<CanMoveObject>();
196 196
197 public void addCheckMoveObject(CanMoveObject delegateFunc) 197 public void addCheckMoveObject(CanMoveObject delegateFunc)
198 { 198 {
199 if (!CanMoveObjectCheckFunctions.Contains(delegateFunc)) 199 if (!CanMoveObjectCheckFunctions.Contains(delegateFunc))
200 CanMoveObjectCheckFunctions.Add(delegateFunc); 200 CanMoveObjectCheckFunctions.Add(delegateFunc);
201 } 201 }
202 public void removeCheckMoveObject(CanMoveObject delegateFunc) 202 public void removeCheckMoveObject(CanMoveObject delegateFunc)
203 { 203 {
204 if (CanMoveObjectCheckFunctions.Contains(delegateFunc)) 204 if (CanMoveObjectCheckFunctions.Contains(delegateFunc))
205 CanMoveObjectCheckFunctions.Remove(delegateFunc); 205 CanMoveObjectCheckFunctions.Remove(delegateFunc);
206 } 206 }
207 207
208 public bool ExternalChecksCanMoveObject(LLUUID objectID, LLUUID moverID) 208 public bool ExternalChecksCanMoveObject(LLUUID objectID, LLUUID moverID)
209 { 209 {
210 foreach (CanMoveObject check in CanMoveObjectCheckFunctions) 210 foreach (CanMoveObject check in CanMoveObjectCheckFunctions)
211 { 211 {
212 if (check(objectID,moverID,m_scene) == false) 212 if (check(objectID,moverID,m_scene) == false)
213 { 213 {
214 return false; 214 return false;
215 } 215 }
216 } 216 }
217 return true; 217 return true;
218 } 218 }
219 219
220 #endregion 220 #endregion
221 221
222 #region RETURN OBJECT 222 #region RETURN OBJECT
223 public delegate bool CanReturnObject(LLUUID objectID, LLUUID returnerID, Scene scene); 223 public delegate bool CanReturnObject(LLUUID objectID, LLUUID returnerID, Scene scene);
224 private List<CanReturnObject> CanReturnObjectCheckFunctions = new List<CanReturnObject>(); 224 private List<CanReturnObject> CanReturnObjectCheckFunctions = new List<CanReturnObject>();
225 225
226 public void addCheckReturnObject(CanReturnObject delegateFunc) 226 public void addCheckReturnObject(CanReturnObject delegateFunc)
227 { 227 {
228 if (!CanReturnObjectCheckFunctions.Contains(delegateFunc)) 228 if (!CanReturnObjectCheckFunctions.Contains(delegateFunc))
229 CanReturnObjectCheckFunctions.Add(delegateFunc); 229 CanReturnObjectCheckFunctions.Add(delegateFunc);
230 } 230 }
231 public void removeCheckReturnObject(CanReturnObject delegateFunc) 231 public void removeCheckReturnObject(CanReturnObject delegateFunc)
232 { 232 {
233 if (CanReturnObjectCheckFunctions.Contains(delegateFunc)) 233 if (CanReturnObjectCheckFunctions.Contains(delegateFunc))
234 CanReturnObjectCheckFunctions.Remove(delegateFunc); 234 CanReturnObjectCheckFunctions.Remove(delegateFunc);
235 } 235 }
236 236
237 public bool ExternalChecksCanReturnObject(LLUUID objectID, LLUUID returnerID) 237 public bool ExternalChecksCanReturnObject(LLUUID objectID, LLUUID returnerID)
238 { 238 {
239 foreach (CanReturnObject check in CanReturnObjectCheckFunctions) 239 foreach (CanReturnObject check in CanReturnObjectCheckFunctions)
240 { 240 {
241 if (check(objectID,returnerID,m_scene) == false) 241 if (check(objectID,returnerID,m_scene) == false)
242 { 242 {
243 return false; 243 return false;
244 } 244 }
245 } 245 }
246 return true; 246 return true;
247 } 247 }
248 248
249 #endregion 249 #endregion
250 250
251 #endregion 251 #endregion
252 252
253 #region Misc Permission Checks 253 #region Misc Permission Checks
254 254
255 #region INSTANT MESSAGE 255 #region INSTANT MESSAGE
256 public delegate bool CanInstantMessage(LLUUID user, LLUUID target, Scene startScene); 256 public delegate bool CanInstantMessage(LLUUID user, LLUUID target, Scene startScene);
257 private List<CanInstantMessage> CanInstantMessageCheckFunctions = new List<CanInstantMessage>(); 257 private List<CanInstantMessage> CanInstantMessageCheckFunctions = new List<CanInstantMessage>();
258 258
259 public void addCheckInstantMessage(CanInstantMessage delegateFunc) 259 public void addCheckInstantMessage(CanInstantMessage delegateFunc)
260 { 260 {
261 if (!CanInstantMessageCheckFunctions.Contains(delegateFunc)) 261 if (!CanInstantMessageCheckFunctions.Contains(delegateFunc))
262 CanInstantMessageCheckFunctions.Add(delegateFunc); 262 CanInstantMessageCheckFunctions.Add(delegateFunc);
263 } 263 }
264 public void removeCheckInstantMessage(CanInstantMessage delegateFunc) 264 public void removeCheckInstantMessage(CanInstantMessage delegateFunc)
265 { 265 {
266 if (CanInstantMessageCheckFunctions.Contains(delegateFunc)) 266 if (CanInstantMessageCheckFunctions.Contains(delegateFunc))
267 CanInstantMessageCheckFunctions.Remove(delegateFunc); 267 CanInstantMessageCheckFunctions.Remove(delegateFunc);
268 } 268 }
269 269
270 public bool ExternalChecksCanInstantMessage(LLUUID user, LLUUID target) 270 public bool ExternalChecksCanInstantMessage(LLUUID user, LLUUID target)
271 { 271 {
272 foreach (CanInstantMessage check in CanInstantMessageCheckFunctions) 272 foreach (CanInstantMessage check in CanInstantMessageCheckFunctions)
273 { 273 {
274 if (check(user,target,m_scene) == false) 274 if (check(user,target,m_scene) == false)
275 { 275 {
276 return false; 276 return false;
277 } 277 }
278 } 278 }
279 return true; 279 return true;
280 } 280 }
281 281
282 #endregion 282 #endregion
283 283
284 #region INVENTORY TRANSFER 284 #region INVENTORY TRANSFER
285 public delegate bool CanInventoryTransfer(LLUUID user, LLUUID target, Scene startScene); 285 public delegate bool CanInventoryTransfer(LLUUID user, LLUUID target, Scene startScene);
286 private List<CanInventoryTransfer> CanInventoryTransferCheckFunctions = new List<CanInventoryTransfer>(); 286 private List<CanInventoryTransfer> CanInventoryTransferCheckFunctions = new List<CanInventoryTransfer>();
287 287
288 public void addCheckInventoryTransfer(CanInventoryTransfer delegateFunc) 288 public void addCheckInventoryTransfer(CanInventoryTransfer delegateFunc)
289 { 289 {
290 if (!CanInventoryTransferCheckFunctions.Contains(delegateFunc)) 290 if (!CanInventoryTransferCheckFunctions.Contains(delegateFunc))
291 CanInventoryTransferCheckFunctions.Add(delegateFunc); 291 CanInventoryTransferCheckFunctions.Add(delegateFunc);
292 } 292 }
293 public void removeCheckInventoryTransfer(CanInventoryTransfer delegateFunc) 293 public void removeCheckInventoryTransfer(CanInventoryTransfer delegateFunc)
294 { 294 {
295 if (CanInventoryTransferCheckFunctions.Contains(delegateFunc)) 295 if (CanInventoryTransferCheckFunctions.Contains(delegateFunc))
296 CanInventoryTransferCheckFunctions.Remove(delegateFunc); 296 CanInventoryTransferCheckFunctions.Remove(delegateFunc);
297 } 297 }
298 298
299 public bool ExternalChecksCanInventoryTransfer(LLUUID user, LLUUID target) 299 public bool ExternalChecksCanInventoryTransfer(LLUUID user, LLUUID target)
300 { 300 {
301 foreach (CanInventoryTransfer check in CanInventoryTransferCheckFunctions) 301 foreach (CanInventoryTransfer check in CanInventoryTransferCheckFunctions)
302 { 302 {
303 if (check(user, target, m_scene) == false) 303 if (check(user, target, m_scene) == false)
304 { 304 {
305 return false; 305 return false;
306 } 306 }
307 } 307 }
308 return true; 308 return true;
309 } 309 }
310 310
311 #endregion 311 #endregion
312 312
313 #region EDIT SCRIPT 313 #region EDIT SCRIPT
314 public delegate bool CanEditScript(LLUUID script, LLUUID user, Scene scene); 314 public delegate bool CanEditScript(LLUUID script, LLUUID user, Scene scene);
315 private List<CanEditScript> CanEditScriptCheckFunctions = new List<CanEditScript>(); 315 private List<CanEditScript> CanEditScriptCheckFunctions = new List<CanEditScript>();
316 316
317 public void addCheckEditScript(CanEditScript delegateFunc) 317 public void addCheckEditScript(CanEditScript delegateFunc)
318 { 318 {
319 if (!CanEditScriptCheckFunctions.Contains(delegateFunc)) 319 if (!CanEditScriptCheckFunctions.Contains(delegateFunc))
320 CanEditScriptCheckFunctions.Add(delegateFunc); 320 CanEditScriptCheckFunctions.Add(delegateFunc);
321 } 321 }
322 public void removeCheckEditScript(CanEditScript delegateFunc) 322 public void removeCheckEditScript(CanEditScript delegateFunc)
323 { 323 {
324 if (CanEditScriptCheckFunctions.Contains(delegateFunc)) 324 if (CanEditScriptCheckFunctions.Contains(delegateFunc))
325 CanEditScriptCheckFunctions.Remove(delegateFunc); 325 CanEditScriptCheckFunctions.Remove(delegateFunc);
326 } 326 }
327 327
328 public bool ExternalChecksCanEditScript(LLUUID script, LLUUID user) 328 public bool ExternalChecksCanEditScript(LLUUID script, LLUUID user)
329 { 329 {
330 foreach (CanEditScript check in CanEditScriptCheckFunctions) 330 foreach (CanEditScript check in CanEditScriptCheckFunctions)
331 { 331 {
332 if (check(script, user, m_scene) == false) 332 if (check(script, user, m_scene) == false)
333 { 333 {
334 return false; 334 return false;
335 } 335 }
336 } 336 }
337 return true; 337 return true;
338 } 338 }
339 339
340 #endregion 340 #endregion
341 341
342 #region RUN SCRIPT 342 #region RUN SCRIPT
343 public delegate bool CanRunScript(LLUUID script, LLUUID user, Scene scene); 343 public delegate bool CanRunScript(LLUUID script, LLUUID user, Scene scene);
344 private List<CanRunScript> CanRunScriptCheckFunctions = new List<CanRunScript>(); 344 private List<CanRunScript> CanRunScriptCheckFunctions = new List<CanRunScript>();
345 345
346 public void addCheckRunScript(CanRunScript delegateFunc) 346 public void addCheckRunScript(CanRunScript delegateFunc)
347 { 347 {
348 if (!CanRunScriptCheckFunctions.Contains(delegateFunc)) 348 if (!CanRunScriptCheckFunctions.Contains(delegateFunc))
349 CanRunScriptCheckFunctions.Add(delegateFunc); 349 CanRunScriptCheckFunctions.Add(delegateFunc);
350 } 350 }
351 public void removeCheckRunScript(CanRunScript delegateFunc) 351 public void removeCheckRunScript(CanRunScript delegateFunc)
352 { 352 {
353 if (CanRunScriptCheckFunctions.Contains(delegateFunc)) 353 if (CanRunScriptCheckFunctions.Contains(delegateFunc))
354 CanRunScriptCheckFunctions.Remove(delegateFunc); 354 CanRunScriptCheckFunctions.Remove(delegateFunc);
355 } 355 }
356 356
357 public bool ExternalChecksCanRunScript(LLUUID script, LLUUID user) 357 public bool ExternalChecksCanRunScript(LLUUID script, LLUUID user)
358 { 358 {
359 foreach (CanRunScript check in CanRunScriptCheckFunctions) 359 foreach (CanRunScript check in CanRunScriptCheckFunctions)
360 { 360 {
361 if (check(script, user, m_scene) == false) 361 if (check(script, user, m_scene) == false)
362 { 362 {
363 return false; 363 return false;
364 } 364 }
365 } 365 }
366 return true; 366 return true;
367 } 367 }
368 368
369 #endregion 369 #endregion
370 370
371 #region TERRAFORM LAND 371 #region TERRAFORM LAND
372 public delegate bool CanTerraformLandCommand(LLUUID user, LLVector3 position, Scene requestFromScene); 372 public delegate bool CanTerraformLandCommand(LLUUID user, LLVector3 position, Scene requestFromScene);
373 private List<CanTerraformLandCommand> CanTerraformLandCommandCheckFunctions = new List<CanTerraformLandCommand>(); 373 private List<CanTerraformLandCommand> CanTerraformLandCommandCheckFunctions = new List<CanTerraformLandCommand>();
374 374
375 public void addCheckTerraformLandCommand(CanTerraformLandCommand delegateFunc) 375 public void addCheckTerraformLandCommand(CanTerraformLandCommand delegateFunc)
376 { 376 {
377 if (!CanTerraformLandCommandCheckFunctions.Contains(delegateFunc)) 377 if (!CanTerraformLandCommandCheckFunctions.Contains(delegateFunc))
378 CanTerraformLandCommandCheckFunctions.Add(delegateFunc); 378 CanTerraformLandCommandCheckFunctions.Add(delegateFunc);
379 } 379 }
380 public void removeCheckTerraformLandCommand(CanTerraformLandCommand delegateFunc) 380 public void removeCheckTerraformLandCommand(CanTerraformLandCommand delegateFunc)
381 { 381 {
382 if (CanTerraformLandCommandCheckFunctions.Contains(delegateFunc)) 382 if (CanTerraformLandCommandCheckFunctions.Contains(delegateFunc))
383 CanTerraformLandCommandCheckFunctions.Remove(delegateFunc); 383 CanTerraformLandCommandCheckFunctions.Remove(delegateFunc);
384 } 384 }
385 385
386 public bool ExternalChecksCanTerraformLand(LLUUID user, LLVector3 pos) 386 public bool ExternalChecksCanTerraformLand(LLUUID user, LLVector3 pos)
387 { 387 {
388 foreach (CanTerraformLandCommand check in CanTerraformLandCommandCheckFunctions) 388 foreach (CanTerraformLandCommand check in CanTerraformLandCommandCheckFunctions)
389 { 389 {
390 if (check(user, pos, m_scene) == false) 390 if (check(user, pos, m_scene) == false)
391 { 391 {
392 return false; 392 return false;
393 } 393 }
394 } 394 }
395 return true; 395 return true;
396 } 396 }
397 397
398 #endregion 398 #endregion
399 399
400 #region RUN CONSOLE COMMAND 400 #region RUN CONSOLE COMMAND
401 public delegate bool CanRunConsoleCommand(LLUUID user, Scene requestFromScene); 401 public delegate bool CanRunConsoleCommand(LLUUID user, Scene requestFromScene);
402 private List<CanRunConsoleCommand> CanRunConsoleCommandCheckFunctions = new List<CanRunConsoleCommand>(); 402 private List<CanRunConsoleCommand> CanRunConsoleCommandCheckFunctions = new List<CanRunConsoleCommand>();
403 403
404 public void addCheckRunConsoleCommand(CanRunConsoleCommand delegateFunc) 404 public void addCheckRunConsoleCommand(CanRunConsoleCommand delegateFunc)
405 { 405 {
406 if (!CanRunConsoleCommandCheckFunctions.Contains(delegateFunc)) 406 if (!CanRunConsoleCommandCheckFunctions.Contains(delegateFunc))
407 CanRunConsoleCommandCheckFunctions.Add(delegateFunc); 407 CanRunConsoleCommandCheckFunctions.Add(delegateFunc);
408 } 408 }
409 public void removeCheckRunConsoleCommand(CanRunConsoleCommand delegateFunc) 409 public void removeCheckRunConsoleCommand(CanRunConsoleCommand delegateFunc)
410 { 410 {
411 if (CanRunConsoleCommandCheckFunctions.Contains(delegateFunc)) 411 if (CanRunConsoleCommandCheckFunctions.Contains(delegateFunc))
412 CanRunConsoleCommandCheckFunctions.Remove(delegateFunc); 412 CanRunConsoleCommandCheckFunctions.Remove(delegateFunc);
413 } 413 }
414 414
415 public bool ExternalChecksCanRunConsoleCommand(LLUUID user) 415 public bool ExternalChecksCanRunConsoleCommand(LLUUID user)
416 { 416 {
417 foreach (CanRunConsoleCommand check in CanRunConsoleCommandCheckFunctions) 417 foreach (CanRunConsoleCommand check in CanRunConsoleCommandCheckFunctions)
418 { 418 {
419 if (check(user, m_scene) == false) 419 if (check(user, m_scene) == false)
420 { 420 {
421 return false; 421 return false;
422 } 422 }
423 } 423 }
424 return true; 424 return true;
425 } 425 }
426 426
427 #endregion 427 #endregion
428 428
429 #region CAN BE GODLIKE 429 #region CAN BE GODLIKE
430 public delegate bool CanBeGodLike(LLUUID user, Scene requestFromScene); 430 public delegate bool CanBeGodLike(LLUUID user, Scene requestFromScene);
431 private List<CanBeGodLike> CanBeGodLikeCheckFunctions = new List<CanBeGodLike>(); 431 private List<CanBeGodLike> CanBeGodLikeCheckFunctions = new List<CanBeGodLike>();
432 432
433 public void addCheckBeGodLike(CanBeGodLike delegateFunc) 433 public void addCheckBeGodLike(CanBeGodLike delegateFunc)
434 { 434 {
435 if (!CanBeGodLikeCheckFunctions.Contains(delegateFunc)) 435 if (!CanBeGodLikeCheckFunctions.Contains(delegateFunc))
436 CanBeGodLikeCheckFunctions.Add(delegateFunc); 436 CanBeGodLikeCheckFunctions.Add(delegateFunc);
437 } 437 }
438 public void removeCheckBeGodLike(CanBeGodLike delegateFunc) 438 public void removeCheckBeGodLike(CanBeGodLike delegateFunc)
439 { 439 {
440 if (CanBeGodLikeCheckFunctions.Contains(delegateFunc)) 440 if (CanBeGodLikeCheckFunctions.Contains(delegateFunc))
441 CanBeGodLikeCheckFunctions.Remove(delegateFunc); 441 CanBeGodLikeCheckFunctions.Remove(delegateFunc);
442 } 442 }
443 443
444 public bool ExternalChecksCanBeGodLike(LLUUID user) 444 public bool ExternalChecksCanBeGodLike(LLUUID user)
445 { 445 {
446 foreach (CanBeGodLike check in CanBeGodLikeCheckFunctions) 446 foreach (CanBeGodLike check in CanBeGodLikeCheckFunctions)
447 { 447 {
448 if (check(user, m_scene) == false) 448 if (check(user, m_scene) == false)
449 { 449 {
450 return false; 450 return false;
451 } 451 }
452 } 452 }
453 return true; 453 return true;
454 } 454 }
455 455
456 #endregion 456 #endregion
457 457
458 #endregion 458 #endregion
459 459
460 #region Parcel and Estate Permission Checks 460 #region Parcel and Estate Permission Checks
461 #region EDIT ESTATE TERRAIN 461 #region EDIT ESTATE TERRAIN
462 public delegate bool CanEditEstateTerrain(LLUUID user, Scene scene); 462 public delegate bool CanEditEstateTerrain(LLUUID user, Scene scene);
463 private List<CanEditEstateTerrain> CanEditEstateTerrainCheckFunctions = new List<CanEditEstateTerrain>(); 463 private List<CanEditEstateTerrain> CanEditEstateTerrainCheckFunctions = new List<CanEditEstateTerrain>();
464 464
465 public void addCheckEditEstateTerrain(CanEditEstateTerrain delegateFunc) 465 public void addCheckEditEstateTerrain(CanEditEstateTerrain delegateFunc)
466 { 466 {
467 if (!CanEditEstateTerrainCheckFunctions.Contains(delegateFunc)) 467 if (!CanEditEstateTerrainCheckFunctions.Contains(delegateFunc))
468 CanEditEstateTerrainCheckFunctions.Add(delegateFunc); 468 CanEditEstateTerrainCheckFunctions.Add(delegateFunc);
469 } 469 }
470 public void removeCheckEditEstateTerrain(CanEditEstateTerrain delegateFunc) 470 public void removeCheckEditEstateTerrain(CanEditEstateTerrain delegateFunc)
471 { 471 {
472 if (CanEditEstateTerrainCheckFunctions.Contains(delegateFunc)) 472 if (CanEditEstateTerrainCheckFunctions.Contains(delegateFunc))
473 CanEditEstateTerrainCheckFunctions.Remove(delegateFunc); 473 CanEditEstateTerrainCheckFunctions.Remove(delegateFunc);
474 } 474 }
475 475
476 public bool ExternalChecksCanEditEstateTerrain(LLUUID user) 476 public bool ExternalChecksCanEditEstateTerrain(LLUUID user)
477 { 477 {
478 foreach (CanEditEstateTerrain check in CanEditEstateTerrainCheckFunctions) 478 foreach (CanEditEstateTerrain check in CanEditEstateTerrainCheckFunctions)
479 { 479 {
480 if (check(user, m_scene) == false) 480 if (check(user, m_scene) == false)
481 { 481 {
482 return false; 482 return false;
483 } 483 }
484 } 484 }
485 return true; 485 return true;
486 } 486 }
487 487
488 #endregion 488 #endregion
489 489
490 #region RESTART SIM 490 #region RESTART SIM
491 public delegate bool CanRestartSim(LLUUID user, Scene scene); 491 public delegate bool CanRestartSim(LLUUID user, Scene scene);
492 private List<CanRestartSim> CanRestartSimCheckFunctions = new List<CanRestartSim>(); 492 private List<CanRestartSim> CanRestartSimCheckFunctions = new List<CanRestartSim>();
493 493
494 public void addCheckRestartSim(CanRestartSim delegateFunc) 494 public void addCheckRestartSim(CanRestartSim delegateFunc)
495 { 495 {
496 if (!CanRestartSimCheckFunctions.Contains(delegateFunc)) 496 if (!CanRestartSimCheckFunctions.Contains(delegateFunc))
497 CanRestartSimCheckFunctions.Add(delegateFunc); 497 CanRestartSimCheckFunctions.Add(delegateFunc);
498 } 498 }
499 public void removeCheckRestartSim(CanRestartSim delegateFunc) 499 public void removeCheckRestartSim(CanRestartSim delegateFunc)
500 { 500 {
501 if (CanRestartSimCheckFunctions.Contains(delegateFunc)) 501 if (CanRestartSimCheckFunctions.Contains(delegateFunc))
502 CanRestartSimCheckFunctions.Remove(delegateFunc); 502 CanRestartSimCheckFunctions.Remove(delegateFunc);
503 } 503 }
504 504
505 public bool ExternalChecksCanRestartSim(LLUUID user) 505 public bool ExternalChecksCanRestartSim(LLUUID user)
506 { 506 {
507 foreach (CanRestartSim check in CanRestartSimCheckFunctions) 507 foreach (CanRestartSim check in CanRestartSimCheckFunctions)
508 { 508 {
509 if (check(user, m_scene) == false) 509 if (check(user, m_scene) == false)
510 { 510 {
511 return false; 511 return false;
512 } 512 }
513 } 513 }
514 return true; 514 return true;
515 } 515 }
516 #endregion 516 #endregion
517 517
518 #region EDIT PARCEL 518 #region EDIT PARCEL
519 public delegate bool CanEditParcel(LLUUID user, ILandObject parcel, Scene scene); 519 public delegate bool CanEditParcel(LLUUID user, ILandObject parcel, Scene scene);
520 private List<CanEditParcel> CanEditParcelCheckFunctions = new List<CanEditParcel>(); 520 private List<CanEditParcel> CanEditParcelCheckFunctions = new List<CanEditParcel>();
521 521
522 public void addCheckEditParcel(CanEditParcel delegateFunc) 522 public void addCheckEditParcel(CanEditParcel delegateFunc)
523 { 523 {
524 if (!CanEditParcelCheckFunctions.Contains(delegateFunc)) 524 if (!CanEditParcelCheckFunctions.Contains(delegateFunc))
525 CanEditParcelCheckFunctions.Add(delegateFunc); 525 CanEditParcelCheckFunctions.Add(delegateFunc);
526 } 526 }
527 public void removeCheckEditParcel(CanEditParcel delegateFunc) 527 public void removeCheckEditParcel(CanEditParcel delegateFunc)
528 { 528 {
529 if (CanEditParcelCheckFunctions.Contains(delegateFunc)) 529 if (CanEditParcelCheckFunctions.Contains(delegateFunc))
530 CanEditParcelCheckFunctions.Remove(delegateFunc); 530 CanEditParcelCheckFunctions.Remove(delegateFunc);
531 } 531 }
532 532
533 public bool ExternalChecksCanEditParcel(LLUUID user, ILandObject parcel) 533 public bool ExternalChecksCanEditParcel(LLUUID user, ILandObject parcel)
534 { 534 {
535 foreach (CanEditParcel check in CanEditParcelCheckFunctions) 535 foreach (CanEditParcel check in CanEditParcelCheckFunctions)
536 { 536 {
537 if (check(user, parcel, m_scene) == false) 537 if (check(user, parcel, m_scene) == false)
538 { 538 {
539 return false; 539 return false;
540 } 540 }
541 } 541 }
542 return true; 542 return true;
543 } 543 }
544 #endregion 544 #endregion
545 545
546 #region SELL PARCEL 546 #region SELL PARCEL
547 public delegate bool CanSellParcel(LLUUID user, ILandObject parcel, Scene scene); 547 public delegate bool CanSellParcel(LLUUID user, ILandObject parcel, Scene scene);
548 private List<CanSellParcel> CanSellParcelCheckFunctions = new List<CanSellParcel>(); 548 private List<CanSellParcel> CanSellParcelCheckFunctions = new List<CanSellParcel>();
549 549
550 public void addCheckSellParcel(CanSellParcel delegateFunc) 550 public void addCheckSellParcel(CanSellParcel delegateFunc)
551 { 551 {
552 if (!CanSellParcelCheckFunctions.Contains(delegateFunc)) 552 if (!CanSellParcelCheckFunctions.Contains(delegateFunc))
553 CanSellParcelCheckFunctions.Add(delegateFunc); 553 CanSellParcelCheckFunctions.Add(delegateFunc);
554 } 554 }
555 public void removeCheckSellParcel(CanSellParcel delegateFunc) 555 public void removeCheckSellParcel(CanSellParcel delegateFunc)
556 { 556 {
557 if (CanSellParcelCheckFunctions.Contains(delegateFunc)) 557 if (CanSellParcelCheckFunctions.Contains(delegateFunc))
558 CanSellParcelCheckFunctions.Remove(delegateFunc); 558 CanSellParcelCheckFunctions.Remove(delegateFunc);
559 } 559 }
560 560
561 public bool ExternalChecksCanSellParcel(LLUUID user, ILandObject parcel) 561 public bool ExternalChecksCanSellParcel(LLUUID user, ILandObject parcel)
562 { 562 {
563 foreach (CanSellParcel check in CanSellParcelCheckFunctions) 563 foreach (CanSellParcel check in CanSellParcelCheckFunctions)
564 { 564 {
565 if (check(user, parcel, m_scene) == false) 565 if (check(user, parcel, m_scene) == false)
566 { 566 {
567 return false; 567 return false;
568 } 568 }
569 } 569 }
570 return true; 570 return true;
571 } 571 }
572 #endregion 572 #endregion
573 573
574 #region ABANDON PARCEL 574 #region ABANDON PARCEL
575 public delegate bool CanAbandonParcel(LLUUID user, ILandObject parcel, Scene scene); 575 public delegate bool CanAbandonParcel(LLUUID user, ILandObject parcel, Scene scene);
576 private List<CanAbandonParcel> CanAbandonParcelCheckFunctions = new List<CanAbandonParcel>(); 576 private List<CanAbandonParcel> CanAbandonParcelCheckFunctions = new List<CanAbandonParcel>();
577 577
578 public void addCheckAbandonParcel(CanAbandonParcel delegateFunc) 578 public void addCheckAbandonParcel(CanAbandonParcel delegateFunc)
579 { 579 {
580 if (!CanAbandonParcelCheckFunctions.Contains(delegateFunc)) 580 if (!CanAbandonParcelCheckFunctions.Contains(delegateFunc))
581 CanAbandonParcelCheckFunctions.Add(delegateFunc); 581 CanAbandonParcelCheckFunctions.Add(delegateFunc);
582 } 582 }
583 public void removeCheckAbandonParcel(CanAbandonParcel delegateFunc) 583 public void removeCheckAbandonParcel(CanAbandonParcel delegateFunc)
584 { 584 {
585 if (CanAbandonParcelCheckFunctions.Contains(delegateFunc)) 585 if (CanAbandonParcelCheckFunctions.Contains(delegateFunc))
586 CanAbandonParcelCheckFunctions.Remove(delegateFunc); 586 CanAbandonParcelCheckFunctions.Remove(delegateFunc);
587 } 587 }
588 588
589 public bool ExternalChecksCanAbandonParcel(LLUUID user, ILandObject parcel) 589 public bool ExternalChecksCanAbandonParcel(LLUUID user, ILandObject parcel)
590 { 590 {
591 foreach (CanAbandonParcel check in CanAbandonParcelCheckFunctions) 591 foreach (CanAbandonParcel check in CanAbandonParcelCheckFunctions)
592 { 592 {
593 if (check(user, parcel, m_scene) == false) 593 if (check(user, parcel, m_scene) == false)
594 { 594 {
595 return false; 595 return false;
596 } 596 }
597 } 597 }
598 return true; 598 return true;
599 } 599 }
600 #endregion 600 #endregion
601 #endregion 601 #endregion
602 602
603 603
604 } 604 }
605} 605}
generated by cgit v1.1 at 2024-11-10 16:34:40 +0000