void Analysis(byte[] data, int readLength)
{
int pos = 0;
while (pos < readLength)
{
int size = System.BitConverter.ToInt32(data, pos);
EnumCommand cmd = (EnumCommand)System.BitConverter.ToInt32(data, pos + 4);
switch (cmd)
{
case EnumCommand.ES_TEXT_NORMAL:
int stringLength = size - 4;
string receiveString = System.Text.ASCIIEncoding.ASCII.GetString(data, pos + 8, stringLength);
richTextBox.InvokeAppendText(receiveString);
break;
case EnumCommand.ES_DRAW_CLEAR:
richTextBox.InvokeAppendLine("COMMAND: Draw Clear");
drawWindow.InvokeVisible();
drawWindow.InvokeClear();
break;
case EnumCommand.ES_DRAW_ADD:
unsafe
{
fixed(byte *pdata = data)
{
double *p = (double *)(pdata + pos + 8);
double x = *p;
double y = *(p + 1);
int color = *(int *)(p + 2);
string str = "(" + x + "," + y + ")";
//richTextBox.InvokeAppendText(str);
// str = xs.Count.ToString();
// textBlock1.Dispatcher.Invoke(() => textBlock1.Text = "point count = " + str);
drawWindow.InvokeAdd(x, y, color);
}
}
break;
case EnumCommand.ES_DRAW_DISPLAY:
richTextBox.InvokeAppendLine("COMMAND: Draw Display");
drawWindow.InvokeVisible();
drawWindow.InvokeDraw();
break;
default:
break;
}
pos += 4 + size;
}
richTextBox.InvokeScrollToEnd();
}
private byte[] GetData(EnumCommand cmd, string data = "")
{
Sequence++;
Command = (byte)cmd;
if (!string.IsNullOrEmpty(data))
{
Data = Encoding.UTF8.GetBytes(data);
}
int DataLength = Data.Length;
Length[1] = (byte)(0x06 + DataLength);
Checksum = (byte)(Sequence + Length[0] + Length[1] + Command - 0x01);
byte[] result = { Head, Sequence, Length[0], Length[1], Command, Checksum };
return(result);
}
private static ICommand _EnsureCommand(EnumCommand idCommand, Func <ICommand> func)
{
if (idCommand >= 0 && idCommand < EnumCommand.Last)
{
lock (_internalCommands.SyncRoot)
{
if (_internalCommands[(int)idCommand] == null)
{
_internalCommands[(int)idCommand] = func?.Invoke();
}
}
return(_internalCommands[(int)idCommand]);
}
return(null);
}
private Command title(EnumCommand enumCommand)
{
if (enumCommand.Equals(EnumCommand.CIRCLE))
{
return(new Command(EnumCommand.CIRCLE_TITLE));
}
else if (enumCommand.Equals(EnumCommand.TRIANGLE))
{
return(new Command(EnumCommand.TRIANGLE_TITLE));
}
else
{
return(new Command(EnumCommand.STAR_TITLE));
}
}
private void refFuncion(EnumCommand enumCommand, ref bool refCircle, ref bool refTriangle, ref bool refStar)
{
if (!refCircle && enumCommand.Equals(EnumCommand.CIRCLE))
{
refCircle = true;
}
else if (!refTriangle && enumCommand.Equals(EnumCommand.TRIANGLE))
{
refTriangle = true;
}
else if (!refStar && enumCommand.Equals(EnumCommand.STAR))
{
refStar = true;
}
}
private bool firstCommandLineCheckError(EnumCommand enumCommand, ref int indexCircle, ref int indexStar, ref int indexTriangle, int line)
{
GameManager gameManager = GameManager.instance;
if (EnumCommand.CIRCLE.Equals(enumCommand))
{
if (indexCircle > -1)
{
gameManager.showErro(String.Format(gameManager.messages.getErroFuncaoDefinidaDuasVezes(), gameManager.messages.getFuncaoCirculo()), false, true);
return(true);
}
else
{
indexCircle = line;
}
}
else if (EnumCommand.TRIANGLE.Equals(enumCommand))
{
if (indexTriangle > -1)
{
gameManager.showErro(String.Format(gameManager.messages.getErroFuncaoDefinidaDuasVezes(), gameManager.messages.getFuncaoTriangulo()), false, true);
return(true);
}
else
{
indexTriangle = line;
}
}
else if (EnumCommand.STAR.Equals(enumCommand))
{
if (indexStar > -1)
{
gameManager.showErro(String.Format(gameManager.messages.getErroFuncaoDefinidaDuasVezes(), gameManager.messages.getFuncaoEstrela()), false, true);
return(true);
}
else
{
indexStar = line;
}
}
else
{
gameManager.showErro(String.Format(gameManager.messages.getPrimeiroComandoLinha(), line + 1), false, true);
return(true);
}
return(false);
}
public GameObject getObjectToInstantiate(EnumCommand command)
{
switch (command)
{
case EnumCommand.CIRCLE:
return(circle);
case EnumCommand.CIRCLE_TITLE:
return(circle_title);
case EnumCommand.STAR:
return(star);
case EnumCommand.STAR_TITLE:
return(star_title);
case EnumCommand.TRIANGLE:
return(triangle);
case EnumCommand.TRIANGLE_TITLE:
return(triangle_title);
case EnumCommand.LOOP:
return(loop);
case EnumCommand.LEFT:
return(left);
case EnumCommand.RIGHT:
return(right);
case EnumCommand.MOVE:
return(move);
default:
return(null);
}
}
private Sprite getSpriteCommandMark(EnumCommand enumCommand)
{
switch (enumCommand)
{
case EnumCommand.CIRCLE:
return(circleMark);
case EnumCommand.CIRCLE_TITLE:
return(circleMark);
case EnumCommand.STAR:
return(starMark);
case EnumCommand.STAR_TITLE:
return(starMark);
case EnumCommand.TRIANGLE:
return(triangleMark);
case EnumCommand.TRIANGLE_TITLE:
return(triangleMark);
case EnumCommand.LOOP:
return(loopMark);
case EnumCommand.LEFT:
return(leftMark);
case EnumCommand.RIGHT:
return(rightMark);
case EnumCommand.MOVE:
return(moveMark);
default:
return(null);
}
}
bool Request(EnumCommand Command, out byte[] Buffer)
{
bool ret = false;
Buffer = null;
lockUSBPort.Wait();
//Trace.WriteLine(string.Format("Thread {0}, Enter request ...", Thread.CurrentThread.ManagedThreadId));
try
{
CommandStruct cmd = new CommandStruct()
{
Command = Command,
};
if (hidPort.WriteData(cmd.ToBytes()))
{
Buffer = hidPort.ReadData();
if (Buffer != null)
{
ret = true;
}
}
}
catch
{
ret = false;
}
finally
{
lockUSBPort.Release();
//Trace.WriteLine(string.Format("Thread {0}, Exit request ...", Thread.CurrentThread.ManagedThreadId));
}
return(ret);
}
public Command(Bitmap img, string name, EnumCommand cmd)
{
Image = img;
Name = name;
CommandId = cmd;
}
public MessageModel(EnumCommand command, string body)
{
m_Command = command;
m_Body = body;
}
private void SetCommand(string userCommand)
{
this.command = EnumCommand.NOT_RECOGNIZED;
Enum.TryParse(userCommand, out EnumCommand command);
this.command = command;
}
public GenericCommand(BaseViewModel Selected, EnumCommand comand)
{
_comand = comand;
_selected = Selected;
}
void HandlePendingEvents(Rect Canvas, List <DataStreamMeta> Streams)
{
System.Func <Vector2, TimeUnit?> CanvasPositionToTime = (Position) =>
{
return(PositionToTime(Canvas, Position));
};
System.Func <Vector2, StreamAndTime> CanvasPositionToStreamAndTime = (Position) =>
{
int?StreamIndex;
var Time = PositionToTime(Canvas, Position, Streams, out StreamIndex);
return(new StreamAndTime(Streams[StreamIndex.Value], Time.Value));
};
Input.ProcessScroll((ScrollTime) =>
{
ScrollTimeLeft.Time += ScrollTime.Time;
StickyScroll = false;
});
Input.ProcessSelect(CanvasPositionToTime, (SelectTime) =>
{
LastStickySelectTime = null;
if (SelectTime.HasValue)
{
OnSelectTime(SelectTime.Value);
}
});
Input.ProcessHover(CanvasPositionToTime, (HoverTime) =>
{
OnMouseHover(HoverTime);
});
if (Input.MouseDragCurrentPosition.HasValue)
{
// new drag
if (CurrentDrag == null)
{
CurrentDrag = new DragMeta();
CurrentDrag.DragAmount = new TimeUnit(0);
CurrentDrag.GrabTime = PositionToTime(Canvas, Input.MouseDragCurrentPosition.Value, Streams, out CurrentDrag.StreamIndex);
// check is draggable
CurrentDrag.Draggable = false;
try
{
var Stream = Streams[CurrentDrag.StreamIndex.Value];
CurrentDrag.Draggable = Stream.Draggable;
}
catch
{
CurrentDrag.Draggable = false;
}
}
else
{
if (CurrentDrag.Draggable)
{
// update drag
var NewDragTime = PositionToTime(Canvas, Input.MouseDragCurrentPosition.Value);
if (CurrentDrag.GrabTime.HasValue && NewDragTime.HasValue)
{
CurrentDrag.DragAmount = new TimeUnit(NewDragTime.Value.Time - CurrentDrag.GrabTime.Value.Time);
}
}
}
Input.MouseDragCurrentPosition = null;
}
// drag released
if (Input.MouseDragEndPosition.HasValue)
{
// invoke the drag
try
{
var Stream = Streams[CurrentDrag.StreamIndex.Value];
if (Stream.OnDragged != null)
{
Stream.OnDragged(CurrentDrag.GrabTime.Value, CurrentDrag.DragAmount);
}
}
catch (System.Exception e)
{
Debug.LogException(e);
}
CurrentDrag = null;
Input.MouseDragEndPosition = null;
}
if (Input.MouseJumpPrevPos.HasValue)
{
try
{
int?StreamIndex;
var JumpFromTime = PositionToTime(Canvas, Input.MouseJumpPrevPos.Value, Streams, out StreamIndex);
// get prev pos in stream
var PrevItemTime = new TimeUnit(JumpFromTime.Value.Time - 1);
var PrevItem = Bridge.GetNearestOrPrevStreamData(Streams[StreamIndex.Value], ref PrevItemTime);
// want the item to appear under mouse (where we clicked)
var ScrollOffset = JumpFromTime.Value.Time - ScrollTimeLeft.Time;
var PrevTimeLeft = PrevItemTime.Time - ScrollOffset;
ScrollTimeLeft = new TimeUnit(PrevTimeLeft);
}
catch (System.Exception)
{
// probably no more data
EditorApplication.Beep();
//Debug.LogException(e);
}
finally
{
Input.MouseJumpPrevPos = null;
}
}
if (Input.MouseJumpNextPos.HasValue)
{
try
{
int?StreamIndex;
var JumpFromTime = PositionToTime(Canvas, Input.MouseJumpNextPos.Value, Streams, out StreamIndex);
var NextItemTime = new TimeUnit(JumpFromTime.Value.Time + 1);
var NextItem = Bridge.GetNearestOrNextStreamData(Streams[StreamIndex.Value], ref NextItemTime);
// want the item to appear under mouse (where we clicked)
var ScrollOffset = JumpFromTime.Value.Time - ScrollTimeLeft.Time;
var NextTimeLeft = NextItemTime.Time - ScrollOffset;
ScrollTimeLeft = new TimeUnit(NextTimeLeft);
}
catch (System.Exception)
{
// probably no more data
EditorApplication.Beep();
//Debug.LogException(e);
}
finally
{
Input.MouseJumpNextPos = null;
}
}
Input.ProcessMenuClick(CanvasPositionToStreamAndTime, (StreamAndTime) =>
{
if (StreamAndTime.Stream.OnCreateContextMenu == null)
{
EditorApplication.Beep();
return;
}
// create the menu and add items to it
var Menu = new GenericMenu();
EnumCommand AppendMenuItem = (Label, Lambda) =>
{
if (string.IsNullOrEmpty(Label) || Label.EndsWith("-"))
{
// todo; use path
Menu.AddSeparator(null);
}
else if (Lambda == null)
{
Menu.AddDisabledItem(new GUIContent(Label));
}
else
{
// argh damned delegates
GenericMenu.MenuFunction Callback = () => { Lambda(); };
Menu.AddItem(new GUIContent(Label), false, Callback);
}
};
StreamAndTime.Stream.OnCreateContextMenu(StreamAndTime.Time, AppendMenuItem);
Menu.ShowAsContext();
});
}
public static string GetProtocolStr(EnumCommand secondCommand)
{
return(((int)secondCommand).ToString().PadLeft(ProtocolLen.Length, '0'));
}
public Command(EnumCommand command)
{
this.EnumCommand = command;
}
