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; }