public void GetGeneFusionsByTranscript_TrickyCodingRegionLength_OverlappingCodingRegion()
{
// chr2 130185834 T [chr2:131488839[
// ENST00000427024.5, ENST00000425361.5, ENST00000309451.6
var origin = new BreakPoint(ChromosomeUtilities.Chr2, 130185834, true);
var partner = new BreakPoint(ChromosomeUtilities.Chr2, 131488839, false);
var adjacency = new BreakEndAdjacency(origin, partner);
var transcriptIdToGeneFusions = new Dictionary <string, IAnnotatedGeneFusion>();
transcriptIdToGeneFusions.GetGeneFusionsByTranscript(adjacency, _originTranscripts, _partnerTranscripts);
var observedAnnotatedGeneFusion = transcriptIdToGeneFusions["ENST00000425361.5"];
Assert.NotNull(observedAnnotatedGeneFusion);
Assert.Equal(2, observedAnnotatedGeneFusion.Intron);
Assert.Null(observedAnnotatedGeneFusion.Exon);
Assert.Equal(2, observedAnnotatedGeneFusion.GeneFusions.Length);
var fusion = observedAnnotatedGeneFusion.GeneFusions[0];
Assert.Equal("MZT2A{ENST00000427024.5}:c.1_278+3037_MZT2B{ENST00000425361.5}:c.210+3059_368", fusion.HgvsCoding);
Assert.Equal(2, fusion.Intron);
Assert.Null(fusion.Exon);
var fusion2 = observedAnnotatedGeneFusion.GeneFusions[1];
Assert.Equal("MZT2A{ENST00000309451.6}:c.1_319+3037_MZT2B{ENST00000425361.5}:c.210+3059_368", fusion2.HgvsCoding);
Assert.Equal(2, fusion2.Intron);
Assert.Null(fusion2.Exon);
}
/// <summary>
/// Decodes event data.
/// </summary>
private void DecodeEvents(string line)
{
var splits = line.Split(',');
EventType type = (EventType)Enum.Parse(typeof(EventType), splits[0]);
// Only two event types will be checked, as the rest should be decoded by storyboard decoder.
switch (type)
{
case EventType.Background:
string fileName = splits[2].Trim('"');
map.Detail.Metadata.BackgroundFile = PathUtils.StandardPath(fileName);
break;
case EventType.Break:
float start = ParseUtils.ParseFloat(splits[1]) + offset;
float end = Math.Max(start, ParseUtils.ParseFloat(splits[2]) + offset);
if (!BreakPoint.CanBeValid(start, end))
{
return;
}
map.BreakPoints.Add(new BreakPoint()
{
StartTime = start,
EndTime = end
});
break;
}
}
public Win3muDebugger(Machine machine)
{
BreakPoint.RegisterBreakPointType("wndproc", typeof(WndProcBreakPoint));
_machine = machine;
_wndProcSymbolScope = new WndProcSymbolScope(_machine);
_machine.Messaging.RegisterFilter(this);
}
public async Task OnResize(BreakPoint point)
{
if (OnBreakPointChanged != null)
{
await OnBreakPointChanged(point);
}
}
public static void AddBreakPoint(string behaviorFilename, string nodeId, string nodeType, string actionName, bool actionEnable, string actionResult, int hitCount)
{
if (string.IsNullOrEmpty(behaviorFilename) || string.IsNullOrEmpty(nodeId) || string.IsNullOrEmpty(nodeType) || string.IsNullOrEmpty(actionName) || hitCount < 0)
return;
behaviorFilename = behaviorFilename.Replace('\\', '/');
if (!_breakPoints.ContainsKey(behaviorFilename))
_breakPoints[behaviorFilename] = new Dictionary<string, BreakPoint>();
Dictionary<string, BreakPoint> breakPoints = _breakPoints[behaviorFilename];
if (!breakPoints.ContainsKey(nodeId))
breakPoints[nodeId] = new BreakPoint();
BreakPoint breakPoint = breakPoints[nodeId];
breakPoint.NodeType = nodeType;
Action action = breakPoint.FindAction(actionName);
if (action == null)
{
action = new Action();
breakPoint.Actions.Add(action);
}
action.Name = actionName;
action.Enable = actionEnable;
action.Result = actionResult;
action.HitCount = hitCount;
if (AddBreakPointHandler != null)
AddBreakPointHandler(behaviorFilename, nodeType, nodeId, action);
}
/// <summary>
/// 读取断点报文从数据流。
/// </summary>
/// <param name="outputStream"></param>
/// <returns>无法加载断点报文则返回 null。</returns>
private static BreakPoint LoadBreakPoint(System.IO.Stream outputStream)
{
if (outputStream.Length == 0)
{
return(null);
}
BreakPoint breakPoint = new BreakPoint();
long oldPosition = outputStream.Position; //记录数据操作指针原始位置。
try
{
System.Int32 Int64Size = 8;
outputStream.Seek(-Int64Size, System.IO.SeekOrigin.End);
System.IO.BinaryReader binaryReader = new System.IO.BinaryReader(outputStream, System.Text.Encoding.UTF8);
System.Int64 breakPointPosition = binaryReader.ReadInt64(); //读取断点报文数据区起始位置。
outputStream.Seek(breakPointPosition, System.IO.SeekOrigin.Begin); //定位到断点报文数据区起始位置。
System.Int32 breakPointLength = binaryReader.ReadInt32(); //读取断点报文的长度。
byte[] breakPointDatas = binaryReader.ReadBytes(breakPointLength); //读取断点报文。
breakPoint.FromBytes(breakPointDatas);
}
catch
{
return(null);
}
finally
{
outputStream.Position = oldPosition; //还原数据操作指针原始位置。
}
return(breakPoint);
}
private ITranscript[] GetOverlappingCodingTranscripts(BreakPoint bp)
{
if (bp == null)
{
return(null);
}
ITranscript[] transcripts = _transcriptCache.TranscriptIntervalForest.GetAllOverlappingValues(bp.Chromosome.Index, bp.Position,
bp.Position);
if (transcripts == null)
{
return(null);
}
var overlappingTranscripts = new List <ITranscript>();
foreach (var transcript in transcripts)
{
if (transcript.Id.IsPredictedTranscript() || transcript.Translation == null)
{
continue;
}
overlappingTranscripts.Add(transcript);
}
return(overlappingTranscripts.ToArray());
}
/** Initialize the ID's of the breakpoints and add up weights */
public void Initialize()
{
for (int i = 0; i < BreakPoints.Count; i++)
{
BreakPoint bp = BreakPoints[i];
bp.ID = i;
_TotalWeight += bp.Weight;
}
}
public void sendDeleteBreakPointCommand(BreakPoint breakPoint)
{
if (AcceptedEmulator != null)
{
if (AcceptedEmulator.IsConnected)
{
AcceptedEmulator.Send("DELB " + breakPoint.File + " " + breakPoint.LineNumber + "\n");
}
}
}
/// <summary>
/// Convert this event information to a <see cref="PausedEvent"/> event.
/// </summary>
/// <returns></returns>
public PausedEvent AsEvent()
{
var pausedEvent = new PausedEvent
{
HitBreakpoints = new[] { BreakPoint.GetBreakPointName(Script) },
Reason = Reason ?? "breakpoint",
CallFrames = BreakPoint.GetCallFrame(Script)
};
return(pausedEvent);
}
private void listViewBreakPoints_DoubleClick(object sender, EventArgs e)
{
if (0 == listViewBreakPoints.SelectedIndices.Count)
{
return;
}
BreakPoint dclickedBP = _breakPointManager.ActiveBreakPoints[listViewBreakPoints.SelectedIndices[0]];
_openFilesManager.OpenSourceFile(dclickedBP.ExecutablePath, dclickedBP.Location);
}
private void DebuggingService_OnStepComplete(object sender, BreakPoint e)
{
if (!IsConnected)
{
debuggingService.Step(JavaScriptDiagStepType.JsDiagStepTypeContinue);
return;
}
OnAdapterMessage?.Invoke(this, $"Step complete at {e}");
SendEvent(new StoppedEvent(currentThread.id, "step"));
DebugAdapterStatus = DebugAdapterStatusEnum.StepComplete;
}
public void sendAddBreakPointCommand(BreakPoint breakPoint)
{
if (AcceptedEmulator != null)
{
if (AcceptedEmulator.IsConnected)
{
String message = "SETB " + breakPoint.File + " " + breakPoint.LineNumber + "\n";
AcceptedEmulator.Send(message);
}
}
}
private void DrawWalls()
{
foreach (Element b in field.place)
{
BreakPoint br = b as BreakPoint;
if (br != null)
{
g.DrawImage(b.img, b.X, b.Y, b.Width, b.Height);
}
}
}
/** If the breakable owns the mended point, tell it that it should check if its mended */
public void NotifyBreakableOfRepair(BreakPoint inMendedPoint)
{
foreach (Breakable breakable in _AllBreakables)
{
if (breakable.ContainsBreakPoint(inMendedPoint) == true)
{
breakable.CheckIfRepaired();
return;
}
}
}
private void DebuggingService_OnBreakPoint(object sender, BreakPoint e)
{
if (!IsConnected)
{
clearBreakpointOnScript(e.ScriptId);
debuggingService.Step(JavaScriptDiagStepType.JsDiagStepTypeContinue);
return;
}
OnAdapterMessage?.Invoke(this, $"Breakpoint hit at {e}");
SendEvent(new StoppedEvent(currentThread.id, "breakpoint", "breakpoint hit"));
DebugAdapterStatus = DebugAdapterStatusEnum.BreakPointHit;
}
internal void MarkSetBreakPoint(BreakPoint breakPoint, bool clear)
{
// We can assume here that the location is already scrolled in view
TabPage tabPage = _mainWindow.OpenFilesControl.TabPages[breakPoint.ExecutablePath];
OpenFileUserControl fvUC = tabPage.Controls[0] as OpenFileUserControl;
RichTextBox rtb = fvUC.richTextBox;
rtb.SelectionStart = rtb.GetFirstCharIndexFromLine(breakPoint.Location.Y - 1) + breakPoint.Location.X - 2;;
rtb.SelectionLength = 1;
rtb.SelectionBackColor = clear ? rtb.BackColor : Color.Red;
rtb.SelectionLength = 0;
}
protected void OnStep(object sender, DebugInformation info)
{
if (Step != null)
{
Step(this, info);
}
if (Break != null)
{
BreakPoint breakpoint = BreakPoints.Find(l =>
{
bool afterStart, beforeEnd;
if (l.Line == info.CurrentStatement.Source.Start.Line)
{
return(true);
}
afterStart = l.Line > info.CurrentStatement.Source.Start.Line ||
(l.Line == info.CurrentStatement.Source.Start.Line && l.Char >= info.CurrentStatement.Source.Start.Char);
if (!afterStart)
{
return(false);
}
beforeEnd = l.Line < info.CurrentStatement.Source.Stop.Line ||
(l.Line == info.CurrentStatement.Source.Stop.Line && l.Char <= info.CurrentStatement.Source.Stop.Char);
if (!beforeEnd)
{
return(false);
}
if (!String.IsNullOrEmpty(l.Condition))
{
return(Convert.ToBoolean(this.Run(l.Condition)));
}
return(true);
});
if (breakpoint != null)
{
Break(this, info);
}
}
}
public void ToggleBreakPoint(int line)
{
if (line >= 0 && line < this.Document.TotalNumberOfLines)
{
ICSharpCode.TextEditor.Document.LineSegment lineseg = this.Document.GetLineSegment(line);
// walk through the line and make sure the first word is not a comment
bool okToAdd = false;
for (int i = 0; i < lineseg.Words.Count; i++)
{
if (lineseg.Words[i].Type == ICSharpCode.TextEditor.Document.TextWordType.Word)
{
if (lineseg.Words[i].Color != System.Drawing.Color.Green)
{
okToAdd = true;
}
break;
}
}
if (!okToAdd)
{
return;
}
ICSharpCode.TextEditor.Document.Bookmark existing_mark = null;
foreach (ICSharpCode.TextEditor.Document.Bookmark mark in this.Document.BookmarkManager.Marks)
{
if (mark.LineNumber == line)
{
existing_mark = mark;
break;
}
}
if (existing_mark != null)
{
this.Document.BookmarkManager.RemoveMark(existing_mark);
}
else
{
ICSharpCode.TextEditor.Document.Bookmark breakpoint = new BreakPoint(this.Document, new ICSharpCode.TextEditor.TextLocation(0, line));
this.Document.BookmarkManager.AddMark(breakpoint);
}
RepaintBookmarks();
}
}
private void AppDebugger_BreakPoint(IRemoteDebugApplicationThread prpt, tagBREAKREASON br, IActiveScriptErrorDebug pError)
{
RemoteDebugApplicationThread rdat = null;
if (prpt != null)
{
rdat = new RemoteDebugApplicationThread(prpt);
}
ActiveScriptErrorDebug ased = null;
if (pError != null)
{
ased = new ActiveScriptErrorDebug(pError);
}
BreakPoint?.Invoke(rdat, br.ToBreakReason(), ased);
}
public void ApplyBreakPoints()
{
Break -= OnBreakEvent;
int[] breakPoints = Debugger.GetBreakPoints(ModuleName);
if (breakPoints != null)
{
if (breakPoints.Length > 0)
{
BreakPoints.Clear();
foreach (int line in breakPoints)
{
var bp = new BreakPoint(line, 0);
BreakPoints.Add(bp);
}
Break += OnBreakEvent;
}
}
}
public static void AddBreakPoint(string behaviorFilename, string nodeId, string nodeType, string actionName, bool actionEnable, string actionResult, int hitCount)
{
if (string.IsNullOrEmpty(behaviorFilename) || string.IsNullOrEmpty(nodeId) || string.IsNullOrEmpty(nodeType) || string.IsNullOrEmpty(actionName) || hitCount < 0)
{
return;
}
behaviorFilename = behaviorFilename.Replace('\\', '/');
if (!_breakPoints.ContainsKey(behaviorFilename))
{
_breakPoints[behaviorFilename] = new Dictionary <string, BreakPoint>();
}
Dictionary <string, BreakPoint> breakPoints = _breakPoints[behaviorFilename];
if (!breakPoints.ContainsKey(nodeId))
{
breakPoints[nodeId] = new BreakPoint();
}
BreakPoint breakPoint = breakPoints[nodeId];
breakPoint.NodeType = nodeType;
Action action = breakPoint.FindAction(actionName);
if (action == null)
{
action = new Action();
breakPoint.Actions.Add(action);
}
action.Name = actionName;
action.Enable = actionEnable;
action.Result = actionResult;
action.HitCount = hitCount;
if (AddBreakPointHandler != null)
{
AddBreakPointHandler(behaviorFilename, nodeType, nodeId, action);
}
}
public override void SetBreakpoints(Response response, dynamic args)
{
string path = null;
if (args.source != null)
{
string p = (string)args.source.path;
if (p != null && p.Trim().Length > 0)
{
path = p;
}
}
if (path == null)
{
SendErrorResponse(response, 3010, "setBreakpoints: property 'source' is empty or misformed", null, false, true);
return;
}
path = ConvertClientPathToDebugger(path);
int[] clientLines = args.lines.ToObject <int[]>();
var file = path.Replace(_t_work_dir, "").Trim('/', '\\');
BreakCmd cmd = new BreakCmd();
cmd.m_file = file;
cmd.m_cmd_mode = BreakCmd.BreakCmdMode.ResetOneFile;
var breakpoints = new List <Breakpoint>();
for (var i = 0; i < clientLines.Length; ++i)
{
var l = ConvertClientLineToDebugger(clientLines[i]);
var p = new BreakPoint();
p.file_name = file;
p.line = l;
cmd.m_break_points.Add(p);
breakpoints.Add(new Breakpoint(true, clientLines[i]));
}
SendOneCmdAndWaitForResponse(cmd);
SendResponse(response, new SetBreakpointsResponseBody(breakpoints));
}
private void listViewBreakPoints_KeyPress(object sender, KeyPressEventArgs e)
{
if (0 == listViewBreakPoints.SelectedIndices.Count)
{
return;
}
if (('d' != e.KeyChar) && ('D' != e.KeyChar))
{
return;
}
BreakPoint bp = _breakPointManager.ActiveBreakPoints[listViewBreakPoints.SelectedIndices[0]];
_openFilesManager.MarkSetBreakPoint(bp, true);
_breakPointManager.RemoveBreakPoint(bp);
listViewBreakPoints.Items.Remove(listViewBreakPoints.SelectedItems[0]);
e.Handled = true;
}
private void DebuggingService_OnAsyncBreak(object sender, BreakPoint e)
{
if (!IsConnected)
{
debuggingService.Step(JavaScriptDiagStepType.JsDiagStepTypeContinue);
return;
}
OnAdapterMessage?.Invoke(this, $"Async break at {e}");
if (postAsyncBreakAction != null)//event is triggered by Attach command
{
postAsyncBreakAction();
postAsyncBreakAction = null;
}
else
{
SendEvent(new StoppedEvent(currentThread.id, "async break"));
}
DebugAdapterStatus = DebugAdapterStatusEnum.AsyncBreakHit;
}
public override void SetBreakpoints(Response response, dynamic arguments)
{
string fileName = arguments.source.name;
List <Breakpoint> bps = new List <Breakpoint>();
OnAdapterMessage?.Invoke(this, "Waiting for script ready");
engineReadyEvent.WaitOne();
if (findSourceCode(fileName, out var sourceCode))
{
clearBreakpointOnScript(sourceCode.ScriptId);
for (int i = 0; i < arguments.breakpoints.Count; i++)
{
uint line = (uint)ConvertDebuggerLineToClient((int)arguments.breakpoints[i].line);
BreakPoint bp = debuggingService.SetBreakpoint(sourceCode.ScriptId, line, 0);
bps.Add(new Breakpoint(true, ConvertClientLineToDebugger((int)bp.Line)));
}
}
OnAdapterMessage?.Invoke(this, $"BreakPoints on {fileName} Set");
SendResponse(response, new SetBreakpointsResponseBody(bps));
}
public static BreakPoint FindBreakPoint(string behaviorFilename, string nodeId, string actionName)
{
behaviorFilename = behaviorFilename.Replace('\\', '/');
if (!_breakPoints.ContainsKey(behaviorFilename))
{
return(null);
}
Dictionary <string, BreakPoint> breakPoints = _breakPoints[behaviorFilename];
if (!breakPoints.ContainsKey(nodeId))
{
return(null);
}
BreakPoint breakPoint = breakPoints[nodeId];
Action action = breakPoint.FindAction(actionName);
return((action != null) ? breakPoint : null);
}
public LayoutImport(string FilePath, bool ImportOnlyFirstLine, LayoutType LayoutType) : base(LayoutType)
{
_layoutBase = (LayoutBase)Layout;
_layoutBase.ImportOnlyFirstLine = ImportOnlyFirstLine;
_breakPoint = BreakPoint.Success;
Layout.Import(FilePath);
if (_layoutBase.HasError)
{
_breakPoint = BreakPoint.Import;
return;
}
//TODO: FEEL FREE TO CHANGE THE STRUCTURE AND THE METHOD SIGNATURE
if (!ImportOnlyFirstLine)
{
Layout.ValidateStructure();
if (_layoutBase.HasError)
{
_breakPoint = BreakPoint.ValidateStructure;
return;
}
Layout.Validate();
if (_layoutBase.HasError)
{
_breakPoint = BreakPoint.Validate;
return;
}
Layout.Save();
if (_layoutBase.HasError)
{
_breakPoint = BreakPoint.Save;
return;
}
}
}
/// <summary>
/// 保存断点数据到输出流。
/// </summary>
/// <param name="outputStream"></param>
/// <param name="breakPoint"></param>
private static void SaveBreakPoint(System.IO.Stream outputStream, BreakPoint breakPoint)
{
long oldPosition = outputStream.Position; //记录数据操作指针原始位置。
System.Int32 Int32Size = 4;
System.Int32 Int64Size = 8;
byte[] breakPointDatas = breakPoint.ToBytes();
System.Int64 fileSize = breakPoint.TotalSize + Int32Size + breakPointDatas.Length + Int64Size;
if (outputStream.Length != fileSize)
{
outputStream.SetLength(fileSize);
}
outputStream.Seek(breakPoint.TotalSize, System.IO.SeekOrigin.Begin);
System.IO.BinaryWriter binaryWriter = new System.IO.BinaryWriter(outputStream, System.Text.Encoding.UTF8);
binaryWriter.Write(breakPointDatas.Length); //写入断点报文的长度。
binaryWriter.Write(breakPointDatas); //写入断点报文。
binaryWriter.Write(breakPoint.TotalSize); //写入断点报文数据区起始位置。
outputStream.Position = oldPosition; //还原数据操作指针原始位置。
}
public static void RemoveBreakPoint(string behaviorFilename, string nodeId, Action action)
{
if (string.IsNullOrEmpty(behaviorFilename) || string.IsNullOrEmpty(nodeId) || action == null)
{
return;
}
behaviorFilename = behaviorFilename.Replace('\\', '/');
if (!_breakPoints.ContainsKey(behaviorFilename))
{
return;
}
Dictionary <string, BreakPoint> breakPoints = _breakPoints[behaviorFilename];
if (!breakPoints.ContainsKey(nodeId))
{
return;
}
BreakPoint breakPoint = breakPoints[nodeId];
breakPoint.RemoveAction(action.Name);
if (breakPoint.Actions.Count == 0)
{
breakPoints.Remove(nodeId);
if (breakPoints.Count == 0)
{
_breakPoints.Remove(behaviorFilename);
}
}
if (RemoveBreakPointHandler != null)
{
RemoveBreakPointHandler(behaviorFilename, breakPoint.NodeType, nodeId, action);
}
}
internal bool GetCaretLocation(out BreakPoint unboundBreakPoint)
{
unboundBreakPoint = null;
// Get the currently opened file
TabPage selectedTab = _mainWindow.OpenFilesControl.SelectedTab;
if (null != selectedTab)
{
OpenFileUserControl fvUC = selectedTab.Controls[0] as OpenFileUserControl;
Point caretLocation = GetCaretLocationInRichTextBox(fvUC.richTextBox);
unboundBreakPoint = new BreakPoint
{
ExecutablePath = fvUC.OpenedFilePath,
Location = caretLocation
};
return(true);
}
return(false);
}
private void btnAddSave_Click(object sender, EventArgs e)
{
if (txtSrc.Text == string.Empty || txtLine.Text == string.Empty)
{
return;
}
var breakPoint = new BreakPoint
{
Source = txtSrc.Text,
Line = int.Parse(txtLine.Text)
};
HashSet<int> breakPoints;
if (!_debuggerWindow.BreakPointMap.TryGetValue(breakPoint.Source, out breakPoints) || breakPoints == null)
{
breakPoints = new HashSet<int>();
_debuggerWindow.BreakPointMap[breakPoint.Source] = breakPoints;
}
breakPoints.Add(breakPoint.Line);
listBox1.Items.Add(breakPoint);
}
protected virtual void OnEngineStopped(bool finished, BreakPoint breakpoint, string reason)
{
if (Engine == null)
return;
if (finished)
{
Engine.EndMatch(console);
Engine = null;
//console.WriteLine(stopedString);
}
else
{
if (breakpoint!=null)
{
console.WriteLine(breakString);
console.WriteLine("Reason: " + reason);
}
else
{
console.WriteLine(pausedString);
}
}
}
/// <summary>
/// Redirection thru MainForm on derived class
/// </summary>
protected virtual void onEngineStoppedAsync(bool finished, BreakPoint breakPoint, string reason)
{
OnEngineStopped(finished, breakPoint, reason);
}
public void sendDeleteBreakPointCommand(BreakPoint breakPoint)
{
if (AcceptedEmulator != null)
{
if (AcceptedEmulator.IsConnected)
{
AcceptedEmulator.Send("DELB " + breakPoint.File + " " + breakPoint.LineNumber + "\n");
}
}
}
public void sendAddBreakPointCommand(BreakPoint breakPoint)
{
if (AcceptedEmulator != null)
{
if (AcceptedEmulator.IsConnected)
{
String message = "SETB " + breakPoint.File + " " + breakPoint.LineNumber + "\n";
AcceptedEmulator.Send(message);
}
}
}
private void button14_Click(object sender, EventArgs e)
{
if (this.InvokeRequired)
{
dbutton14_Click d = new dbutton14_Click(button14_Click);
object[] args = { sender, e };
this.Invoke(d, args);
}
else
{
if (AcceptedEmulator != null)
{
if (AcceptedEmulator.IsConnected)
{
if (!filetb.Text.Equals("") && !linetb.Text.Equals(""))
{
String message = "SETB " + filetb.Text.ToLower() + " " + linetb.Text + "\n";
BreakPoint bt = new BreakPoint(filetb.Text, linetb.Text);
BreakPoints.Add(bt);
AcceptedEmulator.Send(message);
}
}
}
}
}
void server_OnAccept(ASyncSocket AcceptedSocket)
{
if (this.InvokeRequired)
{
dserver_OnAccept d = new dserver_OnAccept(server_OnAccept);
object[] args = { AcceptedSocket };
this.Invoke(d, args);
}
else
{
AcceptedEmulator = AcceptedSocket;
AcceptedSocket.OnReceive += new ASyncSocket.OnReceiveEventHandler(server_OnReceive);
AcceptedSocket.OnSend += new ASyncSocket.OnSendEventHandler(server_OnSend);
AcceptedSocket.OnDisconnect += new ASyncSocket.OnDisconnectEventHandler(server_OnDisconnect);
AcceptedSocket.OnReceiveFailed += new ASyncSocket.OnReceiveFailedEventHandler(server_OnReceiveFailed);
AcceptedSocket.OnSendFailed += new ASyncSocket.OnSendFailedEventHandler(server_OnSendFailed);
String command = "\n> Emulator Ready to receive order.\n";
outPutTxtBx.AppendText(command);
outPutTxtBx.ScrollToCaret();
foreach (DocumentForm doc in this.mainForm.cgEeditor1.dockPanel.Documents)
{
//--- Get all breakPoints
foreach (Line line in doc.Scintilla.Lines)
{
int mask = doc.Scintilla.Markers.GetMarkerMask(line);
if (mask != 0)
{
BreakPoint breakpoint = new BreakPoint(doc.Text, (line.Number + 1).ToString());
this.sendAddBreakPointCommand(breakpoint);
}
}
}
}
}
/// <summary>
/// Redirection thru MainForm
/// </summary>
protected override void onEngineStoppedAsync(bool finished, BreakPoint breakPoint, string reason)
{
MainForm.Invoke(new EngineStoppedCallback(OnEngineStopped), finished, breakPoint, reason);
}
protected override void OnEngineStopped(bool finished, BreakPoint breakpoint, string reason)
{
if (finished)
{
EndWatch();
ActiveProject.Project.EngineOptions.Brake = executeBrake;
}
else
{
PauseWatch();
}
base.OnEngineStopped(finished, breakpoint, reason);
RefreshControls();
}
public void ToggleBreakPoint(int line)
{
if (line >= 0 && line < this.Document.TotalNumberOfLines)
{
ICSharpCode.TextEditor.Document.LineSegment lineseg = this.Document.GetLineSegment(line);
// walk through the line and make sure the first word is not a comment
bool okToAdd = false;
for (int i = 0; i < lineseg.Words.Count; i++)
{
if (lineseg.Words[i].Type == ICSharpCode.TextEditor.Document.TextWordType.Word)
{
if (lineseg.Words[i].Color != System.Drawing.Color.Green)
okToAdd = true;
break;
}
}
if (!okToAdd)
return;
ICSharpCode.TextEditor.Document.Bookmark existing_mark = null;
foreach (ICSharpCode.TextEditor.Document.Bookmark mark in this.Document.BookmarkManager.Marks)
{
if (mark.LineNumber == line)
{
existing_mark = mark;
break;
}
}
if (existing_mark != null)
{
this.Document.BookmarkManager.RemoveMark(existing_mark);
}
else
{
ICSharpCode.TextEditor.Document.Bookmark breakpoint = new BreakPoint(this.Document, new ICSharpCode.TextEditor.TextLocation(0, line));
this.Document.BookmarkManager.AddMark(breakpoint);
}
RepaintBookmarks();
}
}
public TextboxLinePart(BreakPoint textItem, TextStyle style, bool endOfLine)
{
_textItem = textItem;
_style = style;
EndOfLine = endOfLine;
}
public List<BreakPoint> Add(List<BreakPoint> breakPoints, int line)
{
for (int i = 0; i < breakPoints.Count; i++)
{
if (breakPoints[i].BPLineNumber == line)
return breakPoints;
}
BreakPoint node = new BreakPoint(true, line);
breakPoints.Add(node);
return breakPoints;
}
