public Appearance(LogFontSize fontSize, string fontFamily, ColoringMode coloring, PaletteBrightness coloringBrightness)
{
this.FontSize = fontSize;
this.FontFamily = fontFamily;
this.Coloring = coloring;
this.ColoringBrightness = coloringBrightness;
}
static ImmutableArray <IViewItem> CreateViewItems(
IEnumerable <IBookmark> bookmarks,
IImmutableSet <IBookmark> selected,
ImmutableArray <Color> threadColors,
ColoringMode coloring
)
{
var resultBuilder = ImmutableArray.CreateBuilder <IViewItem>();
DateTime?prevTimestamp = null;
DateTime?prevSelectedTimestamp = null;
bool multiSelection = selected.Count >= 2;
int index = 0;
foreach (IBookmark bmk in bookmarks)
{
var ts = bmk.Time.ToUniversalTime();
var ls = bmk.GetLogSource();
var isEnabled = ls != null && ls.Visible;
var isSelected = selected.Contains(bmk);
var deltaBase = multiSelection ? (isSelected ? prevSelectedTimestamp : null) : prevTimestamp;
var delta = deltaBase != null ? ts - deltaBase.Value : new TimeSpan?();
var altDelta = prevTimestamp != null ? ts - prevTimestamp.Value : new TimeSpan?();
int?colorIndex = null;
var thread = bmk.Thread;
if (coloring == Settings.Appearance.ColoringMode.Threads)
{
if (!thread.IsDisposed)
{
colorIndex = thread.ThreadColorIndex;
}
}
if (coloring == Settings.Appearance.ColoringMode.Sources)
{
if (!thread.IsDisposed && !thread.LogSource.IsDisposed)
{
colorIndex = thread.LogSource.ColorIndex;
}
}
resultBuilder.Add(new ViewItem()
{
bookmark = bmk,
key = bmk.GetHashCode().ToString(),
text = bmk.ToString(),
delta = TimeUtils.TimeDeltaToString(delta),
altDelta = TimeUtils.TimeDeltaToString(altDelta),
isSelected = isSelected,
isEnabled = isEnabled,
contextColor = threadColors.GetByIndex(colorIndex),
index = index
});
prevTimestamp = ts;
if (isSelected)
{
prevSelectedTimestamp = ts;
}
++index;
}
return(resultBuilder.ToImmutable());
}
private static Color CharacterizeBlock(byte[] block, ColoringMode coloringMode)
{
return(Color.FromArgb(
coloringMode.Red(block),
coloringMode.Green(block),
coloringMode.Blue(block)
));
}
public static Color Colorize(this Color originalColor, Color targetColor, ColoringMode coloringMode, float lerpAmount = 1.0f)
{
Color resultColor;
switch (coloringMode)
{
case ColoringMode.Tint:
{
float s_h, s_s, s_v, t_h, t_s, t_v;
Color.RGBToHSV(originalColor, out s_h, out s_s, out s_v);
Color.RGBToHSV(targetColor, out t_h, out t_s, out t_v);
resultColor = Color.HSVToRGB(t_h, t_s, s_v * t_v);
resultColor.a = originalColor.a * targetColor.a;
}
break;
case ColoringMode.Multiply:
resultColor = originalColor * targetColor;
break;
case ColoringMode.Replace:
resultColor = targetColor;
break;
case ColoringMode.ReplaceKeepAlpha:
resultColor = targetColor;
resultColor.a = originalColor.a;
break;
case ColoringMode.Add:
resultColor = originalColor + targetColor;
break;
default:
throw new ArgumentOutOfRangeException(nameof(coloringMode), coloringMode.ToString("G"), null);
}
return(Color.Lerp(originalColor, resultColor, lerpAmount));
}
public static Color MMColorize(this Color originalColor, Color targetColor, ColoringMode coloringMode, float lerpAmount = 1.0f)
{
Color resultColor = Color.white;
switch (coloringMode)
{
case ColoringMode.Tint:
{
float s_h, s_s, s_v, t_h, t_s, t_v;
Color.RGBToHSV(originalColor, out s_h, out s_s, out s_v);
Color.RGBToHSV(targetColor, out t_h, out t_s, out t_v);
resultColor = Color.HSVToRGB(t_h, t_s, s_v * t_v);
resultColor.a = originalColor.a * targetColor.a;
}
break;
case ColoringMode.Multiply:
resultColor = originalColor * targetColor;
break;
case ColoringMode.Replace:
resultColor = targetColor;
break;
case ColoringMode.ReplaceKeepAlpha:
resultColor = targetColor;
resultColor.a = originalColor.a;
break;
case ColoringMode.Add:
resultColor = originalColor + targetColor;
break;
default:
break;
}
return(Color.Lerp(originalColor, resultColor, lerpAmount));
}
private void RenderPathCustomColors(PathRule pathRule, ColoringMode coloringMode, MapColorPalette palette, Color fromColor, Color middleColor, Color toColor)
{
pathRule.UseCustomColors = true;
SetRuleColors(pathRule.GetColors(coloringMode, palette, fromColor, middleColor, toColor, GetBucketCount()), pathRule.CustomColors);
}
private void RenderShapeCustomColors(ShapeRule shapeRule, ColoringMode coloringMode, MapColorPalette palette, Color fromColor, Color middleColor, Color toColor)
{
shapeRule.UseCustomColors = true;
SetRuleColors(shapeRule.GetColors(coloringMode, palette, fromColor, middleColor, toColor, GetBucketCount()), shapeRule.CustomColors);
}
internal Color[] GetColors(ColoringMode coloringMode, MapColorPalette colorPalette, Color startColor, Color middleColor, Color endColor, int colorCount)
{
if (colorCount == 0)
{
return(null);
}
if (coloringMode == ColoringMode.DistinctColors)
{
return(new ColorGenerator().GenerateColors(colorPalette, colorCount));
}
switch (colorCount)
{
case 1:
return(new Color[1]
{
startColor
});
case 2:
return(new Color[2]
{
startColor,
endColor
});
default:
{
bool flag = middleColor.A == 0;
byte a = startColor.A;
_ = middleColor.A;
byte a2 = endColor.A;
startColor = Color.FromArgb(255, startColor);
middleColor = Color.FromArgb(255, middleColor);
endColor = Color.FromArgb(255, endColor);
Color[] array = new Color[colorCount];
array[0] = startColor;
array[colorCount - 1] = endColor;
Rectangle rect = new Rectangle(0, 0, colorCount, 1);
if (colorCount % 2 == 1)
{
rect.Width--;
}
Bitmap bitmap = new Bitmap(colorCount, 1);
using (LinearGradientBrush linearGradientBrush = new LinearGradientBrush(rect, startColor, endColor, 0f, isAngleScaleable: false))
{
ColorBlend colorBlend = new ColorBlend();
if (flag)
{
colorBlend.Positions = new float[2]
{
0f,
1f
};
colorBlend.Colors = new Color[2]
{
startColor,
endColor
};
}
else
{
colorBlend.Positions = new float[3]
{
0f,
0.5f,
1f
};
colorBlend.Colors = new Color[3]
{
startColor,
middleColor,
endColor
};
}
linearGradientBrush.InterpolationColors = colorBlend;
using (Graphics graphics = Graphics.FromImage(bitmap))
{
graphics.FillRectangle(linearGradientBrush, rect);
}
}
float num = (a2 - a) / (colorCount - 1);
float num2 = (int)a;
for (int i = 1; i < colorCount - 1; i++)
{
num2 += num;
Color pixel = bitmap.GetPixel(i, 0);
array[i] = Color.FromArgb((int)num2, pixel);
}
return(array);
}
}
}
/// <summary>
/// Creates a memsquare from a file.
/// </summary>
/// <param name="worker">The background worker the function is running on, or null if it isn't</param>
/// <param name="fileData">The file to create the memsquare of</param>
/// <param name="blockSize">Size of each block in bytes</param>
/// <param name="coloringMode">Method in which to color each pixel based on the block</param>
/// <returns>A memsquare based on the file</returns>
public static Bitmap Generate(BackgroundWorker worker, byte[] fileData, int blockSize, ColoringMode coloringMode)
{
int fileSize = fileData.Length;
// Side length of square must be a power of two for the Hilbert curve,
// so therefore to maintain a square the number of blocks must be a square
// number.
int blockCount = GetBlockCount(fileSize, blockSize);
int sideLength = GetSideLength(fileSize, blockSize);
Bitmap memsquare = new Bitmap(sideLength, sideLength);
for (int i = 0; i < blockCount; ++i)
{
if (worker != null && worker.CancellationPending)
{
memsquare.Dispose();
return(null);
}
byte[] block = GetBlock(fileData, i, blockSize);
Color c = CharacterizeBlock(block, coloringMode);
Tuple <int, int> position = Utility.HilbertDToXY(sideLength, i);
memsquare.SetPixel(position.Item1, position.Item2, c);
double percentage = (i + 1) / (double)blockCount * 100.0;
// Don't report the percentage too often - otherwise the UI locks up entirely
if (worker != null && i % (blockCount / 1000) == 0)
{
worker.ReportProgress((int)percentage);
}
}
// As we only report every so often, 100% doesn't usually get reported.
// Just do it now so everything looks good.
if (worker != null)
{
worker.ReportProgress(100);
}
return(memsquare);
}
