949 lines
28 KiB
C#
949 lines
28 KiB
C#
// <copyright file="gpl-2.0.txt">
|
|
// ORIGINAL CODE BASE IS Copyright (C) 2006-2010 by Alphons van der Heijden.
|
|
// The code was donated on 2010-04-28 by Alphons van der Heijden to Brandon 'Dimentox Travanti' Husbands &
|
|
// Malcolm J. Kudra, who in turn License under the GPLv2 in agreement with Alphons van der Heijden's wishes.
|
|
//
|
|
// The community would like to thank Alphons for all of his hard work, blood sweat and tears. Without his work
|
|
// the community would be stuck with crappy editors.
|
|
//
|
|
// The source code in this file ("Source Code") is provided by The LSLEditor Group to you under the terms of the GNU
|
|
// General Public License, version 2.0 ("GPL"), unless you have obtained a separate licensing agreement ("Other
|
|
// License"), formally executed by you and The LSLEditor Group.
|
|
// Terms of the GPL can be found in the gplv2.txt document.
|
|
//
|
|
// GPLv2 Header
|
|
// ************
|
|
// LSLEditor, a External editor for the LSL Language.
|
|
// Copyright (C) 2010 The LSLEditor Group.
|
|
//
|
|
// This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public
|
|
// License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any
|
|
// later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
|
|
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
|
|
// details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License along with this program; if not, write to the Free
|
|
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
// ********************************************************************************************************************
|
|
// The above copyright notice and this permission notice shall be included in copies or substantial portions of the
|
|
// Software.
|
|
// ********************************************************************************************************************
|
|
// </copyright>
|
|
//
|
|
// <summary>
|
|
// SecondLifeHost.cs
|
|
//
|
|
// </summary>
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Reflection;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
|
|
using System.Windows.Forms;
|
|
|
|
using LSLEditor.Helpers;
|
|
|
|
namespace LSLEditor
|
|
{
|
|
public class SecondLifeHostEventArgs : EventArgs
|
|
{
|
|
public string Message;
|
|
public SecondLifeHostEventArgs(string Message)
|
|
{
|
|
this.Message = Message;
|
|
}
|
|
}
|
|
|
|
public class SecondLifeHostMessageLinkedEventArgs : EventArgs
|
|
{
|
|
public SecondLife.integer iLinkIndex;
|
|
public SecondLife.integer iNumber;
|
|
public SecondLife.String sText;
|
|
public SecondLife.key kID;
|
|
|
|
public SecondLifeHostMessageLinkedEventArgs(SecondLife.integer iLinkIndex, SecondLife.integer iNumber, SecondLife.String sText, SecondLife.key kID)
|
|
{
|
|
this.iLinkIndex = iLinkIndex;
|
|
this.iNumber = iNumber;
|
|
this.sText = sText;
|
|
this.kID = kID;
|
|
}
|
|
}
|
|
|
|
public class SecondLifeHostChatEventArgs : EventArgs
|
|
{
|
|
public SecondLife.integer channel;
|
|
public SecondLife.String name;
|
|
public SecondLife.key id;
|
|
public SecondLife.String message;
|
|
public CommunicationType how;
|
|
|
|
public SecondLifeHostChatEventArgs(SecondLife.integer channel, SecondLife.String name, SecondLife.key id, SecondLife.String message, CommunicationType how)
|
|
{
|
|
this.channel = channel;
|
|
this.name = name;
|
|
this.id = id;
|
|
this.message = message;
|
|
this.how = how;
|
|
}
|
|
}
|
|
|
|
public class SecondLifeHost : IDisposable
|
|
{
|
|
private List<ListenFilter> ListenFilterList;
|
|
|
|
private List<Link> LinkList;
|
|
|
|
private SecondLife secondLife;
|
|
private TaskQueue taskQueue;
|
|
private AutoResetEvent StateChanged;
|
|
private Thread StateWatcher;
|
|
|
|
private LSLEditorForm mainForm;
|
|
private Assembly CompiledAssembly;
|
|
|
|
public string FullPath;
|
|
public Guid guid;
|
|
|
|
public delegate void SecondLifeHostMessageHandler(object sender, SecondLifeHostEventArgs e);
|
|
public event SecondLifeHostMessageHandler OnVerboseMessage;
|
|
public event SecondLifeHostMessageHandler OnStateChange;
|
|
|
|
public delegate void SecondLifeHostChatHandler(object sender, SecondLifeHostChatEventArgs e);
|
|
public event SecondLifeHostChatHandler OnChat;
|
|
|
|
public delegate void SecondLifeHostMessageLinkedHandler(object sender, SecondLifeHostMessageLinkedEventArgs e);
|
|
public event SecondLifeHostMessageLinkedHandler OnMessageLinked;
|
|
|
|
public event EventHandler OnDie;
|
|
public event EventHandler OnReset;
|
|
|
|
public event EventHandler OnListenChannelsChanged;
|
|
|
|
public System.Timers.Timer timer;
|
|
|
|
public System.Timers.Timer sensor_timer;
|
|
|
|
public string CurrentStateName;
|
|
private string NewStateName;
|
|
|
|
private string ObjectName;
|
|
private string ObjectDescription;
|
|
|
|
public SecondLifeHost(LSLEditorForm mainForm, Assembly CompiledAssembly, string FullPath, Guid guid)
|
|
{
|
|
this.ListenFilterList = null;
|
|
this.LinkList = null;
|
|
this.secondLife = null;
|
|
this.taskQueue = new TaskQueue();
|
|
this.StateChanged = new AutoResetEvent(false);
|
|
this.StateWatcher = new Thread(new ThreadStart(StateWatch));
|
|
this.StateWatcher.Name = "StateWatch";
|
|
this.StateWatcher.IsBackground = true;
|
|
this.StateWatcher.Start();
|
|
|
|
this.mainForm = mainForm;
|
|
this.CompiledAssembly = CompiledAssembly;
|
|
this.FullPath = FullPath;
|
|
this.guid = guid;
|
|
|
|
this.ObjectName = Path.GetFileNameWithoutExtension(this.FullPath);
|
|
this.ObjectDescription = "";
|
|
|
|
this.timer = new System.Timers.Timer();
|
|
this.timer.AutoReset = true;
|
|
this.timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
|
|
|
|
this.sensor_timer = new System.Timers.Timer();
|
|
this.sensor_timer.AutoReset = true;
|
|
this.sensor_timer.Elapsed += new System.Timers.ElapsedEventHandler(sensor_timer_Elapsed);
|
|
|
|
this.NewStateName = "default";
|
|
this.CurrentStateName = "";
|
|
}
|
|
|
|
private void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
|
|
{
|
|
ExecuteSecondLife("timer");
|
|
}
|
|
|
|
private void StateWatch()
|
|
{
|
|
while (true) {
|
|
this.StateChanged.WaitOne();
|
|
this.taskQueue.Start(); // is implicit Stop() old Queue
|
|
if (this.CurrentStateName != this.NewStateName) {
|
|
this.CurrentStateName = this.NewStateName;
|
|
ExecuteSecondLife("state_exit");
|
|
|
|
// Changing to CurrentStateName on this thread! (not ExecuteSecondLife)
|
|
this.taskQueue.Invoke(this, "SetState");
|
|
}
|
|
}
|
|
}
|
|
|
|
public void State(string strStateName, bool blnForce)
|
|
{
|
|
if (this.CompiledAssembly != null) {
|
|
if (blnForce) {
|
|
this.CurrentStateName = "";
|
|
}
|
|
this.NewStateName = strStateName;
|
|
this.StateChanged.Set();
|
|
}
|
|
}
|
|
|
|
private void SetState()
|
|
{
|
|
if (CompiledAssembly != null) {
|
|
secondLife = CompiledAssembly.CreateInstance("LSLEditor.State_" + CurrentStateName) as SecondLife;
|
|
|
|
if (secondLife == null) {
|
|
MessageBox.Show("State " + CurrentStateName + " does not exist!");
|
|
return;
|
|
}
|
|
|
|
ListenFilterList = new List<ListenFilter>();
|
|
|
|
LinkList = new List<Link>();
|
|
|
|
// Make friends
|
|
secondLife.host = this;
|
|
|
|
// Update runtime userinterface by calling event handler
|
|
if (OnStateChange != null) {
|
|
OnStateChange(this, new SecondLifeHostEventArgs(CurrentStateName));
|
|
}
|
|
|
|
ExecuteSecondLife("state_entry");
|
|
}
|
|
}
|
|
|
|
public string GetArgumentsFromMethod(string strName)
|
|
{
|
|
string strArgs = "";
|
|
if (this.secondLife != null) {
|
|
MethodInfo mi = secondLife.GetType().GetMethod(strName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
|
|
if (mi != null) {
|
|
int intI = 0;
|
|
foreach (ParameterInfo pi in mi.GetParameters()) {
|
|
if (intI > 0)
|
|
strArgs += ",";
|
|
strArgs += pi.ParameterType.ToString() + " " + pi.Name;
|
|
intI++;
|
|
}
|
|
}
|
|
}
|
|
return strArgs;
|
|
}
|
|
|
|
public void VerboseEvent(string strEventName, object[] args)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append("*** ");
|
|
sb.Append(strEventName);
|
|
sb.Append('(');
|
|
for (int intI = 0; intI < args.Length; intI++) {
|
|
if (intI > 0) sb.Append(',');
|
|
sb.Append(args[intI].ToString());
|
|
}
|
|
sb.Append(")");
|
|
VerboseMessage(sb.ToString());
|
|
}
|
|
|
|
public void ExecuteSecondLife(string strName, params object[] args)
|
|
{
|
|
if (secondLife != null) {
|
|
VerboseEvent(strName, args);
|
|
|
|
this.taskQueue.Invoke(secondLife, strName, args);
|
|
}
|
|
}
|
|
|
|
public ArrayList GetEvents()
|
|
{
|
|
ArrayList ar = new ArrayList();
|
|
if (secondLife != null) {
|
|
foreach (MethodInfo mi in secondLife.GetType().GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)) {
|
|
ar.Add(mi.Name);
|
|
}
|
|
}
|
|
ar.Sort();
|
|
return ar;
|
|
}
|
|
|
|
public void Reset()
|
|
{
|
|
if (OnReset != null) {
|
|
OnReset(this, new EventArgs());
|
|
}
|
|
}
|
|
|
|
public void Die()
|
|
{
|
|
if (OnDie != null) {
|
|
OnDie(this, new EventArgs());
|
|
}
|
|
|
|
if (secondLife != null) {
|
|
// stop all timers
|
|
this.timer.Stop();
|
|
this.sensor_timer.Stop();
|
|
|
|
this.taskQueue.Stop();
|
|
this.taskQueue.Dispose();
|
|
this.taskQueue = null;
|
|
|
|
this.secondLife = null;
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (taskQueue != null) {
|
|
this.taskQueue.Stop();
|
|
this.taskQueue.Dispose();
|
|
this.taskQueue = null;
|
|
}
|
|
if (listXmlRpc != null) {
|
|
foreach (XMLRPC xmlRpc in listXmlRpc) {
|
|
xmlRpc.CloseChannel();
|
|
}
|
|
}
|
|
if (secondLife != null) {
|
|
this.timer.Stop();
|
|
this.sensor_timer.Stop();
|
|
this.mainForm = null;
|
|
this.secondLife = null;
|
|
}
|
|
}
|
|
|
|
|
|
#region Link functions
|
|
private struct Link
|
|
{
|
|
public int number;
|
|
public string name;
|
|
public SecondLife.key id;
|
|
public SecondLife.key target;
|
|
public Link(int number, string name, SecondLife.key id, SecondLife.key target)
|
|
{
|
|
this.number = number;
|
|
this.name = name;
|
|
this.id = id;
|
|
this.target = target;
|
|
}
|
|
}
|
|
|
|
public void llBreakAllLinks()
|
|
{
|
|
LinkList = new List<Link>();
|
|
}
|
|
|
|
public void llBreakLink(int linknum)
|
|
{
|
|
foreach (Link link in this.LinkList) {
|
|
if (link.number == linknum) {
|
|
this.LinkList.Remove(link);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Listen functions
|
|
|
|
public string[] GetListenChannels() // for GroupboxEvent
|
|
{
|
|
List<string> list = new List<string>();
|
|
foreach (ListenFilter lf in ListenFilterList) {
|
|
list.Add(lf.channel.ToString());
|
|
}
|
|
return list.ToArray();
|
|
}
|
|
|
|
private struct ListenFilter
|
|
{
|
|
public int channel;
|
|
public string name;
|
|
public SecondLife.key id;
|
|
public string message;
|
|
public bool active;
|
|
public ListenFilter(int channel, string name, SecondLife.key id, string message)
|
|
{
|
|
this.channel = channel;
|
|
this.name = name;
|
|
this.id = id;
|
|
this.message = message;
|
|
this.active = true;
|
|
}
|
|
}
|
|
|
|
public void llListenControl(int number, int active)
|
|
{
|
|
for (int intI = 0; intI < ListenFilterList.Count; intI++) {
|
|
ListenFilter lf = ListenFilterList[intI];
|
|
if (lf.GetHashCode() == number) {
|
|
lf.active = (active == 1);
|
|
ListenFilterList[intI] = lf;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void llListenRemove(int intHandle)
|
|
{
|
|
for (int intI = 0; intI < ListenFilterList.Count; intI++) {
|
|
ListenFilter lf = ListenFilterList[intI];
|
|
if (lf.GetHashCode() == intHandle) {
|
|
ListenFilterList.RemoveAt(intI);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public int llListen(int channel, string name, SecondLife.key id, string message)
|
|
{
|
|
if (ListenFilterList.Count >= 64) {
|
|
Chat(this, 0, "LSLEditor", SecondLife.NULL_KEY, "Maximum of 64 listens!!!", CommunicationType.Shout);
|
|
return 0;
|
|
}
|
|
ListenFilter lf = new ListenFilter(channel, name, id, message);
|
|
ListenFilterList.Add(lf);
|
|
if (OnListenChannelsChanged != null) {
|
|
OnListenChannelsChanged(this, null);
|
|
}
|
|
return lf.GetHashCode();
|
|
}
|
|
|
|
private bool CheckListenFilter(int channel, string name, SecondLife.key id, string message)
|
|
{
|
|
ListenFilter lfToCheck = new ListenFilter(channel, name, id, message);
|
|
|
|
foreach (ListenFilter lf in ListenFilterList) {
|
|
if (!lf.active) continue;
|
|
if (lf.channel != lfToCheck.channel) continue;
|
|
if (lf.name != "" && lf.name != lfToCheck.name) continue;
|
|
if (lf.id != Guid.Empty.ToString() && lf.id != "" && lf.id != lfToCheck.id) continue;
|
|
if (lf.message != "" && lf.message != lfToCheck.message) continue;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// sink listen
|
|
public void Listen(SecondLifeHostChatEventArgs e)
|
|
{
|
|
if (secondLife != null) {
|
|
if (CheckListenFilter(e.channel, e.name, e.id, e.message)) {
|
|
ExecuteSecondLife("listen", e.channel, e.name, e.id, e.message);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
// raise
|
|
public void Chat(object sender, int channel, string name, SecondLife.key id, string message, CommunicationType how)
|
|
{
|
|
if (OnChat != null) {
|
|
OnChat(sender, new SecondLifeHostChatEventArgs(channel, name, id, message, how));
|
|
}
|
|
}
|
|
|
|
// raise
|
|
public void MessageLinked(SecondLife.integer iLlinkIndex, SecondLife.integer iNumber, SecondLife.String sText, SecondLife.key kID)
|
|
{
|
|
if (OnMessageLinked != null) {
|
|
OnMessageLinked(this, new SecondLifeHostMessageLinkedEventArgs(iLlinkIndex, iNumber, sText, kID));
|
|
}
|
|
}
|
|
|
|
// sink
|
|
public void LinkMessage(SecondLifeHostMessageLinkedEventArgs e)
|
|
{
|
|
ExecuteSecondLife("link_message", e.iLinkIndex, e.iNumber, e.sText, e.kID);
|
|
}
|
|
|
|
|
|
public SecondLife.key Http(string Url, SecondLife.list Parameters, string Body)
|
|
{
|
|
SecondLife.key Key = SecondLife.NULL_KEY;
|
|
if (secondLife != null) {
|
|
System.Net.WebProxy proxy = null;
|
|
if (Properties.Settings.Default.ProxyServer != "") {
|
|
proxy = new System.Net.WebProxy(Properties.Settings.Default.ProxyServer.Replace("http://", ""));
|
|
}
|
|
|
|
if (Properties.Settings.Default.ProxyUserid != "" && proxy != null) {
|
|
proxy.Credentials = new System.Net.NetworkCredential(Properties.Settings.Default.ProxyUserid, Properties.Settings.Default.ProxyPassword);
|
|
}
|
|
|
|
Key = new SecondLife.key(Guid.NewGuid());
|
|
//WebRequestClass a = new WebRequestClass(proxy, secondLife, Url, Parameters, Body, Key);
|
|
try {
|
|
HTTPRequest.Request(proxy, secondLife, Url, Parameters, Body, Key);
|
|
} catch (Exception exception) {
|
|
VerboseMessage(exception.Message);
|
|
}
|
|
}
|
|
return Key;
|
|
}
|
|
|
|
public void Email(string To, string Subject, string Body)
|
|
{
|
|
if (secondLife != null) {
|
|
SmtpClient client = new SmtpClient();
|
|
client.SmtpServer = Properties.Settings.Default.EmailServer;
|
|
|
|
string strName = GetObjectName();
|
|
string strObjectName = string.Format("Object-Name: {0}", strName);
|
|
|
|
SecondLife.vector RegionCorner = secondLife.llGetRegionCorner();
|
|
string strRegionName = secondLife.llGetRegionName();
|
|
string strRegion = string.Format("Region: {0} ({1},{2})", strRegionName, RegionCorner.x, RegionCorner.y);
|
|
|
|
SecondLife.vector pos = secondLife.llGetPos();
|
|
string strPosition = string.Format("Local-Position: ({0},{1},{2})", (int)pos.x, (int)pos.y, (int)pos.z);
|
|
|
|
string strPrefix = strObjectName + "\r\n";
|
|
strPrefix += strRegion + "\r\n";
|
|
strPrefix += strPosition + "\r\n\r\n";
|
|
|
|
MailMessage msg = new MailMessage();
|
|
msg.To = To;
|
|
msg.Subject = Subject;
|
|
msg.Body = strPrefix + Body;
|
|
msg.From = Properties.Settings.Default.EmailAddress;
|
|
msg.Headers.Add("Reply-to", msg.From);
|
|
|
|
//MailAttachment myAttachment = new MailAttachment(strAttachmentFile);
|
|
//msg.Attachments.Add(myAttachment);
|
|
|
|
VerboseMessage(client.Send(msg));
|
|
}
|
|
}
|
|
|
|
public void VerboseMessage(string Message)
|
|
{
|
|
if (OnVerboseMessage != null) {
|
|
OnVerboseMessage(this, new SecondLifeHostEventArgs(Message));
|
|
}
|
|
}
|
|
|
|
delegate void ShowDialogDelegate(SecondLifeHost host,
|
|
SecondLife.String objectName,
|
|
SecondLife.key k,
|
|
SecondLife.String name,
|
|
SecondLife.String message,
|
|
SecondLife.list buttons,
|
|
SecondLife.integer channel);
|
|
private void Dialog(SecondLifeHost host,
|
|
SecondLife.String objectName,
|
|
SecondLife.key k,
|
|
SecondLife.String name,
|
|
SecondLife.String message,
|
|
SecondLife.list buttons,
|
|
SecondLife.integer channel)
|
|
{
|
|
llDialogForm DialogForm = new llDialogForm(host, objectName, k, name, message, buttons, channel);
|
|
DialogForm.Left = this.mainForm.Right - DialogForm.Width - 5;
|
|
DialogForm.Top = this.mainForm.Top + 30;
|
|
DialogForm.Show(this.mainForm);
|
|
this.mainForm.llDialogForms.Add(DialogForm);
|
|
}
|
|
|
|
public void llDialog(SecondLife.key avatar, SecondLife.String message, SecondLife.list buttons, SecondLife.integer channel)
|
|
{
|
|
if (message.ToString().Length >= 512) {
|
|
VerboseMessage("llDialog: message too long, must be less than 512 characters");
|
|
return;
|
|
}
|
|
if (message.ToString().Length == 0) {
|
|
VerboseMessage("llDialog: must supply a message");
|
|
return;
|
|
}
|
|
for (int intI = 0; intI < buttons.Count; intI++) {
|
|
if (buttons[intI].ToString() == "") {
|
|
VerboseMessage("llDialog: all buttons must have label strings");
|
|
return;
|
|
}
|
|
if (buttons[intI].ToString().Length > 24) {
|
|
VerboseMessage("llDialog:Button Labels can not have more than 24 characters");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (buttons.Count == 0) {
|
|
buttons = new SecondLife.list(new string[] { "OK" });
|
|
}
|
|
|
|
this.mainForm.Invoke(new ShowDialogDelegate(Dialog), this, (SecondLife.String)GetObjectName(), secondLife.llGetOwner(), (SecondLife.String)Properties.Settings.Default.AvatarName, message, buttons, channel);
|
|
}
|
|
delegate void ShowTextBoxDelegate(SecondLifeHost host,
|
|
SecondLife.String objectName,
|
|
SecondLife.key k,
|
|
SecondLife.String name,
|
|
SecondLife.String message,
|
|
SecondLife.integer channel);
|
|
private void TextBox(SecondLifeHost host,
|
|
SecondLife.String objectName,
|
|
SecondLife.key k,
|
|
SecondLife.String name,
|
|
SecondLife.String message,
|
|
SecondLife.integer channel)
|
|
{
|
|
llTextBoxForm TextBoxForm = new llTextBoxForm(host, objectName, k, name, message, channel);
|
|
TextBoxForm.Left = this.mainForm.Left + this.mainForm.Width / 2 - TextBoxForm.Width / 2;
|
|
TextBoxForm.Top = this.mainForm.Top + this.mainForm.Height / 2 - TextBoxForm.Height / 2;
|
|
TextBoxForm.Show(this.mainForm);
|
|
this.mainForm.llTextBoxForms.Add(TextBoxForm);
|
|
}
|
|
public void llTextBox(SecondLife.key avatar, SecondLife.String message, SecondLife.integer channel)
|
|
{
|
|
if (message.ToString().Length >= 512) {
|
|
VerboseMessage("llTextBox: message too long, must be less than 512 characters");
|
|
return;
|
|
}
|
|
if (message.ToString().Length == 0) {
|
|
VerboseMessage("llTextBos: must supply a message");
|
|
return;
|
|
}
|
|
this.mainForm.Invoke(new ShowTextBoxDelegate(TextBox), this, (SecondLife.String)GetObjectName(), secondLife.llGetOwner(), (SecondLife.String)Properties.Settings.Default.AvatarName, message, channel);
|
|
}
|
|
|
|
public void SetPermissions(SecondLife.integer intPermissions)
|
|
{
|
|
ExecuteSecondLife("run_time_permissions", intPermissions);
|
|
}
|
|
|
|
delegate void RequestPermissionsDelegate(
|
|
SecondLifeHost host,
|
|
SecondLife.String objectName,
|
|
SecondLife.key k,
|
|
SecondLife.String name,
|
|
SecondLife.key agent,
|
|
SecondLife.integer intPermissions);
|
|
private void RequestPermissions(
|
|
SecondLifeHost host,
|
|
SecondLife.String objectName,
|
|
SecondLife.key k,
|
|
SecondLife.String name,
|
|
SecondLife.key agent,
|
|
SecondLife.integer intPermissions)
|
|
{
|
|
PermissionsForm PermissionForm = new PermissionsForm(this, GetObjectName(), secondLife.llGetOwner(), Properties.Settings.Default.AvatarName, agent, intPermissions);
|
|
PermissionForm.Left = this.mainForm.Right - PermissionForm.Width - 5;
|
|
PermissionForm.Top = this.mainForm.Top + 30;
|
|
PermissionForm.Show(this.mainForm);
|
|
this.mainForm.PermissionForms.Add(PermissionForm);
|
|
}
|
|
|
|
public void llRequestPermissions(SecondLife.key agent, SecondLife.integer intPermissions)
|
|
{
|
|
this.mainForm.Invoke(new RequestPermissionsDelegate(RequestPermissions),
|
|
this,
|
|
(SecondLife.String)GetObjectName(),
|
|
secondLife.llGetOwner(),
|
|
(SecondLife.String)Properties.Settings.Default.AvatarName,
|
|
agent,
|
|
intPermissions);
|
|
}
|
|
|
|
private int m_intControls = -1;
|
|
|
|
public void SendControl(Keys keys)
|
|
{
|
|
if (m_intControls >= 0 || this.secondLife != null) {
|
|
// check againt m_intControls TODO!!!!!
|
|
int held = 0;
|
|
int change = 0;
|
|
|
|
if ((keys & Keys.Up) == Keys.Up)
|
|
held |= SecondLife.CONTROL_UP;
|
|
if ((keys & Keys.Down) == Keys.Down)
|
|
held |= SecondLife.CONTROL_DOWN;
|
|
if ((keys & Keys.Left) == Keys.Left)
|
|
held |= SecondLife.CONTROL_LEFT;
|
|
if ((keys & Keys.Right) == Keys.Right)
|
|
held |= SecondLife.CONTROL_RIGHT;
|
|
|
|
ExecuteSecondLife("control", (SecondLife.key)Properties.Settings.Default.AvatarKey, (SecondLife.integer)held, (SecondLife.integer)change);
|
|
}
|
|
}
|
|
|
|
public void TakeControls(int intControls, int accept, int pass_on)
|
|
{
|
|
this.m_intControls = intControls;
|
|
}
|
|
|
|
public void ReleaseControls()
|
|
{
|
|
this.m_intControls = -1;
|
|
}
|
|
|
|
#region Notecards
|
|
private void GetNotecardLineWorker(SecondLife.key k, string strPath, int line)
|
|
{
|
|
StreamReader sr = new StreamReader(strPath);
|
|
int intI = 0;
|
|
string strData = SecondLife.EOF;
|
|
while (!sr.EndOfStream) {
|
|
string strLine = sr.ReadLine();
|
|
if (intI == line) {
|
|
strData = strLine;
|
|
break;
|
|
}
|
|
intI++;
|
|
}
|
|
sr.Close();
|
|
ExecuteSecondLife("dataserver", k, (SecondLife.String)strData);
|
|
}
|
|
|
|
public SecondLife.key GetNotecardLine(string name, int line)
|
|
{
|
|
string strPath = mainForm.SolutionExplorer.GetPath(this.guid, name);
|
|
if (strPath == string.Empty) {
|
|
strPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), name);
|
|
}
|
|
if (!File.Exists(strPath)) {
|
|
VerboseMessage("Notecard: " + strPath + " not found");
|
|
taskQueue.Invoke(secondLife, "llSay", (SecondLife.integer)0, (SecondLife.String)("Couldn't find notecard " + name));
|
|
return SecondLife.NULL_KEY;
|
|
}
|
|
SecondLife.key k = new SecondLife.key(Guid.NewGuid());
|
|
taskQueue.Invoke(this, "GetNotecardLineWorker", k, strPath, line);
|
|
return k;
|
|
}
|
|
|
|
|
|
private void GetNumberOfNotecardLinesWorker(SecondLife.key k, string strPath)
|
|
{
|
|
StreamReader sr = new StreamReader(strPath);
|
|
int intI = 0;
|
|
while (!sr.EndOfStream) {
|
|
string strLine = sr.ReadLine();
|
|
intI++;
|
|
}
|
|
sr.Close();
|
|
ExecuteSecondLife("dataserver", k, (SecondLife.String)intI.ToString());
|
|
}
|
|
|
|
|
|
public SecondLife.key GetNumberOfNotecardLines(string name)
|
|
{
|
|
string strPath = mainForm.SolutionExplorer.GetPath(this.guid, name);
|
|
if (strPath == string.Empty) {
|
|
strPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), name);
|
|
}
|
|
|
|
if (!File.Exists(strPath)) {
|
|
VerboseMessage("Notecard: " + strPath + " not found");
|
|
taskQueue.Invoke(secondLife, "llSay", (SecondLife.integer)0, (SecondLife.String)("Couldn't find notecard " + name));
|
|
return SecondLife.NULL_KEY;
|
|
}
|
|
SecondLife.key k = new SecondLife.key(Guid.NewGuid());
|
|
taskQueue.Invoke(this, "GetNumberOfNotecardLinesWorker", k, strPath);
|
|
return k;
|
|
}
|
|
#endregion
|
|
|
|
#region XML-RPC
|
|
|
|
private List<XMLRPC> listXmlRpc;
|
|
public void llOpenRemoteDataChannel()
|
|
{
|
|
if (listXmlRpc == null) {
|
|
listXmlRpc = new List<XMLRPC>();
|
|
}
|
|
XMLRPC xmlRpc = new XMLRPC();
|
|
xmlRpc.OnRequest += new XMLRPC.RequestEventHandler(xmlRpc_OnRequest);
|
|
xmlRpc.OpenChannel(listXmlRpc.Count);
|
|
listXmlRpc.Add(xmlRpc);
|
|
ExecuteSecondLife("remote_data",
|
|
SecondLife.REMOTE_DATA_CHANNEL,
|
|
xmlRpc.guid,
|
|
new SecondLife.key(Guid.NewGuid()),
|
|
(SecondLife.String)("LSLEditor"),
|
|
(SecondLife.integer)(0),
|
|
(SecondLife.String)("Listening on " + xmlRpc.Prefix));
|
|
}
|
|
|
|
void xmlRpc_OnRequest(object sender, XmlRpcRequestEventArgs e)
|
|
{
|
|
XMLRPC xmlRpc = sender as XMLRPC;
|
|
|
|
ExecuteSecondLife("remote_data",
|
|
SecondLife.REMOTE_DATA_REQUEST,
|
|
e.channel,
|
|
e.message_id,
|
|
e.sender,
|
|
e.iData,
|
|
e.sData);
|
|
}
|
|
|
|
public void llCloseRemoteDataChannel(SecondLife.key channel)
|
|
{
|
|
if (listXmlRpc != null) {
|
|
foreach (XMLRPC xmlRpc in listXmlRpc) {
|
|
if (xmlRpc.guid == channel.guid) {
|
|
xmlRpc.CloseChannel();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public void llRemoteDataReply(SecondLife.key channel, SecondLife.key message_id, string sdata, int idata)
|
|
{
|
|
if (listXmlRpc != null) {
|
|
foreach (XMLRPC xmlRpc in listXmlRpc) {
|
|
if (xmlRpc.guid == channel.guid) {
|
|
xmlRpc.RemoteDataReply(channel.guid, message_id.guid, sdata, idata);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Wiki sais this is not working in InWorld
|
|
public SecondLife.key llSendRemoteData(SecondLife.key channel, string dest, int idata, string sdata)
|
|
{
|
|
XMLRPC xmlRpc = new XMLRPC();
|
|
xmlRpc.OnReply += new XMLRPC.RequestEventHandler(xmlRpc_OnReply);
|
|
SecondLife.key message_id = xmlRpc.SendRemoteData(channel, dest, idata, sdata);
|
|
return message_id;
|
|
}
|
|
|
|
// Wiki sais currently disabled
|
|
void xmlRpc_OnReply(object sender, XmlRpcRequestEventArgs e)
|
|
{
|
|
ExecuteSecondLife("remote_data",
|
|
SecondLife.REMOTE_DATA_REPLY,
|
|
e.channel,
|
|
e.message_id,
|
|
(SecondLife.String)"", // Wiki
|
|
e.iData,
|
|
e.sData);
|
|
}
|
|
#endregion
|
|
|
|
public string GetObjectName(Guid guid)
|
|
{
|
|
string strObjectName = mainForm.SolutionExplorer.GetObjectName(guid);
|
|
return strObjectName != string.Empty ? strObjectName : this.ObjectName;
|
|
}
|
|
|
|
public string GetObjectName()
|
|
{
|
|
return GetObjectName(this.guid);
|
|
}
|
|
|
|
public void SetObjectName(string name)
|
|
{
|
|
if (!mainForm.SolutionExplorer.SetObjectName(this.guid, name)) {
|
|
ObjectName = name;
|
|
}
|
|
}
|
|
|
|
public string GetObjectDescription(Guid guid)
|
|
{
|
|
string strObjectDescription = mainForm.SolutionExplorer.GetObjectDescription(guid);
|
|
if (strObjectDescription != string.Empty) {
|
|
return strObjectDescription;
|
|
} else {
|
|
return this.ObjectDescription;
|
|
}
|
|
}
|
|
|
|
public string GetObjectDescription()
|
|
{
|
|
return GetObjectDescription(this.guid);
|
|
}
|
|
|
|
public void SetObjectDescription(string description)
|
|
{
|
|
if (!mainForm.SolutionExplorer.SetObjectDescription(this.guid, description)) {
|
|
this.ObjectDescription = description;
|
|
}
|
|
}
|
|
|
|
public string GetScriptName()
|
|
{
|
|
string strScriptName = mainForm.SolutionExplorer.GetScriptName(this.guid);
|
|
if (strScriptName == string.Empty) {
|
|
strScriptName = this.FullPath;
|
|
}
|
|
if (Properties.Settings.Default.llGetScriptName) {
|
|
strScriptName = Path.GetFileNameWithoutExtension(strScriptName);
|
|
} else {
|
|
strScriptName = Path.GetFileName(strScriptName);
|
|
}
|
|
return strScriptName;
|
|
}
|
|
|
|
public SecondLife.key GetKey()
|
|
{
|
|
string strGuid = mainForm.SolutionExplorer.GetKey(this.guid);
|
|
if (strGuid == string.Empty) {
|
|
return new SecondLife.key(this.guid);
|
|
}
|
|
return new SecondLife.key(strGuid);
|
|
}
|
|
|
|
public SecondLife.String GetInventoryName(SecondLife.integer type, SecondLife.integer number)
|
|
{
|
|
string strInventoryName = mainForm.SolutionExplorer.GetInventoryName(this.guid, type, number);
|
|
if (strInventoryName == string.Empty) {
|
|
return "**GetInventoryName only works in SolutionExplorer**";
|
|
}
|
|
return strInventoryName;
|
|
}
|
|
|
|
public SecondLife.key GetInventoryKey(SecondLife.String name)
|
|
{
|
|
string strInventoryKey = mainForm.SolutionExplorer.GetInventoryKey(this.guid, name);
|
|
if (strInventoryKey == string.Empty) {
|
|
return new SecondLife.key(Guid.Empty);
|
|
}
|
|
return new SecondLife.key(strInventoryKey);
|
|
}
|
|
|
|
public SecondLife.integer GetInventoryNumber(SecondLife.integer type)
|
|
{
|
|
return mainForm.SolutionExplorer.GetInventoryNumber(this.guid, type);
|
|
}
|
|
|
|
public SecondLife.integer GetInventoryType(SecondLife.String name)
|
|
{
|
|
return mainForm.SolutionExplorer.GetInventoryType(this.guid, name);
|
|
}
|
|
|
|
public void RemoveInventory(SecondLife.String name)
|
|
{
|
|
mainForm.SolutionExplorer.RemoveInventory(this.guid, name);
|
|
}
|
|
|
|
public System.Media.SoundPlayer GetSoundPlayer(string sound)
|
|
{
|
|
string strPath = mainForm.SolutionExplorer.GetPath(this.guid, sound);
|
|
if (strPath == string.Empty) {
|
|
strPath = sound;
|
|
}
|
|
return new System.Media.SoundPlayer(strPath);
|
|
}
|
|
|
|
private void sensor_timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
|
|
{
|
|
SecondLife.integer total_number = 1;
|
|
ExecuteSecondLife("sensor", total_number);
|
|
}
|
|
|
|
}
|
|
}
|