void Debugger_DebuggerDisconnecting(DebugManager sender, Target target)
{
target.CallstackUpdate -= new CallstackUpdateEventHandler(target_CallstackUpdate);
target.StateUpdate -= new StateUpdateEventHandler(target_StateUpdate);
callstackListView.Items.Clear();
}
void Debugger_DebuggerConnected(DebugManager sender, Target target)
{
target.StateUpdate += new StateUpdateEventHandler(target_StateUpdate);
target.VariableUpdate += new VariableUpdateEventHandler(target_VariableUpdate);
UpdateConnectionState(true);
}
void Debugger_DebuggerDisconnecting(DebugManager sender, Target target)
{
target.VariableUpdate -= new VariableUpdateEventHandler(Target_VariableUpdate);
target.StateUpdate -= new StateUpdateEventHandler(Target_StateUpdate);
Clear();
}
void Target_VariableUpdate(Target sender, VariableUpdateEventArgs args)
{
if (args.Type == VariableUpdateType.Locals)
{
mDebugger.Manager.StopProgressBarMarquee();
if (args.CacheFlush)
Clear();
UpdateVariables(args.Variables);
}
}
void Debugger_DebuggerDisconnecting(DebugManager sender, Target target)
{
target.VariableUpdate -= new VariableUpdateEventHandler(target_VariableUpdate);
target.StateUpdate -= new StateUpdateEventHandler(target_StateUpdate);
variablesListView.BeginUpdate();
foreach(TreeTableNode node in variablesListView.Root.Items)
{
node.SubItems[1].Text = "";
node.SubItems[2].Text = "";
node.Items.Clear();
}
variablesListView.EndUpdate();
UpdateConnectionState(false);
}
void target_CallstackUpdate(Target sender, CallstackUpdateEventArgs args)
{
// name (class::method) [C]
// name (C function 0x00000000) [C]
// name (file:line) [Lua]
string languageExpr = @"\[(?<language>\w*)\]";
string detailsExpr = @"(\((?<details>[^)]*)\))?";
string nameExpr = @"(?<name>\w*)?";
Regex functionRegex = new Regex(@"^" + nameExpr + @"\s*" + detailsExpr + @"\s*" + languageExpr + "$");
callstackListView.Items.Clear();
foreach(LuaStackFrame stackFrame in args.StackFrames)
{
string funcName = stackFrame.Function;
string source = stackFrame.File;
string language = "?";
string line = stackFrame.Line.ToString();
Match match = functionRegex.Match(stackFrame.Function);
if(match.Success)
{
string details = match.Groups["details"].Value;
funcName = match.Groups["name"].Value;
language = match.Groups["language"].Value;
if (funcName == "")
funcName = details;
if (language == "C" && details != "")
source = details;
if (language == "C")
line = "";
}
ListViewItem item = new ListViewItem(funcName);
item.Tag = stackFrame;
item.SubItems.Add(source);
item.SubItems.Add(line);
item.SubItems.Add(language);
if (stackFrame == mDebugger.CurrentStackFrame)
item.StateImageIndex = 0;
if (stackFrame.File.StartsWith("=[C]"))
item.ForeColor = SystemColors.GrayText;
callstackListView.Items.Add(item);
}
}
void Debugger_DebuggerConnected(DebugManager sender, Target target)
{
target.StateUpdate += new StateUpdateEventHandler(target_StateUpdate);
}
void target_ExCommandResult(Target sender, ExMessageEventArgs args)
{
if (args.Command == "StartProfile")
mDebugger.ShowStatusMessage("Lua Profile Started...");
else if (args.Command == "StopProfile")
mDebugger.ShowStatusMessage("Lua Profile Stopped!");
}
void Debugger_DebuggerConnected(DebugManager sender, Target target)
{
target.StateUpdate += new StateUpdateEventHandler(target_StateUpdate);
target.ExMessage += new ExMessageEventHandler(target_ExCommandResult);
UpdateMenuStatus();
}
void Target_FileUpload(Target sender, FileUploadEventArgs args)
{
MemoryStream stream = new MemoryStream(args.Data);
Document doc = Manager.CreateDocument(args.FileName, null, stream);
stream.Dispose();
if(doc != null)
Manager.ShowDocument(doc);
}
/// <summary>
/// Triggered when the target has accepted or rejected a breakpoint.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void Target_BreakpointUpdate(Target sender, BreakpointUpdateEventArgs args)
{
BreakpointDetails bkpt = FindBreakpoint(args.ID);
if(bkpt != null)
{
if (args.State == BreakpointUpdateEventState.Added)
{
// Force it to be displayed as enabled, 'cos the debugger is gonna break on it anyway!
bkpt.Enabled = true;
bkpt.TargetState = BreakpointState.Accepted;
}
else if (args.State == BreakpointUpdateEventState.Invalid)
bkpt.TargetState = BreakpointState.Invalid;
else if (args.State == BreakpointUpdateEventState.Removed)
{
if (bkpt.TargetState == BreakpointState.PendingRemove)
bkpt.TargetState = BreakpointState.Removed;
else if (bkpt.TargetState == BreakpointState.PendingDisable)
bkpt.TargetState = BreakpointState.NotSent;
}
if(bkpt.TargetState == BreakpointState.Removed)
mBreakpoints.Remove(bkpt);
OnBreakpointChanged(bkpt, bkpt.TargetState != BreakpointState.Removed);
}
}
void Target_StateUpdate(Target sender, StateUpdateEventArgs args)
{
mTargetStatus = args.TargetState;
if(args.TargetState == TargetState.Disconnected)
{
Disconnect(false, false);
mMainWindowComponents.targetStateLabel.Text = "";
Connect(mHostInfo);
}
else if (args.TargetState == TargetState.Connected)
{
HideStatusMessage();
// Tell everyone the good news
OnDebuggerConnected(mConnectedTarget);
SetNotification(Tilde.LuaDebugger.Properties.Resources.SystrayConnected, "Tilde connected", "Connection established to " + mConnectedTarget.HostInfo.ToString());
// Send breakpoints
foreach (BreakpointDetails bkpt in mBreakpoints)
{
if (bkpt.Enabled)
{
bkpt.TargetState = BreakpointState.PendingAdd;
mConnectedTarget.AddBreakpoint(bkpt.FileName, bkpt.Line, bkpt.ID);
}
else
{
bkpt.TargetState = BreakpointState.NotSent;
}
OnBreakpointChanged(bkpt, true);
}
// Send watches
foreach (WatchDetails watch in mWatches.Values)
{
if (watch.Enabled)
{
watch.State = WatchState.PendingAdd;
mConnectedTarget.AddWatch(watch.Expression, watch.ID);
}
else
{
watch.State = WatchState.NotSent;
}
}
// Request threads
mConnectedTarget.RetrieveThreads();
mMainWindowComponents.targetStateLabel.Text = "CONNECTED";
mCurrentThread = LuaValue.nil;
}
else if (args.TargetState == TargetState.Running)
{
mMainWindowComponents.targetStateLabel.Text = "RUN";
mCurrentThread = LuaValue.nil;
CurrentStackFrame = null;
}
else if (args.TargetState == TargetState.Breaked)
{
mMainWindowComponents.targetStateLabel.Text = "BREAK";
mCurrentThread = args.Thread;
Manager.FlashMainWindow();
}
else if (args.TargetState == TargetState.Error)
{
mMainWindowComponents.targetStateLabel.Text = "ERROR";
mCurrentThread = args.Thread;
}
else if (args.TargetState == TargetState.Finished)
{
mMainWindowComponents.targetStateLabel.Text = "FINISH";
mCurrentThread = LuaValue.nil;
CurrentStackFrame = null;
}
}
void target_StateUpdate(Target sender, StateUpdateEventArgs args)
{
if (args.TargetState != TargetState.Breaked && args.TargetState != TargetState.Error)
callstackListView.Items.Clear();
}
void target_VariableUpdate(Target sender, VariableUpdateEventArgs args)
{
if (args.Type == VariableUpdateType.Watches)
{
UpdateVariables(args.Variables);
mDebugger.Manager.StopProgressBarMarquee();
}
}
void target_AutocompleteOptions(Target sender, AutocompleteOptionsEventArgs args)
{
if (m_autocompletePopup.Visible && args.SequenceID == m_autocompleteSequenceID)
{
if (args.Message != null && args.Message.Length > 0)
{
m_autocompletePopup.SetMessage(args.Message);
}
else if(args.Options != null)
{
m_autocompletePopup.SetOptions(args.Options);
}
}
}
void Target_ErrorMessage(Target sender, ErrorMessageEventArgs args)
{
Manager.ShowMessages("Debug");
Manager.AddMessage("Debug", "\r\n" + args.Message + "\r\n");
Manager.FlashMainWindow();
if (mTargetStatus != TargetState.Error)
MessageBox.Show(Manager.MainWindow, args.Message, "Lua Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
else
{
string result = Tilde.Framework.Controls.MessageBoxEx.Show(Manager.MainWindow, args.Message, "Lua Error", new string[] { "Break", "Continue", "Ignore" }, MessageBoxIcon.Error, "Break");
if (result == "Continue")
mConnectedTarget.Run(ExecutionMode.Continue);
else if (result == "Ignore")
{
// Skip over any C functions on the stack to get to the top-most lua function
foreach(LuaStackFrame frame in mCurrentStack)
{
if (!frame.File.StartsWith("=[C]"))
{
mConnectedTarget.IgnoreError(frame.File, frame.Line);
break;
}
}
mConnectedTarget.Run(ExecutionMode.Continue);
}
}
}
void Target_StatusMessage(Target sender, StatusMessageEventArgs args)
{
ShowStatusMessage(args.Message);
}
void Debugger_DebuggerDisconnecting(DebugManager sender, Target target)
{
threadListView.Items.Clear();
target.ThreadUpdate -= new ThreadUpdateEventHandler(target_ThreadUpdate);
target.StateUpdate -= new StateUpdateEventHandler(target_StateUpdate);
}
void Target_CallstackUpdate(Target sender, CallstackUpdateEventArgs args)
{
if(args.StackFrames.Length > 0)
{
mCurrentStack = args.StackFrames;
mCurrentStackFrame = args.StackFrames[args.CurrentFrame < args.StackFrames.Length ? args.CurrentFrame : 0];
OnCurrentStackFrameChanged(mCurrentStackFrame, false);
}
}
void target_StateUpdate(Target sender, StateUpdateEventArgs args)
{
m_breakedThread = args.Thread;
UpdateStates();
}
void Target_ValueCached(Target target, ValueCachedEventArgs args)
{
mValueCache.Add(args.Value, args.Description);
}
void target_ThreadUpdate(Target sender, ThreadUpdateEventArgs args)
{
threadListView.BeginUpdate();
threadListView.ListViewItemSorter = null;
for (int index = 0; index < threadListView.Items.Count; )
{
ListViewItem item = threadListView.Items[index];
if (item.BackColor == Color.LightPink)
{
threadListView.Items.RemoveAt(index);
}
else
{
SetItemForeColor(item, threadListView.ForeColor);
SetItemBackColor(item, threadListView.BackColor);
++index;
}
}
foreach (ThreadDetails thread in args.Threads)
{
ListViewItem item = threadListView.Items[thread.Thread.ToString()];
if (!thread.Valid)
{
if(item != null)
SetItemBackColor(item, Color.LightPink);
}
else
{
if (item == null)
{
item = CreateItem(thread, threadListView.Items.Count, 0);
threadListView.Items.Add(item);
SetItemBackColor(item, Color.LightBlue);
UpdateItem(item, thread, false);
}
else
{
UpdateItem(item, thread, true);
}
}
}
UpdateStates();
UpdateSorting();
threadListView.EndUpdate();
}
void Debugger_DebuggerConnecting(DebugManager sender, Target target)
{
UpdateMenuStatus();
}
public void Connect(HostInfo hostInfo)
{
if (mConnectedTarget == null)
{
IConnection connection = hostInfo.Transport.Connect(hostInfo);
mHostInfo = hostInfo;
if (connection != null)
{
Target target = new Target(this, MainWindow, connection);
// mStatusMessage = new DebuggerStatusDialog("Establishing connection to " + target.HostInfo.ToString() + "...", true);
// mStatusMessage.Cancel.Click += new EventHandler(StatusMessage_Cancel_Click);
// mStatusMessage.Show(MainWindow);
mManager.SetStatusMessage("Establishing connection to " + target.HostInfo.ToString() + "...", 0);
SetNotification(Tilde.LuaDebugger.Properties.Resources.SystrayConnected, "Tilde Connecting...");
mConnectedTarget = target;
mConnectedTarget.DebugPrint += new DebugPrintEventHandler(Target_DebugPrint);
mConnectedTarget.ErrorMessage += new ErrorMessageEventHandler(Target_ErrorMessage);
mConnectedTarget.StatusMessage += new StatusMessageEventHandler(Target_StatusMessage);
mConnectedTarget.StateUpdate += new StateUpdateEventHandler(Target_StateUpdate);
mConnectedTarget.CallstackUpdate += new CallstackUpdateEventHandler(Target_CallstackUpdate);
mConnectedTarget.BreakpointUpdate += new BreakpointUpdateEventHandler(Target_BreakpointUpdate);
mConnectedTarget.ValueCached += new ValueCachedEventHandler(Target_ValueCached);
mConnectedTarget.FileUpload += new FileUploadEventHandler(Target_FileUpload);
OnDebuggerConnecting(mConnectedTarget);
}
}
}
void target_StateUpdate(Target sender, StateUpdateEventArgs args)
{
UpdateMenuStatus();
}
void OnDebuggerConnected(Target target)
{
mConnectionStatus = ConnectionStatus.Connected;
if (DebuggerConnected != null)
DebuggerConnected(this, target);
}
void Debugger_DebuggerDisconnecting(DebugManager sender, Target target)
{
target.StateUpdate -= new StateUpdateEventHandler(target_StateUpdate);
}
void OnDebuggerDisconnecting(Target target)
{
mConnectionStatus = ConnectionStatus.Disconnecting;
if (DebuggerDisconnecting != null)
DebuggerDisconnecting(this, target);
}
void target_StateUpdate(Target sender, StateUpdateEventArgs args)
{
}
void Target_DebugPrint(Target sender, DebugPrintEventArgs args)
{
Manager.AddMessage("Debug", args.Message);
}
