public UnityMessageQuickDocPresenter(UnityMessage message, IClrDeclaredElement element,
QuickDocTypeMemberProvider quickDocTypeMemberProvider,
ITheming theming, HelpSystem helpSystem)
: this(message, null, element, quickDocTypeMemberProvider, theming, helpSystem)
{
myQuickDocTypeMemberProvider = quickDocTypeMemberProvider;
}
protected void ProcessMessage(UnityMessage message)
{
if (message is MessagePing)
{
m_pipe.SendMessage(new MessagePing("Hello from Max!"));
return;
}
if (message is MessageGeometryRequest)
{
m_pipe.SendMessage(new MessageGeometryUpdate(CreateUpdates()));
return;
}
if (message is MessageMaterialRequest)
{
m_pipe.SendMessage(new MessageMaterials(GetMaterials(message as MessageMaterialRequest)));
return;
}
if (message is MessageMapRequest)
{
m_pipe.SendMessage(GetMap(message as MessageMapRequest));
return;
}
var error = "Recieved unsupported message type: " + message.GetType().Name;
Log.Add(error);
SendError(error);
}
protected void ProcessMessage(UnityMessage message)
{
if (message == null)
{
Debug.Log("Did not recieve valid message from Max!");
return;
}
if (message is MessagePing)
{
Debug.Log((message as MessagePing).message);
return;
}
if (message is MessageGeometryUpdate)
{
GeometryCore.ProcessMessage(message as MessageGeometryUpdate);
return;
}
if (message is MessageError)
{
Debug.Log("Max encountered an error: " + (message as MessageError).message);
return;
}
Debug.Log("Encountered unknown message type: " + message.GetType().Name);
}
public void SendMessageToRN(UnityMessage message)
{
if (ShowMessageEvent != null)
{
ShowMessageEvent(message);
}
}
protected void ProcessIsochronous(UnityMessage message)
{
Debug.Log("Beginning import");
ProcessMessage(ExchangeIsochronous(message));
Debug.Log("Update Complete.");
}
public UnityMessageQuickDocPresenter(UnityMessage message, string parameterName,
IClrDeclaredElement element,
QuickDocTypeMemberProvider quickDocTypeMemberProvider,
ITheming theming, HelpSystem helpSystem)
{
myMessage = message;
myParameterName = parameterName;
myQuickDocTypeMemberProvider = quickDocTypeMemberProvider;
myTheming = theming;
myHelpSystem = helpSystem;
myEnvoy = new DeclaredElementEnvoy <IClrDeclaredElement>(element);
}
public void AddListener(string type, UnityAction <Message> listener)
{
UnityMessage message;
if (m_events.TryGetValue(type, out message))
{
message.AddListener(listener);
}
else
{
message = new UnityMessage();
message.AddListener(listener);
m_events.Add(type, message);
}
}
static List <UnityMessage> GetMessagesFromDocs()
{
var lines = File.ReadAllLines(string.Format("{0}/uSquid/Editor/Resources/MonoBehaviourMessages.txt", Application.dataPath));
var messages = new List <UnityMessage>();
var seperator = new string[] { ", " };
foreach (var line in lines)
{
if (line.Contains("//") ||
String.IsNullOrEmpty(line) ||
uSquidUtility.IsWhiteSpaceOrEmpty(line))
{
continue;
}
var msg = new UnityMessage();
var cells = line.Split(seperator, StringSplitOptions.RemoveEmptyEntries);
msg.MessageName = cells[0];
msg.EventName = cells[0];
msg.FireMethodName = "Fire" + msg.EventName;
msg.ClearMethodName = "Clear" + msg.EventName;
var argCells = cells.ToList();
argCells.RemoveAt(0);
msg.Args = argCells.Select(a =>
{
var argSplit = a.Split(' ');
return(new KeyValuePair <string, string>(argSplit[0], argSplit[1]));
}).ToList();
if (argCells.Any())
{
msg.CustomDelegateName = msg.EventName + "EventArgs";
}
else
{
msg.CustomDelegateName = null;
}
messages.Add(msg);
}
return(messages);
}
public void SendMessageToRN(UnityMessage message)
{
int id = generateId();
if (message.callBack != null)
{
waitCallbackMessageMap.Add(id, message);
}
JObject o = JObject.FromObject(new
{
id = id,
seq = message.callBack != null ? "start" : "",
name = message.name,
data = message.data
});
UnityMessageManager.Instance.SendMessageToRN(MessagePrefix + o.ToString());
}
/// <summary>
/// Initialize the communicator by sending the first UnityOutput and receiving the
/// first UnityInput. The second UnityInput is stored in the unityInput argument.
/// </summary>
/// <returns>The first Unity Input.</returns>
/// <param name="unityOutput">The first Unity Output.</param>
/// <param name="unityInput">The second Unity input.</param>
public UnityInput Initialize(UnityOutput unityOutput,
out UnityInput unityInput)
{
m_sender = new Socket(
AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
m_sender.Connect("localhost", communicatorParameters.port);
UnityMessage initializationInput =
UnityMessage.Parser.ParseFrom(Receive());
Send(WrapMessage(unityOutput, 200).ToByteArray());
unityInput = UnityMessage.Parser.ParseFrom(Receive()).UnityInput;
#if UNITY_EDITOR
EditorApplication.playModeStateChanged += HandleOnPlayModeChanged;
#endif
return(initializationInput.UnityInput);
}
protected UnityMessage ExchangeIsochronous(UnityMessage message)
{
try
{
pipe.SendMessage(message);
}
catch (Exception e)
{
Debug.Log("Could not send request: " + e.Message + e.StackTrace);
}
object m = pipe.ReceiveMessage();
if (!(m is UnityMessage))
{
Debug.Log("Could not receive message. Received type " + m.GetType().Name);
return null;
}
return m as UnityMessage;
}
static void OnMessage(BaseMessage bm)
{
//Console.WriteLine(bm.msg);
switch (bm.msg)
{
case LocalMsg.OnOpen:
monitor.Start();
break;
case LocalMsg.OnError:
case LocalMsg.OnClose:
case AppClose:
Messenger.RemoveListener(OnMessage, LocalMsg.OnOpen, LocalMsg.OnClose, LocalMsg.OnError, AppClose, ChangeSettingData);
monitor.Stop();
ExApiClient.Stop();
Application.Exit();
break;
case ChangeSettingData:
UnityMessage um = bm.GetData <UnityMessage>();
monitor.SetInterval(um.i2);
break;
}
}
public void ShowUnityMessage(UnityMessage msg)
{
DebugLog.DebugLogInfo("FF0000", msg.name + " " + msg.data.ToString());
}
public UnityMessageBehavior(DeclaredElementInfo info, UnityMessage message)
: base(info)
{
myMessage = message;
}
private static ILookupItem CreateMethodItem(CSharpCodeCompletionContext context, UnityMessage message,
IClassLikeDeclaration declaration)
{
if (CSharpLanguage.Instance == null)
{
return(null);
}
var method = message.CreateDeclaration(CSharpElementFactory.GetInstance(declaration), declaration);
if (method.DeclaredElement == null)
{
return(null);
}
var instance = new DeclaredElementInstance(method.DeclaredElement);
var declaredElementInfo = new DeclaredElementInfo(method.DeclaredName, instance, CSharpLanguage.Instance,
context.BasicContext.LookupItemsOwner, context, context.BasicContext);
return(LookupItemFactory.CreateLookupItem(declaredElementInfo).
WithPresentation(
_ => new GenerateMemberPresentation(declaredElementInfo, PresenterStyles.DefaultPresenterStyle)).
WithBehavior(_ =>
{
var behavior = new UnityMessageBehavior(declaredElementInfo, message);
behavior.InitializeRanges(context.CompletionRanges, context.BasicContext);
return behavior;
}).
WithMatcher(_ => new DeclaredElementMatcher(declaredElementInfo, context.BasicContext.IdentifierMatchingStyle)));
}
static List<UnityMessage> GetMessagesFromDocs()
{
var lines = File.ReadAllLines(string.Format("{0}/uSquid/Editor/Resources/MonoBehaviourMessages.txt", Application.dataPath));
var messages = new List<UnityMessage>();
var seperator = new string[] { ", " };
foreach (var line in lines)
{
if (line.Contains("//")
|| String.IsNullOrEmpty(line)
|| uSquidUtility.IsWhiteSpaceOrEmpty(line))
continue;
var msg = new UnityMessage();
var cells = line.Split(seperator, StringSplitOptions.RemoveEmptyEntries);
msg.MessageName = cells[0];
msg.EventName = cells[0];
msg.FireMethodName = "Fire" + msg.EventName;
msg.ClearMethodName = "Clear" + msg.EventName;
var argCells = cells.ToList();
argCells.RemoveAt(0);
msg.Args = argCells.Select(a =>
{
var argSplit = a.Split(' ');
return new KeyValuePair<string, string>(argSplit[0], argSplit[1]);
}).ToList();
if (argCells.Any())
msg.CustomDelegateName = msg.EventName + "EventArgs";
else
msg.CustomDelegateName = null;
messages.Add(msg);
}
return messages;
}
public void SendMessage(UnityMessage message)
{
byte[] messageData = MessageSerializers.SerializeObject(message);
byte[] messageLen = BitConverter.GetBytes(messageData.Length);
m_pipe.SendMessage(messageLen.Concat(messageData).ToArray());
}
