public static Canvas LoadGUI(string a_filename, IFileSystem a_fileSystem, Pipeline a_pipeline)
{
if (a_fileSystem != null)
{
Stream stream;
if (a_fileSystem.Load(a_filename, out stream))
{
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(stream);
Canvas canv = Load(xmlDocument, a_fileSystem, a_pipeline);
if (canv != null)
{
canv.m_fileSystem = a_fileSystem;
}
return(canv);
}
else
{
InternalConsole.Error("Cannot access canvas file");
}
}
else
{
InternalConsole.Error("No filesystem to load from for canvas");
}
return(null);
}
bool WriteFrame(Frame a_frame)
{
if (!m_internalClient.IsConnected)
{
InternalConsole.AddMessage("Failed to write to disconnected stream");
}
try
{
m_internalClient.WriteToStream(a_frame.ToBytes());
return(true);
}
catch (IOException e)
{
InternalConsole.Error(string.Format("Discord Client: Failed to write frame: IOException: {0}", e.Message));
}
catch (ObjectDisposedException)
{
InternalConsole.Error("Discord Client: Failed to write frame: Disposed");
}
catch (InvalidOperationException)
{
InternalConsole.Error("Discord Client: Invalid Operaion when writing frame");
}
return(false);
}
void Error(IntPtr a_errorStr)
{
string str = Marshal.PtrToStringAnsi(a_errorStr);
if (!string.IsNullOrEmpty(str))
{
InternalConsole.Error(str);
}
}
void ProcessCommandQueue()
{
if (m_state != e_RPCState.Connected)
{
return;
}
bool write = m_commandQueue.Count > 0;
ICommand command = null;
while (write && m_internalClient.IsConnected)
{
command = m_commandQueue.Peek();
if (command is CloseCommand)
{
m_state = e_RPCState.Disconnected;
if (!WriteFrame(new Frame(Frame.e_OpCode.Close, new Handshake()
{
Version = m_version, ClientID = m_clientID
})))
{
InternalConsole.Error("Discord Client: Handwave Failed");
}
return;
}
else
{
IPayload payload = command.PreparePayload(m_nounce++);
Frame frame = new Frame();
if (!m_shutdown)
{
frame.OpCode = Frame.e_OpCode.Frame;
frame.SetObject(payload);
WriteFrame(frame);
}
}
m_commandQueue.Dequeue();
write = m_commandQueue.Count > 0;
}
}
void ProcessEvent(EventPayload a_event)
{
if (a_event.Event.HasValue && a_event.Event == EventPayload.e_ServerEvent.Error)
{
ErrorMessage error = a_event.GetObject <ErrorMessage>();
InternalConsole.Error(string.Format("Discord responded with error: ({0}) {1}", error.ErrorCode, error.Message));
EnqueueMessage(error);
}
if (m_state == e_RPCState.Connecting)
{
if (a_event.Command == e_Command.Dispatch && a_event.Event.HasValue && a_event.Event.Value == EventPayload.e_ServerEvent.Ready)
{
m_state = e_RPCState.Connected;
ReadyMessage ready = a_event.GetObject <ReadyMessage>();
m_config = ready.Configuration;
User user = ready.User;
user.Configuration = ready.Configuration;
ready.User = user;
m_user = user;
EnqueueMessage(ready);
return;
}
}
// TODO: Implement Connected Commands
if (m_state == e_RPCState.Connected)
{
switch (a_event.Command)
{
case e_Command.Dispatch:
{
break;
}
}
}
}
void EndRead(IAsyncResult a_callback)
{
int bytes = -1;
try
{
bytes = m_stream.EndRead(a_callback);
}
catch (IOException)
{
InternalConsole.Error("Discord Client: Attempted to read from closed pipe");
return;
}
catch (ObjectDisposedException)
{
InternalConsole.Error("Discord Client: Attempted to end reading from a disposed pipe");
return;
}
catch (NullReferenceException)
{
InternalConsole.Error("Discord Client: Attempted to connect to null pipe");
return;
}
if (bytes > 0)
{
Frame frame = Frame.FromBytes(m_buffer);
if (frame != null)
{
Client.EnqueueFrame(frame);
}
}
if (m_stream.IsConnected)
{
BeginRead();
}
}
public override bool AttemptConnection(string a_pipe)
{
m_socket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified);
m_socket.Blocking = false;
UnixEndPoint endPoint = new UnixEndPoint(string.Format("{0}/{1}", m_envPath, a_pipe));
try
{
m_socket.Connect(endPoint);
}
catch (Exception e)
{
InternalConsole.Error(string.Format("Failed to connect to {0}: {1}", a_pipe, e.Message));
return(false);
}
return(true);
}
public override bool AttemptConnection(string a_pipe)
{
try
{
m_stream = new NamedPipeClientStream(".", a_pipe, PipeDirection.InOut, PipeOptions.Asynchronous);
m_stream.Connect(1000);
do
{
Thread.Sleep(10);
}while (!m_stream.IsConnected);
InternalConsole.AddMessage(string.Format("Connected: {0}", a_pipe));
return(true);
}
catch (Exception e)
{
InternalConsole.Error(string.Format("Failed to connect to {0}: {1}", a_pipe, e.Message));
}
return(false);
}
public override void BeginRead()
{
if (!m_stream.IsConnected)
{
return;
}
try
{
m_stream.BeginRead(m_buffer, 0, m_buffer.Length, EndRead, m_stream.IsConnected);
}
catch (ObjectDisposedException)
{
InternalConsole.Error("Discord Client: Attempted to read from disposed stream");
return;
}
catch (InvalidOperationException)
{
InternalConsole.Error("Discord Client: Attempted to read from closed pipe");
return;
}
}
public override void BeginRead()
{
if (!m_socket.Connected)
{
return;
}
try
{
byte[] buffer = new byte[1024 * 16];
SocketAsyncEventArgs eventArgs = new SocketAsyncEventArgs();
eventArgs.SetBuffer(buffer, 0, buffer.Length);
eventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(EndRead);
m_socket.ReceiveAsync(eventArgs);
}
catch (Exception e)
{
InternalConsole.Error(string.Format("Discord Client: Reading socket: {0}", e.Message));
return;
}
}
void PopulateElements(XmlNode a_node, Element a_parent)
{
if (a_node.NodeType == XmlNodeType.Comment)
{
return;
}
Type type = Type.GetType(a_node.Name);
if (type == null)
{
type = Type.GetType("Erde.Graphics.GUI." + a_node.Name);
if (type == null)
{
InternalConsole.Error("Canvas: Invalid Element Type: " + a_node.Name);
return;
}
}
MethodInfo methodInfo = type.GetMethod("Create", BindingFlags.Static | BindingFlags.NonPublic);
Element element = methodInfo.Invoke(null, new object[] { a_node, m_fileSystem, m_pipeline }) as Element;
if (element != null)
{
foreach (XmlAttribute att in a_node.Attributes)
{
switch (att.Name.ToLower())
{
case "visible":
{
element.Visible = bool.Parse(att.Value);
break;
}
case "width":
{
Vector2 size = element.Size;
size.X = float.Parse(att.Value);
element.Size = size;
break;
}
case "height":
{
Vector2 size = element.Size;
size.Y = float.Parse(att.Value);
element.Size = size;
break;
}
case "xpos":
{
Vector2 pos = element.Position;
pos.X = float.Parse(att.Value);
element.Position = pos;
break;
}
case "ypos":
{
Vector2 pos = element.Position;
pos.Y = float.Parse(att.Value);
element.Position = pos;
break;
}
case "xlock":
{
for (int i = 0; i < (int)e_XLockMode.End; ++i)
{
e_XLockMode lockMode = (e_XLockMode)i;
if (lockMode.ToString().ToLower() == att.Value.ToLower())
{
element.XLockMode = lockMode;
break;
}
}
break;
}
case "ylock":
{
for (int i = 0; i < (int)e_YLockMode.End; ++i)
{
e_YLockMode lockMode = (e_YLockMode)i;
if (lockMode.ToString().ToLower() == att.Value.ToLower())
{
element.YLockMode = lockMode;
break;
}
}
break;
}
case "name":
{
if (!string.IsNullOrEmpty(att.Value))
{
m_namedElements.Add(att.Value, element);
}
break;
}
case "onhover":
{
string[] vals = att.Value.Split(new string[] { ":" }, StringSplitOptions.RemoveEmptyEntries);
if (vals.Length > 1)
{
Element.Interaction dele = GetAssemblyFunction(vals[0].TrimEnd(), vals[1].TrimEnd());
if (dele != null)
{
element.Hover += dele;
}
}
break;
}
case "onnormal":
{
string[] vals = att.Value.Split(new string[] { ":" }, StringSplitOptions.RemoveEmptyEntries);
if (vals.Length > 1)
{
Element.Interaction dele = GetAssemblyFunction(vals[0].TrimEnd(), vals[1].TrimEnd());
if (dele != null)
{
element.Normal += dele;
}
}
break;
}
case "onclick":
{
string[] vals = att.Value.Split(new string[] { ":" }, StringSplitOptions.RemoveEmptyEntries);
if (vals.Length > 1)
{
Element.Interaction dele = GetAssemblyFunction(vals[0].TrimEnd(), vals[1].TrimEnd());
if (dele != null)
{
element.Click += dele;
}
}
break;
}
case "onrelease":
{
string[] vals = att.Value.Split(new string[] { ":" }, StringSplitOptions.RemoveEmptyEntries);
if (vals.Length > 1)
{
Element.Interaction dele = GetAssemblyFunction(vals[0].TrimEnd(), vals[1].TrimEnd());
if (dele != null)
{
element.Release += dele;
}
}
break;
}
case "submenu":
{
element.SubMenuDirectory = att.Value;
break;
}
}
}
m_elements.Add(element);
foreach (XmlNode node in a_node.ChildNodes)
{
PopulateElements(node, element);
}
if (a_parent != null)
{
element.Parent = a_parent;
}
element.State = Element.e_State.Normal;
if (element.Normal != null)
{
element.Normal.Invoke(this, element);
}
}
}
void DiscordLoop()
{
bool connected = false;
m_join = false;
for (int i = 0; i < 10; ++i)
{
if (AttemptConnection(i))
{
connected = true;
break;
}
if (m_shutdown)
{
break;
}
}
if (!connected)
{
InternalConsole.Error("Failed to connect to Discord");
m_shutdown = true;
}
else
{
m_internalClient.BeginRead();
EnqueueMessage(new ConnectionEstablishedMessage(m_connectedPipe));
Handshake();
while (!m_shutdown)
{
Frame frame;
if (ReadFrame(out frame))
{
switch (frame.OpCode)
{
case Frame.e_OpCode.Close:
{
ClosePayload close = frame.GetObject <ClosePayload>();
InternalConsole.AddMessage("Discord Client Remotely Terminated");
EnqueueMessage(new CloseMessage(close.Code, close.Reason));
m_shutdown = true;
break;
}
case Frame.e_OpCode.Ping:
{
WriteFrame(new Frame(Frame.e_OpCode.Pong, frame.Data));
break;
}
case Frame.e_OpCode.Pong:
{
InternalConsole.Warning("Got a pong from Discord?");
break;
}
case Frame.e_OpCode.Frame:
{
if (m_shutdown)
{
break;
}
if (frame.Data == null)
{
InternalConsole.Error("Discord Client: No data in frame");
}
EventPayload response = frame.GetObject <EventPayload>();
ProcessEvent(response);
break;
}
default:
{
InternalConsole.Error("Discord Client: Invalid Operation");
m_shutdown = true;
break;
}
}
}
ProcessCommandQueue();
}
ProcessCommandQueue();
}
m_join = true;
}
