//------------------------------------------------------------------------------
private void IndentButton_Click(object sender, RoutedEventArgs e)
{
TraceNode node = TTrace.Debug.Send("Tree indentation using Indent and UnIndent methods");
node.Indent("Indent", "level 1");
node.Send("Node1");
node.Indent("Indent level 2");
node.Send("Node2");
// UnIndent with no title
node.Indent("Indent level 3");
node.Send("Node3");
node.UnIndent(); // UnIndent without title
node.Send("Node4");
node.UnIndent("UnIndent level 2");
node.UnIndent("UnIndent level 1");
// node indentation using traceNodeEx
TTrace.Debug.Send("root 1", TTrace.Debug.IndentLevel.ToString());
TTrace.Debug.Indent("start indentation");
TTrace.Debug.Send("under indent 1", TTrace.Debug.IndentLevel.ToString());
TraceNodeEx nodeEx = new TraceNodeEx(TTrace.Debug); // Parent depends of the indentation
nodeEx.LeftMsg = "under indent 2";
nodeEx.Send();
TTrace.Debug.UnIndent();
TTrace.Debug.Send("root 2", TTrace.Debug.IndentLevel.ToString());
}
public override bool MoveToNext()
{
if (this.current == null)
{
#pragma warning disable 618
Fx.Assert("Operation is invalid on an empty document");
#pragma warning restore 618
throw new InvalidOperationException();
}
bool retval = false;
if (this.state != XPathNodeType.Text)
{
ElementNode parent = this.current.parent;
if (parent != null)
{
TraceNode temp = parent.MoveToNext();
if (temp == null && parent.text != null && !parent.movedToText)
{
this.state = XPathNodeType.Text;
parent.movedToText = true;
this.current = parent;
retval = true;
}
else if (temp != null)
{
this.state = temp.NodeType;
retval = true;
this.current = temp;
}
}
}
return(retval);
}
internal void AddElement(string prefix, string name, string xmlns)
{
if (this.closed)
{
#pragma warning disable 618
Fx.Assert("Cannot add data to a closed document");
#pragma warning restore 618
throw new InvalidOperationException();
}
else
{
ElementNode node = new ElementNode(name, prefix, this.CurrentElement, xmlns);
if (this.current == null)
{
this.VerifySize(node);
this.root = node;
this.current = this.root;
}
else if (!this.closed)
{
this.VerifySize(node);
this.CurrentElement.Add(node);
this.current = node;
}
}
}
public override bool MoveToNext()
{
if (this.current == null)
{
throw new InvalidOperationException();
}
bool flag = false;
if (this.state != XPathNodeType.Text)
{
ElementNode parent = this.current.parent;
if (parent == null)
{
return(flag);
}
TraceNode node2 = parent.MoveToNext();
if (((node2 == null) && (parent.text != null)) && !parent.movedToText)
{
this.state = XPathNodeType.Text;
parent.movedToText = true;
this.current = parent;
return(true);
}
if (node2 != null)
{
this.state = node2.NodeType;
flag = true;
this.current = node2;
}
}
return(flag);
}
//--------------------------------------------------------------------------------------------
private void butstart2_Click(object sender, System.EventArgs e)
{
if (start2 == null)
{
start2 = TTrace.Debug.Send("Start 2 ..");
}
}
//--------------------------------------------------------
private void butstart2_Click(object sender, EventArgs e)
{
start2 = TTrace.Debug.Send("Start 2 ..");
butEnd2.Enabled = true;
butShowNode.Enabled = true;
butToggleBookmark.Enabled = true;
butToggleVisible.Enabled = true;
}
//------------------------------------------------------------------------------
private void butstart2_Click(object sender, RoutedEventArgs e)
{
_start2 = TTrace.Debug.Send("Start 2 ..");
ButEnd2.IsEnabled = true;
ButShowNode.IsEnabled = true;
ButToogleBookmark.IsEnabled = true;
ButToogleVisible.IsEnabled = true;
}
//--------------------------------------------------------------------------------------------
protected void butResend_Click(object sender, EventArgs e)
{
start1 = (TraceNode)Session.Contents["start1"];
if (start1 == null)
{
return;
}
start1.ResendRight("Done 1");
}
//--------------------------------------------------------------------------------------------
protected void butSetSelected_Click(object sender, EventArgs e)
{
start1 = (TraceNode)Session.Contents["start1"];
if (start1 == null)
{
return;
}
start1.SetSelected();
}
//--------------------------------------------------------------------------------------------
protected void butAppend_Click(object sender, EventArgs e)
{
start2 = (TraceNode)Session.Contents["start2"];
if (start2 == null)
{
return;
}
start2.AppendLeft("..Done"); // Append left part
}
//--------------------------------------------------------------------------------------------
protected void butShowNode_Click(object sender, EventArgs e)
{
start2 = (TraceNode)Session.Contents["start2"];
if (start2 == null)
{
return;
}
start2.Show();
}
public static TraceResult Trace(
string host,
int maxTtl = 100,
int timeout = 100)
{
String tempStatus = "";
TraceResult result = new TraceResult();
try
{
Ping pinger = new Ping();
byte[] buffer = Encoding.ASCII.GetBytes(new string('a', 32));
Stopwatch timer = Stopwatch.StartNew();
for (int ttl = 1; ttl < maxTtl; ttl++)
{
PingOptions options = new PingOptions(ttl, true);
timer.Restart();
PingReply reply = pinger.Send(host, timeout, buffer, options);
timer.Stop();
TraceNode node = new TraceNode();
if (reply.Status != IPStatus.TimedOut)
{
node.Address = reply.Address.ToString();
}
else
{
node.Address = "*";
}
node.Status = reply.Status.ToString();
node.Ttl = ttl;
node.RoundtripTime = timer.ElapsedMilliseconds;
result.Nodes.Add(node);
if (reply.Status == IPStatus.Success)
{
tempStatus = "Success";
break;
}
}
if (string.IsNullOrEmpty(tempStatus))
{
tempStatus = "TooSmallValueMaxHops";
}
}
catch (Exception)
{
tempStatus = "InvalidTrace";
}
result.Status = tempStatus;
return(result);
}
internal TraceNode MoveToNext()
{
TraceNode retval = null;
if ((this.elementIndex + 1) < this.childNodes.Count)
{
++this.elementIndex;
retval = this.childNodes[this.elementIndex];
}
return(retval);
}
//--------------------------------------------------------------------------------------------
protected void butstart2_Click(object sender, EventArgs e)
{
start2 = (TraceNode)Session.Contents["start2"];
if (start2 == null)
{
start2 = TTrace.Debug.Send("Start 2 ..");
Session.Contents["start2"] = start2;
butAppend.Enabled = true;
butShowNode.Enabled = true;
}
}
//------------------------------------------------------------------------------
private void butDone1_Click(object sender, RoutedEventArgs e)
{
//start1.ResendRight("Done 1");
//start1.AppendStack();
// same creating a duplicate node with same id
TraceNode newNode = new TraceNode(null,false);
newNode.Id = start1.Id;
newNode.ResendRight("Done 1");
newNode.AppendStack();
}
internal void CloseElement()
{
if (this.closed)
{
throw new InvalidOperationException();
}
this.current = this.CurrentElement.parent;
if (this.current == null)
{
this.closed = true;
}
}
protected void butStart1_Click(object sender, EventArgs e)
{
start1 = (TraceNode)Session.Contents["start1"];
if (start1 == null)
{
start1 = TTrace.Debug.Send("Start 1 ..");
Session.Contents["start1"] = start1;
butResend.Enabled = true;
butSetSelected.Enabled = true;
butNodeIndent.Enabled = true;
}
}
//--------------------------------------------------------------------------------------------
protected void butNodeIndent_Click(object sender, EventArgs e)
{
start1 = (TraceNode)Session.Contents["start1"];
if (start1 == null)
{
return;
}
start1.Send("before indent"); // send text under the start1 node
start1.Indent("ident 1"); // send text under the start1 node and keep it this trace as the new target for further sub traces
start1.Send("Level2"); // send text under the "indent 1" node
start1.UnIndent("done"); // unindent and send text under the start1 node. Text is optional
}
//------------------------------------------------------------------------------
/// <summary>
/// Initialise the plugin
/// </summary>
public void Start()
{
// create a window and ask to receive timer, action and onBeforeDelete events
PlugTraces = new WinTrace("CSHARP", "CSharp Plugin9");
PlugTraces.DisplayWin();
PlugTraces.LinkToPlugin(PlugName,
TraceConst.CST_PLUG_ONACTION +
TraceConst.CST_PLUG_ONBEFOREDELETE +
TraceConst.CST_PLUG_ONTIMER);
// disable the LogFile label
PlugTraces.DisableResource(TraceConst.CST_ACTION_LABEL_LOGFILE);
// add a menu to the 'window' menu
PlugTraces.CreateResource(100, TraceConst.CST_RES_MENU_WINDOW, 0, "My CSharp Plug");
// add a menu to the 'action' menu
PlugTraces.CreateResource(101, TraceConst.CST_RES_MENU_ACTION, 0, "My CSharp action Plug");
// add a label on right, autosize (0)
PlugTraces.CreateResource(102, TraceConst.CST_RES_LABEL_RIGHT, 0, "My label");
// add a button on right (100 pixels)
PlugTraces.CreateResource(103, TraceConst.CST_RES_BUT_RIGHT, 100, "STOP");
// add a label on left, 100 pixels
PlugTraces.CreateResource(104, TraceConst.CST_RES_LABEL_LEFT, 100, "My status");
TraceNodeEx node;
node = new TraceNodeEx(PlugTraces.Debug);
node.LeftMsg = "Actions";
node.Id = "ActionsNode";
ActionNodes = node.Send();
node = new TraceNodeEx(PlugTraces.Debug);
node.LeftMsg = "Deleted Nodes";
node.Id = "BeforeDeletes";
BeforeDeleteNodes = node.Send();
node = new TraceNodeEx(PlugTraces.Debug);
node.LeftMsg = "Timer";
node.Id = "Timer";
Timer = node.Send();
PlugTraces.Debug.Send("Sample CSharp 10.1 Plugin started");
}
internal void CloseElement()
{
if (this.closed)
{
#pragma warning disable 618
Fx.Assert("The document is already closed.");
#pragma warning restore 618
throw new InvalidOperationException();
}
else
{
this.current = this.CurrentElement.parent;
if (this.current == null)
{
this.closed = true;
}
}
}
internal void AddElement(string prefix, string name, string xmlns)
{
if (this.closed)
{
throw new InvalidOperationException();
}
ElementNode node = new ElementNode(name, prefix, this.CurrentElement, xmlns);
if (this.current == null)
{
this.VerifySize(node);
this.root = node;
this.current = this.root;
}
else if (!this.closed)
{
this.VerifySize(node);
this.CurrentElement.Add(node);
this.current = node;
}
}
internal void AddElement(string prefix, string name, string xmlns)
{
if (this.closed)
{
throw new InvalidOperationException();
}
ElementNode node = new ElementNode(name, prefix, this.CurrentElement, xmlns);
if (this.current == null)
{
this.VerifySize(node);
this.root = node;
this.current = this.root;
}
else if (!this.closed)
{
this.VerifySize(node);
this.CurrentElement.Add(node);
this.current = node;
}
}
public override bool MoveToParent()
{
if (this.current == null)
{
#pragma warning disable 618
Fx.Assert("Operation is invalid on an empty document");
#pragma warning restore 618
throw new InvalidOperationException();
}
bool retval = false;
switch (this.state)
{
case XPathNodeType.Comment:
case XPathNodeType.Element:
case XPathNodeType.ProcessingInstruction:
if (this.current.parent != null)
{
this.current = this.current.parent;
this.state = this.current.NodeType;
retval = true;
}
break;
case XPathNodeType.Attribute:
this.state = XPathNodeType.Element;
retval = true;
break;
case XPathNodeType.Text:
this.state = XPathNodeType.Element;
retval = true;
break;
case XPathNodeType.Namespace:
this.state = XPathNodeType.Element;
retval = true;
break;
}
return(retval);
}
public override bool MoveToParent()
{
if (this.current == null)
{
throw new InvalidOperationException();
}
bool flag = false;
switch (this.state)
{
case XPathNodeType.Element:
case XPathNodeType.ProcessingInstruction:
case XPathNodeType.Comment:
if (this.current.parent != null)
{
this.current = this.current.parent;
this.state = this.current.NodeType;
flag = true;
}
return(flag);
case XPathNodeType.Attribute:
this.state = XPathNodeType.Element;
return(true);
case XPathNodeType.Namespace:
this.state = XPathNodeType.Element;
return(true);
case XPathNodeType.Text:
this.state = XPathNodeType.Element;
return(true);
case XPathNodeType.SignificantWhitespace:
case XPathNodeType.Whitespace:
return(flag);
}
return(flag);
}
public override bool MoveToFirstChild()
{
if (this.current == null)
{
throw new InvalidOperationException();
}
bool flag = false;
if ((this.CurrentElement.childNodes != null) && (this.CurrentElement.childNodes.Count > 0))
{
this.current = this.CurrentElement.childNodes[0];
this.state = this.current.NodeType;
return(true);
}
if (((this.CurrentElement.childNodes == null) || (this.CurrentElement.childNodes.Count == 0)) && (this.CurrentElement.text != null))
{
this.state = XPathNodeType.Text;
this.CurrentElement.movedToText = true;
flag = true;
}
return(flag);
}
public override bool MoveToFirstChild()
{
if (this.current == null)
{
#pragma warning disable 618
Fx.Assert("Operation is invalid on an empty document");
#pragma warning restore 618
throw new InvalidOperationException();
}
bool retval = false;
if (null != this.CurrentElement.childNodes && this.CurrentElement.childNodes.Count > 0)
{
this.current = this.CurrentElement.childNodes[0];
this.state = this.current.NodeType;
retval = true;
}
else if ((null == this.CurrentElement.childNodes || this.CurrentElement.childNodes.Count == 0) && this.CurrentElement.text != null)
{
this.state = XPathNodeType.Text;
this.CurrentElement.movedToText = true;
retval = true;
}
return(retval);
}
protected override CorrelaterResult <T> InternalCorrelate(ICollectionWrapper <T> collection1, ICollectionWrapper <T> collection2, CancellationToken cancellationToken = default)
{
var elementToLocationsInCollection2 = GetDictionaryFromElementToLocationsInCollection(collection2);
var traceList = new TraceNode[collection1.Length + 1];
var thresholds = new int[collection1.Length + 1];
thresholds[0] = -1;
for (var i = 1; i < thresholds.Length; i++)
{
thresholds[i] = thresholds.Length + 1;
}
for (var i = 0; i < collection1.Length; i++)
{
cancellationToken.ThrowIfCancellationRequested();
OnProgressUpdate?.Invoke(i + 1, collection1.Length);
if (!elementToLocationsInCollection2.ContainsKey(collection1[i]))
{
continue;
}
foreach (var j in elementToLocationsInCollection2[collection1[i]])
{
var k = BinarySearchFindK(j, thresholds);
if (j < thresholds[k])
{
thresholds[k] = j;
traceList[k] = new TraceNode(i, j, k > 0 ? traceList[k - 1] : null);
}
}
}
return(GetResult(collection1, collection2, thresholds, traceList));
}
internal void CloseElement()
{
if (this.closed)
{
#pragma warning disable 618
Fx.Assert("The document is already closed.");
#pragma warning restore 618
throw new InvalidOperationException();
}
else
{
this.current = this.CurrentElement.parent;
if (this.current == null)
{
this.closed = true;
}
}
}
private void butStart1_Click(object sender, EventArgs e)
{
start1 = TTrace.Debug.Send ("Start 1 ..") ;
butDone1.Enabled = true ;
butSetSelected.Enabled = true ;
}
public override bool MoveToFirstChild()
{
if (this.current == null)
{
#pragma warning disable 618
Fx.Assert("Operation is invalid on an empty document");
#pragma warning restore 618
throw new InvalidOperationException();
}
bool retval = false;
if (null != this.CurrentElement.childNodes && this.CurrentElement.childNodes.Count > 0)
{
this.current = this.CurrentElement.childNodes[0];
this.state = this.current.NodeType;
retval = true;
}
else if ((null == this.CurrentElement.childNodes || this.CurrentElement.childNodes.Count == 0) && this.CurrentElement.text != null)
{
this.state = XPathNodeType.Text;
this.CurrentElement.movedToText = true;
retval = true;
}
return retval;
}
internal void Add(TraceNode node)
{
this.childNodes.Add(node);
}
public override bool MoveToNext()
{
if (this.current == null)
{
#pragma warning disable 618
Fx.Assert("Operation is invalid on an empty document");
#pragma warning restore 618
throw new InvalidOperationException();
}
bool retval = false;
if (this.state != XPathNodeType.Text)
{
ElementNode parent = this.current.parent;
if (parent != null)
{
TraceNode temp = parent.MoveToNext();
if (temp == null && parent.text != null && !parent.movedToText)
{
this.state = XPathNodeType.Text;
parent.movedToText = true;
this.current = parent;
retval = true;
}
else if (temp != null)
{
this.state = temp.NodeType;
retval = true;
this.current = temp;
}
}
}
return retval;
}
private void butTrace_Click(object sender, RoutedEventArgs e)
{
// specify what to send (modifiers, fields, ...). Can be slow on complexe objects
TraceDisplayFlags flags = TraceDisplayFlags.ShowModifiers |
TraceDisplayFlags.ShowInheritedMembers |
TraceDisplayFlags.ShowNonPublic |
TraceDisplayFlags.ShowFields;
if (ChkSendFunctions.IsChecked != null && (bool)ChkSendFunctions.IsChecked)
{
flags |= TraceDisplayFlags.ShowMethods;
}
//TTrace.Debug.SendObject("button1", button1);
//button1.Width = button1.Width + 10;
//button1.SetValue(Canvas.LeftProperty, (double)button1.GetValue(Canvas.LeftProperty) + 1);
if (ChkSendProcessName.IsChecked != null)
{
TTrace.Options.SendProcessName = (bool)ChkSendProcessName.IsChecked;
}
string str = '\u2250' + "qwerty & @ € é ù è azerty" + '\u9999';
// simple traces
//--------------------------------------------
TTrace.Debug.Send("Hello").Send("World"); // "World" is a sub trace of "Hello"
// single separator
TTrace.Debug.Send("---");
// send traces with special font style (bold and Italic), color font size and font name
// use System.Drawing.Color.ToArgb() (not supported in Silverlight) or (int)Helper.ToArgb(System.Windows.Media.Color) to specify Argb color
TTrace.Debug.Send("Special font", "Symbol 12")
.SetFontDetail(-1, false, true) // set whole line to italic
.SetFontDetail(3, true, false, System.Drawing.Color.Red.ToArgb()) // set col 3 (Left Msg) to bold and Red
.SetFontDetail(4, false, false, System.Drawing.Color.Green.ToArgb(), 12, "Symbol"); // set col 4 (Right Msg) to Green , font size 12 , Symbol
TTrace.Debug.Send("Impact Italic")
.SetFontDetail(3, false, true, System.Drawing.Color.BlueViolet.ToArgb(), 12, "Impact"); // Col3 (left msg), non bold, Italic , Blue-Violet , font 12 , Impact
TTrace.Debug.Send("Special chars", "€ é ù è $ ");
// The characters to encode:
// Latin Small Letter Z (U+007A)
// Latin Small Letter A (U+0061)
// Combining Breve (U+0306)
// Latin Small Letter AE With Acute (U+01FD)
// Greek Small Letter Beta (U+03B2)
// a high-surrogate value (U+D8FF)
// a low-surrogate value (U+DCFF)
//char[] myChars = new char[] { 'z', 'a', '\u0306', '\u01FD', '\u03B2', '\uD8FF', '\uDCFF' };
//TTrace.Debug.Send("Other Special chars", new StringBuilder().Append(myChars).ToString()); // note that myChars.ToString() return "char[]"
// double separator
TTrace.Debug.Send("===");
//TTrace.Options.SendThreadId = false ;
//TTrace.Debug.Send("trace without thread id");
//TTrace.Options.SendThreadId = true;
//TTrace.Options.SendDate = true;
//TTrace.Debug.Send("trace with date");
//TTrace.Options.SendDate = false;
// traces using Sendxxx method
//--------------------------------------------
// Use default display filter. (see TTrace.Options)
TTrace.Debug.SendType("Object base type", typeof(Object));
TTrace.Debug.SendType("My interface", typeof(IMyinterface));
TTrace.Debug.SendObject("My const", TraceConst.CST_CREATE_MEMBER);
TTrace.Debug.SendObject("My enum", _testClass.FieldDay);
TTrace.Debug.SendCaller("SendCaller test", 0);
TTrace.Debug.SendStack("Stack test", 0);
TTrace.Debug.SendDump("SendDump test", "Unicode", Encoding.Unicode.GetBytes(str), 50);
TTrace.Warning.SendType("SendType 'testClass'", _testClass.GetType());
TTrace.Error.SendObject("SendObject 'testClass'", _testClass, flags);
// traces using TraceNodeEx
//--------------------------------------------
TraceNodeEx node = new TraceNodeEx(null); // TTrace.Debug
node.LeftMsg = "TraceNodeEx";
node.RightMsg = str;
node.AddFontDetail(3, false, false, System.Drawing.Color.Green.ToArgb());
node.IconIndex = 8;
node.Members.Add("My Members", "col2", "col3")
.SetFontDetail(0, true) // set first column to bold
.SetFontDetail(1, false, false, System.Drawing.Color.Green.ToArgb()) // set second column to green
.Add("Sub members") // add sub member node
.SetFontDetail(0, false, true); // set first column to Italic
node.AddDump("ASCII", Encoding.ASCII.GetBytes(str), 50); // 3F 61 7A ..... 3F
node.AddDump("UTF8", Encoding.UTF8.GetBytes(str), 50);
node.AddDump("Unicode", Encoding.Unicode.GetBytes(str), 50); // 50 22 61 00 7A 00 ..... 99 99
node.AddStackTrace(0);
node.AddCaller();
TraceNode sendNode = node.Send();
sendNode.ResendIconIndex(5); // change icon index after the node is send
// XML sample using Send
//--------------------------------------------
TTrace.Debug.SendXml("xml", "<?xml version='1.0' ?><Data> Hello XML </Data>");
// Image sample using Send
//--------------------------------------------
//TTrace.Debug.SendBitmap("Bitmap", Image1);
// Text, image and XML together
//--------------------------------------------
node = new TraceNodeEx(TTrace.Debug);
node.LeftMsg = "Text, image and XML together";
node.Members.Add("Text displayed in detail");
//node.AddBitmap(Image1);
node.AddXML("<?xml version='1.0' ?><Data> Xml in traceNodeEx </Data>");
node.Send();
// group of traces enabled / disabled
//------------------------------------
TraceNode groupTrace = new TraceNode(null, false); // dummy node not send to viewer
groupTrace.IconIndex = 5;
groupTrace.Enabled = true;
groupTrace.Send("GroupTrace traces 1"); // send to viewer
groupTrace.Enabled = false;
groupTrace.Send("GroupTrace traces 2"); // not send : group not enabled
// generics
//------------------------------------
TTrace.Debug.SendType("typeof(Dictionary<,>)", typeof(Dictionary <,>), flags); // open generic
TTrace.Debug.SendType("typeof(Dictionary<Window, structTest>", typeof(Dictionary <Window, StructTest>), flags); // closed generic
TTrace.Debug.SendObject("new Dictionary<Window, structTest>()", new Dictionary <Window, StructTest>(), flags);
TTrace.Debug.SendType("typeof(templateTest<,>)", typeof(TemplateTest <,>), flags);
TTrace.Debug.SendObject("new templateTest<Window, structTest>()", new TemplateTest <Window, StructTest>(), flags);
// Display tables : use an object that implement : Array or IEnumerable or IDictionary or create a special table
//--------------------------------------------------------------------------------------------------------------
// 1) array of int
int[] numbersA = { 0, 2, 4, 5, 6, 8, 9 };
int[] numbersB = { 1, 3, 5, 7, 8 };
TTrace.Debug.SendTable("numbersA", numbersA);
TTrace.Debug.SendTable("numbersB", numbersB);
// Linq on array
var pairs =
from a in numbersA
from b in numbersB
where a < b
select new { a, b };
TTrace.Debug.SendTable("Linq query on series", pairs);
// 2) array of FileInfo[]
string strTempPath = Path.GetTempPath();
DirectoryInfo tempPath = new DirectoryInfo(strTempPath);
TTrace.Debug.SendTable("Files in temp path", tempPath.GetFiles());
// Linq to array of FileInfo[]
var linqToObjectQuery = from file in tempPath.GetFiles()
where file.Length > 100
orderby file.Length descending
select new
{
file.Name,
file.Length,
file.LastWriteTime,
file
};
TTrace.Debug.SendTable("Files having length>100 in temp path (Linq)", linqToObjectQuery);
// 3) IDictionary : Hashtable
Hashtable openWith = new Hashtable();
openWith.Add("txt", "notepad.exe");
openWith.Add("bmp", "paint.exe");
openWith.Add("dib", "paint.exe");
openWith.Add("rtf", "wordpad.exe");
TTrace.Debug.SendTable("Hashtable", openWith);
// 4) UnTyped collection : Stack
Stack windowStack = new Stack(5);
windowStack.Push(this);
windowStack.Push(this);
windowStack.Push(this);
TTrace.Debug.SendTable("Stack ", windowStack);
// 5) Typed collection (implement ICollection)
Collection <Window> windowsCollection = new Collection <Window>();
for (int c = 0; c < 500; c++)
{
windowsCollection.Add(this);
}
TTrace.Debug.SendTable("window Collection", windowsCollection);
Collection <int> intCollection = new Collection <int>();
for (int c = 0; c < 500; c++)
{
intCollection.Add(c);
}
TTrace.Debug.SendTable("int Collection", intCollection);
// 6) create manually a table
TraceTable table = new TraceTable();
// add titles. Individual columns titles can be added or multiple columns , separated by tabs
table.AddColumnTitle("colA"); // first column title
table.AddColumnTitle("colB"); // second column title
table.AddColumnTitle("title column C\tcolD"); // other columns title (tab separated)
// add first line. Individual columns data can be added or multiple columns , separated by tabs
table.AddRow();
table.AddRowData("a"); // add first col
table.AddRowData("b" + "\t" + "c" + "\t" + "d" + "\t" + "e"); // then add other columns (tab separated)
// add second line
table.AddRow();
table.AddRowData("aa" + "\t" + "data second column" + "\t" + "cc" + "\t" + "dd" + "\t" + "ee"); // add all columns data in a single step (tab separated)
// finally send the table
TTrace.Debug.SendTable("Mytable", table);
// ensure all traces are send to the viewer
TTrace.Flush();
}
public override bool MoveToFirstChild()
{
if (this.current == null)
{
throw new InvalidOperationException();
}
bool flag = false;
if ((this.CurrentElement.childNodes != null) && (this.CurrentElement.childNodes.Count > 0))
{
this.current = this.CurrentElement.childNodes[0];
this.state = this.current.NodeType;
return true;
}
if (((this.CurrentElement.childNodes == null) || (this.CurrentElement.childNodes.Count == 0)) && (this.CurrentElement.text != null))
{
this.state = XPathNodeType.Text;
this.CurrentElement.movedToText = true;
flag = true;
}
return flag;
}
public override bool MoveToNext()
{
if (this.current == null)
{
throw new InvalidOperationException();
}
bool flag = false;
if (this.state != XPathNodeType.Text)
{
ElementNode parent = this.current.parent;
if (parent == null)
{
return flag;
}
TraceNode node2 = parent.MoveToNext();
if (((node2 == null) && (parent.text != null)) && !parent.movedToText)
{
this.state = XPathNodeType.Text;
parent.movedToText = true;
this.current = parent;
return true;
}
if (node2 != null)
{
this.state = node2.NodeType;
flag = true;
this.current = node2;
}
}
return flag;
}
public override bool MoveToParent()
{
if (this.current == null)
{
throw new InvalidOperationException();
}
bool flag = false;
switch (this.state)
{
case XPathNodeType.Element:
case XPathNodeType.ProcessingInstruction:
case XPathNodeType.Comment:
if (this.current.parent != null)
{
this.current = this.current.parent;
this.state = this.current.NodeType;
flag = true;
}
return flag;
case XPathNodeType.Attribute:
this.state = XPathNodeType.Element;
return true;
case XPathNodeType.Namespace:
this.state = XPathNodeType.Element;
return true;
case XPathNodeType.Text:
this.state = XPathNodeType.Element;
return true;
case XPathNodeType.SignificantWhitespace:
case XPathNodeType.Whitespace:
return flag;
}
return flag;
}
public override void MoveToRoot()
{
this.current = this.root;
this.state = XPathNodeType.Element;
this.root.Reset();
}
internal void Add(TraceNode node)
{
this.childNodes.Add(node);
}
internal void CloseElement()
{
if (this.closed)
{
throw new InvalidOperationException();
}
this.current = this.CurrentElement.parent;
if (this.current == null)
{
this.closed = true;
}
}
internal void AddElement(string prefix, string name, string xmlns)
{
if (this.closed)
{
#pragma warning disable 618
Fx.Assert("Cannot add data to a closed document");
#pragma warning restore 618
throw new InvalidOperationException();
}
else
{
ElementNode node = new ElementNode(name, prefix, this.CurrentElement, xmlns);
if (this.current == null)
{
this.VerifySize(node);
this.root = node;
this.current = this.root;
}
else if (!this.closed)
{
this.VerifySize(node);
this.CurrentElement.Add(node);
this.current = node;
}
}
}
public override void MoveToRoot()
{
this.current = this.root;
this.state = XPathNodeType.Element;
this.root.Reset();
}
//--------------------------------------------------------
private void butTrace_Click(object sender, EventArgs e)
{
TTrace.Options.SendProcessName = chkSendProcessName.Checked;
string str = '\u2250' + "qwerty & @ € é ù è azerty" + '\u9999';
// simple traces
//--------------------------------------------
TTrace.Debug.Send("Hello").Send("World"); // "World" is a sub trace of "Hello"
// single separator
TTrace.Debug.Send("---");
// send traces with special font style (bold and Italic), color font size and font name
TTrace.Debug.Send("Special font", "Symbol 12")
.SetFontDetail(-1, false, true) // set whole line to italic
.SetFontDetail(3, true, false, Color.Red.ToArgb()) // set col 3 (Left Msg) to bold and Red
.SetFontDetail(4, false, false, Color.Green.ToArgb(), 12, "Symbol"); // set col 4 (Right Msg) to Green , font size 12 , Symbol
TTrace.Debug.Send("Impact Italic")
.SetFontDetail(3, false, true, Color.BlueViolet.ToArgb(), 12, "Impact"); // Col3 (left msg), non bold, Italic , Blue-Violet , font 12 , Impact
TTrace.Debug.Send("Special chars", "€ é ù è $ ");
// The characters to encode:
// Latin Small Letter Z (U+007A)
// Latin Small Letter A (U+0061)
// Combining Breve (U+0306)
// Latin Small Letter AE With Acute (U+01FD)
// Greek Small Letter Beta (U+03B2)
// a high-surrogate value (U+D8FF)
// a low-surrogate value (U+DCFF)
//char[] myChars = new char[] { 'z', 'a', '\u0306', '\u01FD', '\u03B2', '\uD8FF', '\uDCFF' };
//TTrace.Debug.Send("Other Special chars", new StringBuilder().Append(myChars).ToString()); // myChars.ToString() return "char[]"
// double separator
TTrace.Debug.Send("===");
//TTrace.Options.SendThreadId = false ;
//TTrace.Debug.Send("trace without thread id");
//TTrace.Options.SendThreadId = true;
//TTrace.Options.SendDate = true;
//TTrace.Debug.Send("trace with date");
//TTrace.Options.SendDate = false;
// traces using Sendxxx method
//--------------------------------------------
// Use default display filter. (see TTrace.Options)
TTrace.Debug.SendType("Object base type", typeof(Object));
TTrace.Debug.SendType("My interface", typeof(Myinterface));
TTrace.Debug.SendObject("My const", TraceConst.CST_CREATE_MEMBER);
TTrace.Debug.SendObject("My enum", testClass.fieldDay);
TTrace.Debug.SendCaller("SendCaller test", 0);
TTrace.Debug.SendStack("Stack test", 0);
TTrace.Debug.SendDump("SendDump test", "Unicode", Encoding.Unicode.GetBytes(str), 50);
TTrace.Warning.SendType("SendType 'testClass'", testClass.GetType());
// specify what to send (modifiers, fields, ...). Can be slow on complexe objects
TraceDisplayFlags flags = TraceDisplayFlags.ShowModifiers |
TraceDisplayFlags.ShowInheritedMembers |
TraceDisplayFlags.ShowNonPublic |
TraceDisplayFlags.ShowFields;
if (chkSendFunctions.Checked)
flags |= TraceDisplayFlags.ShowMethods;
TTrace.Error.SendObject("SendObject 'testClass'", testClass, flags);
// traces using TraceNodeEx
//--------------------------------------------
TraceNodeEx node = new TraceNodeEx(null); // TTrace.Debug
node.LeftMsg = "TraceNodeEx";
node.RightMsg = str;
node.AddFontDetail(3, false, false, Color.Green.ToArgb());
node.IconIndex = 8;
node.Members.Add("My Members", "col2", "col3")
.SetFontDetail(0, true) // set first column to bold
.SetFontDetail(1, false, false, Color.Green.ToArgb()) // set second column to green
.Add("Sub members") // add sub member node
.SetFontDetail(0, false, true); // set first column to Italic
node.AddDump("ASCII", Encoding.ASCII.GetBytes(str), 50); // 3F 61 7A ..... 3F
node.AddDump("UTF8", Encoding.UTF8.GetBytes(str), 50);
node.AddDump("Unicode", Encoding.Unicode.GetBytes(str), 50); // 50 22 61 00 7A 00 ..... 99 99
node.AddStackTrace(0);
node.AddCaller();
TraceNode sendNode = node.Send();
sendNode.ResendIconIndex(5); // change icon index after the node is send
// XML sample using Send
//--------------------------------------------
TTrace.Debug.SendXml("xml", "<?xml version='1.0' ?><Data> Hello XML </Data>");
// Image sample using Send
//--------------------------------------------
TTrace.Debug.SendBitmap("Bitmap", pictureBox1.Image);
// Text, image and XML together
//--------------------------------------------
node = new TraceNodeEx(TTrace.Debug);
node.LeftMsg = "Text, image and XML together";
node.Members.Add("Text displayed in detail");
node.AddBitmap(pictureBox1.Image);
node.AddXML("<?xml version='1.0' ?><Data> Xml in traceNodeEx </Data>");
node.Send();
// send table detail
//--------------------------------------------
// create the table
TraceTable table = new TraceTable();
// add titles. Individual columns titles can be added or multiple columns , separated by tabs
table.AddColumnTitle("colA"); // first column title
table.AddColumnTitle("colB"); // second column title
table.AddColumnTitle("title column C\tcolD"); // other columns title (tab separated)
// add first line. Individual columns data can be added or multiple columns , separated by tabs
table.AddRow();
table.AddRowData("a"); // add first col
table.AddRowData("b" + "\t" + "c" + "\t" + "d" + "\t" + "e"); // then add other columns (tab separated)
// add second line
table.AddRow();
table.AddRowData("aa" + "\t" + "data second column" + "\t" + "cc" + "\t" + "dd" + "\t" + "ee"); // add all columns data in a single step (tab separated)
// finally send the table
TTrace.Debug.SendTable("Mytable", table);
ParsedObjectList objList = new ParsedObjectList() ;
objList.Add (testClass) ;
objList.Add (test2) ;
TTrace.Debug.SendTable("Generic table",objList );
List<int> intCollection = new List<int>();
for (int c = 0; c < 500; c++)
intCollection.Add(c);
TTrace.Debug.SendTable("int Collection", intCollection);
// group of traces enabled / disabled
TraceNode databinding = new TraceNode(null, false);
databinding.IconIndex = 5;
databinding.Enabled = true;
databinding.Send("databing traces 1");
databinding.Enabled = false;
databinding.Send("databing traces 2");
// ensure all traces are send to the viewer
TTrace.Flush();
}
//------------------------------------------------------------------------------
private void butStart1_Click(object sender, RoutedEventArgs e)
{
_start1 = TTrace.Debug.Send("Start 1 ..");
ButDone1.IsEnabled = true;
ButSetSelected.IsEnabled = true;
}
public override bool MoveToParent()
{
if (this.current == null)
{
#pragma warning disable 618
Fx.Assert("Operation is invalid on an empty document");
#pragma warning restore 618
throw new InvalidOperationException();
}
bool retval = false;
switch (this.state)
{
case XPathNodeType.Comment:
case XPathNodeType.Element:
case XPathNodeType.ProcessingInstruction:
if (this.current.parent != null)
{
this.current = this.current.parent;
this.state = this.current.NodeType;
retval = true;
}
break;
case XPathNodeType.Attribute:
this.state = XPathNodeType.Element;
retval = true;
break;
case XPathNodeType.Text:
this.state = XPathNodeType.Element;
retval = true;
break;
case XPathNodeType.Namespace:
this.state = XPathNodeType.Element;
retval = true;
break;
}
return retval;
}
//--------------------------------------------------------
private void butstart2_Click(object sender, EventArgs e)
{
start2 = TTrace.Debug.Send("Start 2 ..");
butEnd2.Enabled = true;
butShowNode.Enabled = true;
butToggleBookmark.Enabled = true;
butToggleVisible.Enabled = true;
}
