private void UpdateChart()
{
chartTagDetails.SuspendLayout();
string[] keys;
long[] values;
string tooltip;
Color[] colors;
if (comboBoxTagStatisticsType.SelectedIndex == 0)
{
keys = _bytag.Select(p => p.Key).ToArray();
values = _bytag.Select(p => p.Value.LongCount()).ToArray();
colors = _bytag.Select(p => ColorValueConverter.ToColor(p.Value.First().Color)).ToArray();
tooltip = Properties.Resources.TagStatisticsChartControl_CountToolTip;
}
else
{
keys = _bytag.Select(p => p.Key).ToArray();
values = _bytag.Select(p => p.Value.Sum(x => x.Length)).ToArray();
colors = _bytag.Select(p => ColorValueConverter.ToColor(p.Value.First().Color)).ToArray();
tooltip = Properties.Resources.TagStatisticsChartControl_ByteCountToolTip;
}
chartTagDetails.Series["Tags"].Points.DataBindXY(keys, values);
chartTagDetails.Series["Tags"].ToolTip = tooltip;
chartTagDetails.Series["Tags"].IsValueShownAsLabel = true;
for (int i = 0; i < chartTagDetails.Series["Tags"].Points.Count; ++i)
{
chartTagDetails.Series["Tags"].Points[i].Color = colors[i];
}
chartTagDetails.ResumeLayout();
}
private void UpdatePacketDisplay()
{
LogPacket p = GetCurrentPacket();
if (p == null)
{
return;
}
if (!_newStyleLogViewer)
{
frameEditorControl.ReadOnly = ReadOnly;
}
frameEditorControl.SetFrame(p.Frame, null, ColorValueConverter.ToColor(p.Color));
if (p.Frame.IsBasic || (ReadOnly && !_newStyleLogViewer))
{
toolStripButtonConvertToBytes.Enabled = false;
}
else
{
toolStripButtonConvertToBytes.Enabled = true;
}
if (_newStyleLogViewer)
{
toolStripButtonSave.Enabled = IsFrameModified();
toolStripButtonRevert.Enabled = IsFrameModified();
}
toolStripLabelPosition.Text = String.Format(CANAPE.Properties.Resources.PacketLogViewerForm_Header, _index + 1,
_packets.Count, p.Tag, p.Network, p.Timestamp.ToString());
}
void Graph_EditPacketEvent(object sender, EditPacketEventArgs e)
{
if (InvokeRequired)
{
Invoke(new EventHandler <EditPacketEventArgs>(Graph_EditPacketEvent), sender, e);
}
else
{
using (EditPacketForm frm = new EditPacketForm())
{
frm.Frame = e.Frame;
frm.Selector = e.SelectPath;
frm.DisplayColor = ColorValueConverter.ToColor(e.Color);
frm.DisplayTag = e.Tag;
frm.ShowDisableEditor = true;
frm.ShowReadOnly = true;
if (frm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
e.Frame = frm.Frame;
}
if (frm.DisableEditor)
{
if (e.Sender != null)
{
e.Sender.Enabled = false;
}
}
}
}
}
public override void PaintValue(PaintValueEventArgs e)
{
if (e.Value is ColorValue)
{
using (Brush brush = new SolidBrush(ColorValueConverter.ToColor((ColorValue)e.Value)))
{
e.Graphics.FillRectangle(brush, e.Bounds);
}
}
}
void ExtractTheColors(Color colorName)
{
try
{
// Store color in PictureBox
panelPreviewer.BackColor = colorName;
// Store to textboxes
textBoxRed.Text = colorName.R.ToString();
textBoxGreen.Text = colorName.G.ToString();
textBoxBlue.Text = colorName.B.ToString();
// Convert to HEX
textBoxHex.Text = ColorValueConverter.RGBToHex(colorName);
textBoxRGB.Text = ColorValueConverter.toRGBA(colorName);
// HSL
textBoxHSL.Text = ColorValueConverter.RGBToHSL(colorName);
string HSLAsArray = ColorValueConverter.RGBToHSL(colorName, false, true);
string[] hslarray = HSLAsArray.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
textBoxHue.Text = hslarray[0];
textBoxSaturation.Text = hslarray[1];
textBoxLuminance.Text = hslarray[2];
// KnownColor
textBoxColorName.Text = ColorValueConverter.ColorToKnownColor(colorName);
// Save the Color to Settings
Properties.Settings.Default.LastColor = colorName;
// Populate Pallette
panelPalletteLightestColor.BackColor = ColorValueConverter.ColorAdjust(colorName, (float)0.60); //ControlPaint.Light(colorName, (Single)1.5);
panelPalletteLighterColor.BackColor = ColorValueConverter.ColorAdjust(colorName, (float)0.30); //ControlPaint.Light(colorName, (Single)1.01);
panelPalletteNormalColor.BackColor = ColorValueConverter.ColorAdjust(colorName, (float)0);; // 0F
panelPalletteDarkerColor.BackColor = ColorValueConverter.ColorAdjust(colorName, (float)-0.30); //ControlPaint.Dark(colorName, 0.01F);
panelPalletteDarkestColor.BackColor = ColorValueConverter.ColorAdjust(colorName, (float)-0.60); //ControlPaint.Dark(colorName, 0.05F);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message.ToString(), "Exception Error Occured", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
finally
{
// Copy to Clipboard
CopyToClipboard();
this.Text = Properties.Settings.Default.AppTitle + " - " + GetTheColorViaRadioButton(colorName).ToUpper();
}
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if ((value is ColorValue) && (provider != null))
{
IWindowsFormsEditorService service = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
if (service != null)
{
using (ColorDialog frm = new ColorDialog())
{
frm.Color = ColorValueConverter.ToColor((ColorValue)value);
if (frm.ShowDialog() == DialogResult.OK)
{
value = ColorValueConverter.FromColor(frm.Color);
}
}
}
}
return(value);
}
public String GetTheColorViaRadioButton(Color c)
{
String color = "";
var checkedRadioButton = Automaton.GetCheckedRadio(new List <RadioButton>(new RadioButton[] { radioButtonHex, radioButtonRGB, radioButtonHSL }));
var tag = checkedRadioButton.Tag.ToString();
switch (tag)
{
case "textBoxHex":
color = ColorValueConverter.RGBToHex(c);
break;
case "textBoxRGB":
color = ColorValueConverter.toRGBA(c);
break;
case "textBoxHSL":
color = ColorValueConverter.RGBToHSL(c);
break;
}
return(color);
}
EditPacketForm CreateEditor(EditPacketEventArgs e)
{
if (InvokeRequired)
{
return((EditPacketForm)Invoke(new Func <EditPacketEventArgs, EditPacketForm>(CreateEditor), e));
}
else
{
EditPacketForm frm = new EditPacketForm();
frm.Frame = e.Frame;
frm.Selector = e.SelectPath;
frm.DisplayColor = ColorValueConverter.ToColor(e.Color);
frm.DisplayTag = e.Tag;
frm.ShowDisableEditor = true;
frm.ShowReadOnly = true;
frm.Show();
frm.Activate();
return(frm);
}
}
/// <summary>
/// Initializes a new instance of the class.
/// </summary>
public VertexGradientValueConverter()
{
_type = typeof(VertexGradient);
_colorValueConverter = new ColorValueConverter();
}
private LogPacket[] CreatePacketFromSelection()
{
LogPacket[] ret = null;
try
{
if (hexBox.CanCopy())
{
long startPos = hexBox.SelectionStart;
long length = hexBox.SelectionLength;
if (startPos >= 0)
{
byte[] data = new byte[length];
for (long i = 0; i < length; ++i)
{
data[i] = _provider.ReadByte(startPos + i);
}
ret = new LogPacket[1];
ret[0] = new LogPacket("Hex", Guid.NewGuid(), "Hex Copy", new DataFrame(data), ColorValueConverter.FromColor(this.HexColor));
}
}
}
catch (ArgumentOutOfRangeException)
{
}
return(ret ?? new LogPacket[0]);
}
/// <summary>
/// Replaces BBCode style tags with unity rich text syntax and parses embedded views.
/// </summary>
public string ParseText(string text)
{
if (text == null)
{
return(String.Empty);
}
if (!TextComponent.supportRichText)
{
return(text);
}
string formattedText = string.Empty;
string separatorString = "&sp;";
// search for tokens and apply formatting and embedded views
List <TextToken> tokens = new List <TextToken>();
formattedText = _tagRegex.Replace(text, x =>
{
string tag = x.Groups["tag"].Value.Trim();
string tagNoWs = tag.RemoveWhitespace();
// check if tag matches default tokens
if (String.Equals("B", tagNoWs, StringComparison.OrdinalIgnoreCase))
{
// bold
tokens.Add(new TextToken {
TextTokenType = TextTokenType.BoldStart
});
return(separatorString);
}
else if (String.Equals("/B", tagNoWs, StringComparison.OrdinalIgnoreCase))
{
// bold end
tokens.Add(new TextToken {
TextTokenType = TextTokenType.BoldEnd
});
return(separatorString);
}
else if (String.Equals("I", tagNoWs, StringComparison.OrdinalIgnoreCase))
{
// italic
tokens.Add(new TextToken {
TextTokenType = TextTokenType.ItalicStart
});
return(separatorString);
}
else if (String.Equals("/I", tagNoWs, StringComparison.OrdinalIgnoreCase))
{
// italic end
tokens.Add(new TextToken {
TextTokenType = TextTokenType.ItalicEnd
});
return(separatorString);
}
else if (tagNoWs.StartsWith("SIZE=", StringComparison.OrdinalIgnoreCase))
{
// parse size value
var vc = new IntValueConverter();
var convertResult = vc.Convert(tagNoWs.Substring(5), ValueConverterContext.Empty);
if (!convertResult.Success)
{
// unable to parse token
Utils.LogError("[MarkLight] {0}: Unable to parse text embedded size tag \"[{1}]\". {2}", GameObjectName, tag, convertResult.ErrorMessage);
return(String.Format("[{0}]", tag));
}
tokens.Add(new TextToken {
TextTokenType = TextTokenType.SizeStart, FontSize = (int)convertResult.ConvertedValue
});
return(separatorString);
}
else if (String.Equals("/SIZE", tagNoWs, StringComparison.OrdinalIgnoreCase))
{
// size end
tokens.Add(new TextToken {
TextTokenType = TextTokenType.SizeEnd
});
return(separatorString);
}
else if (tagNoWs.StartsWith("COLOR=", StringComparison.OrdinalIgnoreCase))
{
// parse color value
var vc = new ColorValueConverter();
var convertResult = vc.Convert(tagNoWs.Substring(6), ValueConverterContext.Empty);
if (!convertResult.Success)
{
// unable to parse token
Utils.LogError("[MarkLight] {0}: Unable to parse text embedded color tag \"[{1}]\". {2}", GameObjectName, tag, convertResult.ErrorMessage);
return(String.Format("[{0}]", tag));
}
Color color = (Color)convertResult.ConvertedValue;
tokens.Add(new TextToken {
TextTokenType = TextTokenType.ColorStart, FontColor = color
});
return(separatorString);
}
else if (String.Equals("/COLOR", tagNoWs, StringComparison.OrdinalIgnoreCase))
{
// color end
tokens.Add(new TextToken {
TextTokenType = TextTokenType.ColorEnd
});
return(separatorString);
}
return(String.Format("[{0}]", tag));
});
// replace newline in string
formattedText = formattedText.Replace("\\n", Environment.NewLine);
// split the string up on each line
StringBuilder result = new StringBuilder();
var splitString = formattedText.Split(new string[] { separatorString }, StringSplitOptions.None);
int splitIndex = 0;
int fontBoldCount = 0;
int fontItalicCount = 0;
Stack <int> fontSizeStack = new Stack <int>();
// loop through each split string and apply tokens (embedded views & font styles)
foreach (var str in splitString)
{
int tokenIndex = splitIndex - 1;
var token = tokenIndex >= 0 && tokenIndex < tokens.Count ? tokens[tokenIndex] : null;
++splitIndex;
// do we have a token?
if (token != null)
{
// yes. parse token type
switch (token.TextTokenType)
{
case TextTokenType.BoldStart:
result.Append("<b>");
++fontBoldCount;
break;
case TextTokenType.BoldEnd:
result.Append("</b>");
--fontBoldCount;
break;
case TextTokenType.ItalicStart:
result.Append("<i>");
++fontItalicCount;
break;
case TextTokenType.ItalicEnd:
result.Append("</i>");
--fontItalicCount;
break;
case TextTokenType.SizeStart:
result.Append(String.Format("<size={0}>", token.FontSize));
fontSizeStack.Push(token.FontSize);
break;
case TextTokenType.SizeEnd:
result.Append("</size>");
fontSizeStack.Pop();
break;
case TextTokenType.ColorStart:
int r = (int)(token.FontColor.r * 255f);
int g = (int)(token.FontColor.g * 255f);
int b = (int)(token.FontColor.b * 255f);
int a = (int)(token.FontColor.a * 255f);
result.Append(String.Format("<color=#{0}{1}{2}{3}>", r.ToString("X2"), g.ToString("X2"), b.ToString("X2"), a.ToString("X2")));
break;
case TextTokenType.ColorEnd:
result.Append("</color>");
break;
case TextTokenType.Unknown:
default:
break;
}
}
result.Append(str);
}
return(result.ToString());
}
