CruncherSharpForm.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Windows.Forms;
using static System.Int32;

namespace CruncherSharp
{
    public partial class CruncherSharpForm : Form
    {
        public enum SearchType
        {
            None,
            UnusedVTables,
            MSVCExtraPadding,
            MSVCEmptyBaseClass,
            UnusedInterfaces,
            UnusedVirtual,
            MaskingFunction,
            RemovedInline,
        }

        private readonly List<string> _FunctionsToIgnore;
        private readonly Stack<SymbolInfo> _NavigationStack;
        private readonly SymbolAnalyzer _SymbolAnalyzer;
        private readonly DataTable _Table;
        public bool _CloseRequested;
        private string _FileName;
        public bool _HasInstancesCount;
        public bool _HasSecondPDB;
        private ulong _PrefetchStartOffset;
        private SearchType _SearchCategory = SearchType.None;

        private SymbolInfo _SelectedSymbol;

        public CruncherSharpForm(SymbolAnalyzer symbolAnalyzer)
        {
            InitializeComponent();

            _SymbolAnalyzer = symbolAnalyzer;
            _Table = CreateDataTable();
            _Table.CaseSensitive = checkBoxMatchCase.Checked;
            _NavigationStack = new Stack<SymbolInfo>();
            _FunctionsToIgnore = new List<string>();
            _SelectedSymbol = null;
            _PrefetchStartOffset = 0;

            bindingSourceSymbols.DataSource = _Table;
            dataGridSymbols.DataSource = bindingSourceSymbols;

            dataGridSymbols.Columns[0].Width = 271;

            WindowState = FormWindowState.Maximized;
        }

        public SearchType SearchCategory
        {
            get => _SearchCategory;
            private set
            {
                _SearchCategory = value;
                UpdateCheckedOption();
            }
        }

        private void Reset()
        {
            checkedListBoxNamespaces.Items.Clear();
            _Table.Clear();
            dataGridViewSymbolInfo.Rows.Clear();
            dataGridViewFunctionsInfo.Rows.Clear();
            _SelectedSymbol = null;
            labelCurrentSymbol.Text = "";
            _SymbolAnalyzer.Reset();
        }

        private void exitToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Close();
        }

        private void loadPDBToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (backgroundWorker.IsBusy)
                return;

            if (openPdbDialog.ShowDialog() != DialogResult.OK)
                return;

            _FileName = openPdbDialog.FileName;
            Text = "Cruncher# - " + _FileName;
            Reset();
            btnLoad.Enabled = true;
            btnReset.Enabled = true;
            textBoxFilter.Focus();
        }

        public void LoadPdb(string fileName, bool secondPDB)
        {
            _SelectedSymbol = null;
            toolStripProgressBar.Value = 0;
            toolStripStatusLabel.Text = "Loading PDB...";
            if (!secondPDB)
            {
                Text = "Cruncher# - " + fileName;
                if (textBoxFilter.Text.Length > 0)
                    Text += " Filter: " + textBoxFilter.Text;
            }

            var task = new LoadPDBTask
            {
                FileName = fileName,
                SecondPDB = secondPDB,
                Filter = textBoxFilter.Text,
                MatchCase = checkBoxMatchCase.Checked,
                WholeExpression = checkBoxMatchWholeExpression.Checked,
                UseRegularExpression = checkBoxRegularExpressions.Checked
            };
            backgroundWorker.RunWorkerAsync(task);
        }

        private static DataTable CreateDataTable()
        {
            var table = new DataTable("Symbols");
            table.Columns.Add(new DataColumn {ColumnName = "Symbol", ReadOnly = true});
            table.Columns.Add(new DataColumn
            {
                ColumnName = "Size",
                ReadOnly = true,
                DataType = Type.GetType("System.UInt32")
            });
            table.Columns.Add(new DataColumn
            {
                ColumnName = "Padding",
                ReadOnly = true,
                DataType = Type.GetType("System.UInt32")
            });
            table.Columns.Add(new DataColumn
            {
                ColumnName = "Padding zones",
                ReadOnly = true,
                DataType = Type.GetType("System.UInt32")
            });
            table.Columns.Add(new DataColumn
            {
                ColumnName = "Total padding",
                ReadOnly = true,
                DataType = Type.GetType("System.UInt32")
            });
            table.Columns.Add(new DataColumn
            {
                ColumnName = "Padding %",
                ReadOnly = true,
                DataType = Type.GetType("System.UInt32")
            });

            return table;
        }

        private void AddInstancesCount()
        {
            if (_HasInstancesCount)
                return;
            _HasInstancesCount = true;
            if (_HasSecondPDB)
                _Table.Columns.Add(new DataColumn
                {
                    ColumnName = "Total delta",
                    ReadOnly = true,
                    DataType = Type.GetType("System.Int32")
                });
            _Table.Columns.Add(new DataColumn
            {
                ColumnName = "Instances",
                ReadOnly = true,
                DataType = Type.GetType("System.UInt64")
            });
            _Table.Columns.Add(new DataColumn
            {
                ColumnName = "Total count",
                ReadOnly = true,
                DataType = Type.GetType("System.UInt64")
            });
            _Table.Columns.Add(new DataColumn
            {
                ColumnName = "Total size",
                ReadOnly = true,
                DataType = Type.GetType("System.UInt64")
            });
            _Table.Columns.Add(new DataColumn
            {
                ColumnName = "Total waste",
                ReadOnly = true,
                DataType = Type.GetType("System.UInt64")
            });
        }

        private void AddSecondPDB()
        {
            if (_HasSecondPDB)
                return;
            _HasSecondPDB = true;
            _Table.Columns.Add(new DataColumn
            {
                ColumnName = "New size",
                ReadOnly = true,
                DataType = Type.GetType("System.UInt32")
            });
            _Table.Columns.Add(new DataColumn
            {
                ColumnName = "Delta",
                ReadOnly = true,
                DataType = Type.GetType("System.Int32")
            });
            if (_HasInstancesCount)
                _Table.Columns.Add(new DataColumn
                {
                    ColumnName = "Total delta",
                    ReadOnly = true,
                    DataType = Type.GetType("System.Int32")
                });
        }

        private void AddSymbolToTable(SymbolInfo symbolInfo)
        {
            var row = _Table.NewRow();

            row["Symbol"] = symbolInfo.Name;
            row["Size"] = symbolInfo.Size;
            row["Padding"] = symbolInfo.Padding;
            row["Padding zones"] = symbolInfo.PaddingZonesCount;
            row["Total padding"] = symbolInfo.TotalPadding.Value;
            row["Padding %"] = (uint) ((double) symbolInfo.TotalPadding.Value / symbolInfo.Size * 100);
            if (_HasInstancesCount)
            {
                row["Instances"] = symbolInfo.NumInstances;
                row["Total count"] = symbolInfo.TotalCount;
                row["Total size"] = symbolInfo.TotalCount * symbolInfo.Size;
                row["Total waste"] = symbolInfo.TotalCount * symbolInfo.Padding;
            }

            if (_HasSecondPDB)
            {
                row["New size"] = symbolInfo.NewSize;
                row["Delta"] = (long) symbolInfo.NewSize - (long) symbolInfo.Size;
                if (_HasInstancesCount && symbolInfo.NumInstances > 0)
                    row["Total delta"] = ((long) symbolInfo.NewSize - (long) symbolInfo.Size) *
                                         (long) symbolInfo.NumInstances;
            }

            _Table.Rows.Add(row);
        }


        private ulong GetCacheLineSize()
        {
            return Convert.ToUInt32(textBoxCache.Text);
        }

        private SymbolInfo FindSelectedSymbolInfo()
        {
            if (dataGridSymbols.SelectedRows.Count == 0) return null;

            var selectedRow = dataGridSymbols.SelectedRows[0];
            var symbolName = selectedRow.Cells[0].Value.ToString();
            return _SymbolAnalyzer.FindSymbolInfo(symbolName);
        }

        private string GetFilterString()
        {
            var filters = new List<string>();
            if (textBoxFilter.Text.Length > 0)
                if (checkBoxMatchWholeExpression.Checked)
                    filters.Add($"Symbol = '{textBoxFilter.Text.Replace("'", string.Empty)}'");
                else if (checkBoxRegularExpressions.Checked)
                    filters.Add($"Symbol LIKE '{textBoxFilter.Text.Replace("'", string.Empty)}'");
                else
                    filters.Add($"Symbol LIKE '*{textBoxFilter.Text.Replace("'", string.Empty)}*'");
            if (!chkShowTemplates.Checked)
                filters.Add("Symbol NOT LIKE '*<*'");
            if (checkedListBoxNamespaces.CheckedItems.Count > 0)
            {
                var namespaceFilters = checkedListBoxNamespaces.CheckedItems.Cast<string>()
                    .Select(item => $"Symbol LIKE '*{item.Replace("'", string.Empty)}::*'");
                filters.Add($"({string.Join(" OR ", namespaceFilters)})");
            }

            return string.Join(" AND ", filters);
        }

        private void dataGridSymbols_SelectionChanged(object sender, EventArgs e)
        {
            _PrefetchStartOffset = 0;
            if (dataGridSymbols.SelectedRows.Count > 1)
                ShowSelectionSummary();
            else
                ShowSelectedSymbolInfo();
        }

        private void dataGridSymbols_ParentSelected(object sender, EventArgs e)
        {
            dataGridSymbols.ClearSelection();
            if (TrySelectSymbol(sender.ToString()) == false)
            {
                var symbolInfo = _SymbolAnalyzer.FindSymbolInfo(sender.ToString());
                if (symbolInfo != null)
                    ShowSymbolInfo(symbolInfo, true);
            }
        }

        private void dataGridSymbols_CellMouseDoubleClick(object sender, DataGridViewCellMouseEventArgs e)
        {
            _PrefetchStartOffset = 0;
            ShowSelectedSymbolInfo();
        }

        private void ShowSelectionSummary()
        {
            dataGridViewSymbolInfo.Rows.Clear();

            ulong totalMemory = 0;
            ulong totalWaste = 0;
            long totalDiff = 0;
            foreach (DataGridViewRow selectedRow in dataGridSymbols.SelectedRows)
            {
                var symbolName = selectedRow.Cells[0].Value.ToString();
                var symbolInfo = _SymbolAnalyzer.FindSymbolInfo(symbolName);

                if (_HasInstancesCount)
                {
                    totalMemory += symbolInfo.NumInstances * symbolInfo.Size;
                    totalWaste += symbolInfo.NumInstances * symbolInfo.TotalPadding.Value;
                    if (_HasSecondPDB)
                        totalDiff += ((long) symbolInfo.NewSize - (long) symbolInfo.Size) *
                                     (long) symbolInfo.NumInstances;
                }
                else
                {
                    totalMemory += symbolInfo.Size;
                    totalWaste += symbolInfo.TotalPadding.Value;
                }
            }

            labelCurrentSymbol.Text = "Total memory: " + totalMemory + "    total waste: " + totalWaste;
            if (_HasInstancesCount && _HasSecondPDB)
                labelCurrentSymbol.Text += "    total diff: " + totalDiff;
        }

        private void ShowSelectedSymbolInfo()
        {
            dataGridViewSymbolInfo.Rows.Clear();
            var info = FindSelectedSymbolInfo();
            if (info != null) ShowSymbolInfo(info, false);
        }

        private bool TrySelectSymbol(string name)
        {
            foreach (DataGridViewRow dr in dataGridSymbols.Rows)
            {
                var dc = dr.Cells[0]; // name
                if (dc.Value.ToString() != name)
                    continue;
                dataGridSymbols.CurrentCell = dc;
                return true;
            }

            return false;
        }

        private void ShowSymbolInfo(SymbolInfo info, bool addToStack)
        {
            labelCurrentSymbol.Text = info.Name;

            if (_SelectedSymbol != null && addToStack)
                _NavigationStack.Push(_SelectedSymbol);
            else if (!addToStack) _NavigationStack.Clear();
            _SelectedSymbol = info;

            UpdateSymbolGrid();
        }

        private void UpdateSymbolGrid()
        {
            dataGridViewSymbolInfo.Rows.Clear();
            dataGridViewFunctionsInfo.Rows.Clear();

            var prevCacheBoundaryOffset = _PrefetchStartOffset;

            if (prevCacheBoundaryOffset > _SelectedSymbol.Size) prevCacheBoundaryOffset = _SelectedSymbol.Size;

            ulong numCacheLines = 0;
            var increment = 0;

            AddSymbolToGrid(_SelectedSymbol, ref prevCacheBoundaryOffset, ref numCacheLines, 0, increment);
        }

        private void RefreshSymbolGrid(int rowIndex)
        {
            var firstRow = dataGridViewSymbolInfo.FirstDisplayedScrollingRowIndex;
            UpdateSymbolGrid();
            dataGridViewSymbolInfo.Rows[rowIndex].Selected = true;
            dataGridViewSymbolInfo.FirstDisplayedScrollingRowIndex = firstRow;
        }

        private void AddSymbolToGrid(SymbolInfo symbol, ref ulong prevCacheBoundaryOffset, ref ulong numCacheLines,
            ulong previousOffset, int increment)
        {
            var cacheLineSize = GetCacheLineSize();

            var incrementText = "";
            var incrementTextEmpty = "";

            var whitespaceIncrementText = "";
            for (var i = 0; i < increment; i++)
            {
                whitespaceIncrementText += "   ";
                if (i == increment - 1)
                    incrementText += "   |__  ";
                else
                    incrementText += "   |    ";
                incrementTextEmpty += "   |    ";
            }

            foreach (var member in symbol.Members)
            {
                var currentOffset = previousOffset + member.Offset;
                if (member.PaddingBefore > 0 && checkBoxPadding.Checked)
                {
                    var paddingOffset = member.Offset - member.PaddingBefore;
                    string[] paddingRow =
                    {
                        string.Empty,
                        incrementTextEmpty,
                        "Padding",
                        paddingOffset.ToString(),
                        string.Empty,
                        member.PaddingBefore.ToString(),
                        string.Empty
                    };
                    dataGridViewSymbolInfo.Rows.Add(paddingRow);
                }

                if (checkBoxCacheLines.Checked)
                {
                    var cacheLines = new List<ulong>();
                    while (currentOffset >= cacheLineSize + prevCacheBoundaryOffset)
                    {
                        numCacheLines++;
                        var cacheLineOffset = numCacheLines * cacheLineSize + _PrefetchStartOffset;
                        cacheLines.Add(cacheLineOffset);
                        prevCacheBoundaryOffset = cacheLineOffset;
                    }

                    if (cacheLines.Count > 3 && chkSmartCacheLines.Checked)
                    {
                        string[] firstBoundaryRow =
                        {
                            string.Empty, incrementTextEmpty, "Cacheline boundary", cacheLines[0].ToString(),
                            string.Empty, string.Empty, string.Empty
                        };
                        dataGridViewSymbolInfo.Rows.Add(firstBoundaryRow);
                        string[] middleBoundariesRow =
                        {
                            string.Empty, incrementTextEmpty, "Cacheline boundaries (...)", string.Empty,
                            string.Empty, string.Empty, string.Empty
                        };
                        dataGridViewSymbolInfo.Rows.Add(middleBoundariesRow);
                        string[] lastBoundaryRow =
                        {
                            string.Empty, incrementTextEmpty, "Cacheline boundary",
                            cacheLines[cacheLines.Count - 1].ToString(), string.Empty, string.Empty, string.Empty
                        };
                        dataGridViewSymbolInfo.Rows.Add(lastBoundaryRow);
                    }
                    else
                    {
                        cacheLines.ForEach(offset =>
                        {
                            string[] boundaryRow =
                            {
                                string.Empty,
                                incrementTextEmpty,
                                "Cacheline boundary",
                                offset.ToString(),
                                string.Empty,
                                string.Empty
                            };
                            dataGridViewSymbolInfo.Rows.Add(boundaryRow);
                        });
                    }
                }

                var baseInfo = _SymbolAnalyzer.FindSymbolInfo(member.TypeName);
                var expand = "";
                if (member.Expanded)
                    expand = whitespaceIncrementText + "- ";
                else if (member.IsExapandable)
                    expand = whitespaceIncrementText + "+ ";

                object[] row =
                {
                    expand,
                    incrementText + member.DisplayName,
                    member.TypeName,
                    currentOffset.ToString(),
                    (member.BitField ? member.BitPosition.ToString() : string.Empty),
                    member.BitField ? (member.BitSize.ToString() + (member.BitSize == 1 ? " bit" : " bits")) : (member.Size.ToString() + (member.Size == 1 ? " byte" : " bytes")),
                    baseInfo?.TotalPadding.ToString() ?? string.Empty
                };
                dataGridViewSymbolInfo.Rows.Add(row);
                dataGridViewSymbolInfo.Rows[dataGridViewSymbolInfo.Rows.Count - 1].Tag = member;

                if (member.Expanded && baseInfo != null)
                    AddSymbolToGrid(baseInfo, ref prevCacheBoundaryOffset, ref numCacheLines, currentOffset,
                        increment + 1);

                if (member.BitField && member.BitPaddingAfter > 0 && checkBoxBitPadding.Checked)
                {
                    var paddingOffset = member.BitPaddingAfter.ToString() + " bits";
                    string[] paddingRow =
                    {
                        string.Empty,
                        incrementTextEmpty,
                        "Bitfield padding",
                        currentOffset.ToString(),
                        (member.BitPosition + member.BitSize).ToString(),
                        paddingOffset,
                        string.Empty
                    };
                    dataGridViewSymbolInfo.Rows.Add(paddingRow);
                }
            }

            // Final structure padding.
            if (symbol.EndPadding > 0 && checkBoxPadding.Checked)
            {
                var endPaddingOffset = symbol.Size - symbol.EndPadding;
                string[] paddingRow =
                {
                    string.Empty, string.Empty, "Padding", endPaddingOffset.ToString(), symbol.EndPadding.ToString(),
                    symbol.EndPadding.ToString()
                };
                dataGridViewSymbolInfo.Rows.Add(paddingRow);
            }

            foreach (var function in symbol.Functions)
            {
                object[] row =
                {
                    function.DisplayName, function.Virtual, function.IsPure, function.IsOverride, function.IsOverloaded,
                    function.IsMasking
                };
                dataGridViewFunctionsInfo.Rows.Add(row);
                dataGridViewFunctionsInfo.Rows[dataGridViewFunctionsInfo.Rows.Count - 1].Tag = function;
            }
        }

        private void dataGridSymbols_SortCompare(object sender, DataGridViewSortCompareEventArgs e)
        {
            if (e.Column.Index > 0)
            {
                e.Handled = true;
                TryParse(e.CellValue1.ToString(), out var val1);
                TryParse(e.CellValue2.ToString(), out var val2);
                e.SortResult = val1 - val2;
            }
        }

        private void dataGridViewSymbolInfo_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
        {
            var row = dataGridViewSymbolInfo.Rows[e.RowIndex];
            var nameCell = row.Cells[2];

            if (row.Tag is SymbolMemberInfo info)
            {
                if (info.Category == SymbolMemberInfo.MemberCategory.VTable)
                    e.CellStyle.BackColor = Color.LemonChiffon;
                else if (info.IsBase)
                    e.CellStyle.BackColor = Color.LightGreen;

                else if (info.BitField)
                {
                    if (e.ColumnIndex == 3 ) // Offset column
                    {
                        e.CellStyle.BackColor = Color.FromArgb((int)((info.Offset * 37) % 256), 192, 192); // random color not too dark
                        row.Cells[e.ColumnIndex].ToolTipText = "Bitfield";
                    }
                }
                else if (info.AlignWithPrevious)
                    if (e.ColumnIndex == 3) // Offset column
                    {
                        e.CellStyle.BackColor = Color.Salmon;
                        row.Cells[e.ColumnIndex].ToolTipText = "Aligned with previous";
                    }

                if (info.Volatile)
                    if (e.ColumnIndex == 0) // Name (Field) column
                    {
                        e.CellStyle.BackColor = Color.LightBlue;
                        row.Cells[e.ColumnIndex].ToolTipText = "Volatile";
                    }
            }
            else if (nameCell.Value.ToString() == "Padding")
            {
                e.CellStyle.BackColor = Color.LightPink;
                if (e.ColumnIndex == 2)
                    e.CellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
            }
            else if (nameCell.Value.ToString() == "Bitfield padding")
            {
                e.CellStyle.BackColor = Color.PaleVioletRed;
                if (e.ColumnIndex == 2)
                    e.CellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
            }
            else if (nameCell.Value.ToString().StartsWith("Cacheline"))
            {
                e.CellStyle.BackColor = Color.LightGray;
                if (e.ColumnIndex == 2)
                    e.CellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
            }
        }

        private void textBoxFilter_TextChanged(object sender, EventArgs e)
        {
            try
            {
                bindingSourceSymbols.Filter = GetFilterString();
                textBoxFilter.BackColor = Color.Empty;
                textBoxFilter.ForeColor = Color.Empty;
            }
            catch (EvaluateException)
            {
                textBoxFilter.BackColor = Color.Red;
                textBoxFilter.ForeColor = Color.White;
            }
        }

        private void textBoxFilter_KeyUp(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Return && !backgroundWorker.IsBusy)
            {
                LoadPdb(_FileName, false);
                btnLoad.Text = "Cancel";
            }
        }

        private void copyTypeLayoutToClipboardToolStripMenuItem_Click(object sender, EventArgs e)
        {
            var info = FindSelectedSymbolInfo();
            if (info != null) Clipboard.SetText(info.ToString());
        }

        private void textBoxCache_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar == (char) Keys.Enter || e.KeyChar == (char) Keys.Escape) ShowSelectedSymbolInfo();
            OnKeyPress(e);
        }

        private void textBoxCache_Leave(object sender, EventArgs e)
        {
            ShowSelectedSymbolInfo();
        }

        private void setPrefetchStartOffsetToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (dataGridViewSymbolInfo.SelectedRows.Count != 0)
            {
                var selectedRow = dataGridViewSymbolInfo.SelectedRows[0];
                ulong symbolOffset = Convert.ToUInt32(selectedRow.Cells[3].Value);
                _PrefetchStartOffset = symbolOffset % GetCacheLineSize();
                RefreshSymbolGrid(selectedRow.Index);
            }
        }


        private void checkBoxCacheLines_CheckedChanged(object sender, EventArgs e)
        {
            if (dataGridViewSymbolInfo.SelectedRows.Count != 0)
            {
                var selectedRow = dataGridViewSymbolInfo.SelectedRows[0];
                RefreshSymbolGrid(selectedRow.Index);
            }
            else
            {
                RefreshSymbolGrid(0);
            }
        }

        private void dataGridViewSymbolInfo_MouseClick(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                var currentMouseOverRow = dataGridViewSymbolInfo.HitTest(e.X, e.Y).RowIndex;
                if (currentMouseOverRow >= 0)
                {
                    dataGridViewSymbolInfo.Rows[currentMouseOverRow].Selected = true;
                    contextMenuStripMembers.Show(dataGridViewSymbolInfo, new Point(e.X, e.Y));
                }
            }
        }

        private void dataGridViewSymbolInfo_CellMouseDoubleClick(object sender, DataGridViewCellMouseEventArgs e)
        {
            var selectedRow = dataGridViewSymbolInfo.Rows[e.RowIndex];
            var currentSymbolInfo = selectedRow.Tag as SymbolMemberInfo;
            if (currentSymbolInfo != null && currentSymbolInfo.Category != SymbolMemberInfo.MemberCategory.Member)
            {
                var typeName = currentSymbolInfo.TypeName;
                if (typeName.Contains("[")) typeName = typeName.Substring(0, typeName.IndexOf("["));

                if (currentSymbolInfo.Category == SymbolMemberInfo.MemberCategory.Pointer)
                {
                    if (typeName.Contains("*")) typeName = typeName.Substring(0, typeName.IndexOf("*"));
                    if (typeName.Contains("&")) typeName = typeName.Substring(0, typeName.IndexOf("&"));
                }

                var jumpToSymbolInfo = _SymbolAnalyzer.FindSymbolInfo(typeName, true);
                if (jumpToSymbolInfo != null)
                    if (e.ColumnIndex == 0)
                    {
                        if (currentSymbolInfo.IsExapandable)
                        {
                            currentSymbolInfo.Expanded = !currentSymbolInfo.Expanded;
                            RefreshSymbolGrid(e.RowIndex);
                        }
                    }
                    else
                    {
                        ShowSymbolInfo(jumpToSymbolInfo, true);
                    }
            }
        }

        private void chkShowTemplates_CheckedChanged(object sender, EventArgs e)
        {
            bindingSourceSymbols.Filter = GetFilterString();
        }

        private void chkSmartCacheLines_CheckedChanged(object sender, EventArgs e)
        {
            ShowSelectedSymbolInfo();
        }

        private void checkedListBoxNamespaces_ItemCheck(object sender, ItemCheckEventArgs e)
        {
            this.BeginInvoke(new Action(() =>
            {
                bindingSourceSymbols.Filter = GetFilterString();
            }));
        }

        private void dataGridViewSymbolInfo_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Back)
                if (_NavigationStack.Count > 0)
                {
                    _SelectedSymbol = null;
                    ShowSymbolInfo(_NavigationStack.Pop(), true);
                }

            OnKeyDown(e);
        }

        private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            toolStripProgressBar.Value = e.ProgressPercentage;
            toolStripStatusLabel.Text = e.UserState as String;
        }

        private void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            btnLoad.Text = "Load";

            if (e.Cancelled)
            {
                if (_CloseRequested)
                {
                    Close();
                }
                else
                {
                    toolStripStatusLabel.Text = "";
                    toolStripProgressBar.Value = 0;
                }

                return;
            }

            var loadPdbSuccess = (bool) e.Result;

            if (!loadPdbSuccess)
            {
                MessageBox.Show(this, _SymbolAnalyzer.LastError);
                toolStripStatusLabel.Text = "Failed to load PDB.";
                return;
            }

            OnPDBLoaded();
        }

        private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            e.Result = _SymbolAnalyzer.LoadPdb(sender, e);
        }

        private void OnPDBLoaded()
        {
            compareWithPDBToolStripMenuItem.Enabled = true;
            loadInstanceCountToolStripMenuItem.Enabled = true;
            exportCsvToolStripMenuItem.Enabled = true;
            findUnusedVtablesToolStripMenuItem.Enabled = true;
            findMSVCExtraPaddingToolStripMenuItem.Enabled = true;
            findMSVCEmptyBaseClassToolStripMenuItem.Enabled = true;
            findUnusedInterfacesToolStripMenuItem.Enabled = true;
            findUnusedVirtualToolStripMenuItem.Enabled = true;
            findMaskingFunctionsToolStripMenuItem.Enabled = true;
            findRemovedInlineToolStripMenuItem.Enabled = true;

            // Temporarily clear the filter so, if current filter is invalid, we don't generate a ton of exceptions while populating the table
            var preExistingFilter = textBoxFilter.Text;
            textBoxFilter.Text = string.Empty;

            PopulateDataTable();

            checkedListBoxNamespaces.Items.Clear();
            foreach (var name in _SymbolAnalyzer.RootNamespaces) checkedListBoxNamespaces.Items.Add(name);

            // Sort by name by default (ascending)
            dataGridSymbols.Sort(dataGridSymbols.Columns[0], ListSortDirection.Ascending);
            bindingSourceSymbols.Filter = null; // "Symbol LIKE '*rde*'";

            // Restore the filter now that the table is populated
            textBoxFilter.Text = preExistingFilter;
            bindingSourceSymbols.Filter = GetFilterString();

            ShowSelectedSymbolInfo();

            _NavigationStack.Clear();
        }

        private void loadInstanceCountToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (backgroundWorker.IsBusy) return;
            if (openCsvDialog.ShowDialog() == DialogResult.OK) LoadCsv(openPdbDialog.FileName);
        }

        private void LoadCsv(string fileName)
        {
            Cursor.Current = Cursors.WaitCursor;

            if (_HasInstancesCount)
                foreach (var symbol in _SymbolAnalyzer.Symbols.Values)
                {
                    symbol.NumInstances = 0;
                    symbol.TotalCount = 0;
                }

            using (var sourceStream =
                File.Open(openCsvDialog.FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
            {
                using (var reader = new StreamReader(sourceStream))
                {
                    var skipAllResolve = false;
                    while (!reader.EndOfStream)
                    {
                        var line = reader.ReadLine();
                        var values = line.Split(',');
                        var count = ulong.Parse(values[1]);
                        if (count == 0)
                            continue;

                        var info = _SymbolAnalyzer.FindSymbolInfo(values[0]);
                        if (info == null)
                        {
                            var validNamespaces = new List<string>();
                            if (checkedListBoxNamespaces.CheckedItems.Count > 0)
                            {
                                foreach (var selected in checkedListBoxNamespaces.CheckedItems)
                                {
                                    info = _SymbolAnalyzer.FindSymbolInfo(selected + "::" + values[0]);
                                    if (info != null)
                                        validNamespaces.Add(selected.ToString());
                                }

                                if (validNamespaces.Count == 0)
                                    foreach (var selected in _SymbolAnalyzer.Namespaces)
                                    {
                                        info = _SymbolAnalyzer.FindSymbolInfo(selected + "::" + values[0]);
                                        if (info != null)
                                            validNamespaces.Add(selected);
                                    }
                            }
                            else
                            {
                                foreach (var selected in _SymbolAnalyzer.Namespaces)
                                {
                                    info = _SymbolAnalyzer.FindSymbolInfo(selected + "::" + values[0]);
                                    if (info != null)
                                        validNamespaces.Add(selected);
                                }
                            }

                            if (validNamespaces.Count == 0) continue;

                            if (validNamespaces.Count == 1)
                            {
                                info = _SymbolAnalyzer.FindSymbolInfo(validNamespaces[0] + "::" + values[0]);
                            }
                            else if (!skipAllResolve)
                            {
                                var namespaceForm = new SelectNamespaceForm();
                                namespaceForm.SetName(values[0], count);
                                namespaceForm.AddNamespaces(validNamespaces);
                                namespaceForm.ShowDialog();
                                skipAllResolve = namespaceForm.SkipAllNamespaces;
                                info = _SymbolAnalyzer.FindSymbolInfo(namespaceForm.GetNamespace() + "::" + values[0]);
                            }
                        }

                        if (info != null) info.TotalCount = info.NumInstances = count;
                    }
                }
            }

            foreach (var symbol in _SymbolAnalyzer.Symbols.Values)
                if (symbol.NumInstances > 0)
                    symbol.UpdateTotalCount(_SymbolAnalyzer, symbol.NumInstances);

            Cursor.Current = Cursors.Default;
            AddInstancesCount();
            PopulateDataTable();
        }

        private void compareWithPDBToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (backgroundWorker.IsBusy) return;
            if (openPdbDialog.ShowDialog() == DialogResult.OK)
            {
                AddSecondPDB();
                LoadPdb(openPdbDialog.FileName, true);
            }
        }

        private void exportCsvToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (backgroundWorker.IsBusy) return;
            if (saveCsvDialog.ShowDialog() == DialogResult.OK)
                using (var writer = new StreamWriter(saveCsvDialog.FileName))
                {
                    writer.WriteLine(
                        "Name,Size,Padding,Padding zones,Total padding,Num Instances,Total size,Total waste,");

                    foreach (var symbolInfo in _SymbolAnalyzer.Symbols.Values)
                        writer.WriteLine("{0},{1},{2},{3},{4},{5},{6},{7},", symbolInfo.Name, symbolInfo.Size,
                            symbolInfo.Padding, symbolInfo.PaddingZonesCount, symbolInfo.TotalPadding.Value,
                            symbolInfo.NumInstances, symbolInfo.NumInstances * symbolInfo.Size,
                            symbolInfo.NumInstances * symbolInfo.Padding);
                }
        }

        private void CruncherSharpForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (backgroundWorker.IsBusy)
            {
                e.Cancel = true; // Can't close form while background worker is busy!
                backgroundWorker.CancelAsync();
                _CloseRequested = true;
            }
        }

        private void findUnusedVtablesToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SearchCategory = SearchType.UnusedVTables;

            PopulateDataTable();
        }

        private void Reset_Click(object sender, EventArgs e)
        {
            chkShowTemplates.Checked = true;
            chkSmartCacheLines.Checked = true;
            for (var i = 0; i < checkedListBoxNamespaces.Items.Count; i++)
                checkedListBoxNamespaces.SetItemChecked(i, false);
            textBoxFilter.Clear();
            SearchCategory = SearchType.None;
            PopulateDataTable();
        }

        private void findMSVCExtraPaddingToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SearchCategory = SearchType.MSVCExtraPadding;

            PopulateDataTable();
        }

        private void findMSVCEmptyBaseClassToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SearchCategory = SearchType.MSVCEmptyBaseClass;

            PopulateDataTable();
        }

        private void findUnusedInterfacesToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SearchCategory = SearchType.UnusedInterfaces;

            PopulateDataTable();
        }

        private void findUnusedVirtualToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SearchCategory = SearchType.UnusedVirtual;

            PopulateDataTable();
        }

        private void dataGridViewFunctionsInfo_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
        {
            var row = dataGridViewFunctionsInfo.Rows[e.RowIndex];
            var info = row.Tag as SymbolFunctionInfo;
            if (_FunctionsToIgnore.Contains(info.Name))
                e.CellStyle.BackColor = Color.LightGray;
            else
                switch (info.Category)
                {
                    case SymbolFunctionInfo.FunctionCategory.Constructor:
                        e.CellStyle.BackColor = Color.LightBlue;
                        break;
                    case SymbolFunctionInfo.FunctionCategory.Destructor:
                        e.CellStyle.BackColor = Color.LightGreen;
                        break;
                    case SymbolFunctionInfo.FunctionCategory.StaticFunction:
                        e.CellStyle.BackColor = Color.LightPink;
                        break;
                    default:
                        switch (SearchCategory)
                        {
                            case SearchType.UnusedVirtual:
                                if (info.UnusedVirtual) e.CellStyle.BackColor = Color.IndianRed;

                                break;
                            case SearchType.MaskingFunction:
                                if (info.IsMasking) e.CellStyle.BackColor = Color.IndianRed;

                                break;
                            case SearchType.RemovedInline:
                                if (info.WasInlineRemoved) e.CellStyle.BackColor = Color.IndianRed;

                                break;
                        }

                        break;
                }
        }

        private void findMaskingFunctionsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SearchCategory = SearchType.MaskingFunction;

            PopulateDataTable();
        }

        private void ignoreFunctionToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (dataGridViewFunctionsInfo.SelectedRows.Count != 0)
            {
                var selectedRow = dataGridViewFunctionsInfo.SelectedRows[0];
                var info = selectedRow.Tag as SymbolFunctionInfo;
                if (!_FunctionsToIgnore.Contains(info.Name))
                {
                    _FunctionsToIgnore.Add(info.Name);
                    PopulateDataTable();
                }
            }
        }

        private void dataGridViewFunctionsInfo_MouseClick(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                var currentMouseOverRow = dataGridViewFunctionsInfo.HitTest(e.X, e.Y).RowIndex;
                if (currentMouseOverRow >= 0)
                {
                    dataGridViewFunctionsInfo.Rows[currentMouseOverRow].Selected = true;
                    contextMenuStripFunctions.Show(dataGridViewFunctionsInfo, new Point(e.X, e.Y));
                }
            }
        }

        private void dataGridSymbols_MouseClick(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                var currentMouseOverRow = dataGridSymbols.HitTest(e.X, e.Y).RowIndex;
                if (currentMouseOverRow >= 0)
                {
                    foreach (DataGridViewRow selectedRow in dataGridSymbols.SelectedRows)
                        selectedRow.Selected = false;
                    dataGridSymbols.Rows[currentMouseOverRow].Selected = true;

                    toolStripMenuItemParentClasses.DropDownItems.Clear();
                    var info = FindSelectedSymbolInfo();
                    if (info != null)
                    {
                        if (info.DerivedClasses != null)
                        {
                            toolStripMenuItemParentClasses.Enabled = true;
                            foreach (var parent in info.DerivedClasses)
                                toolStripMenuItemParentClasses.DropDownItems.Add(parent.Name, null,
                                    dataGridSymbols_ParentSelected);
                        }
                        else
                        {
                            toolStripMenuItemParentClasses.Enabled = false;
                        }

                        ShowSymbolInfo(info, false);
                    }

                    contextMenuStripClassInfo.Show(dataGridSymbols, new Point(e.X, e.Y));
                }
            }
        }

        private void findRemovedInlineToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SearchCategory = SearchType.RemovedInline;

            PopulateDataTable();
        }

        private void UpdateCheckedOption()
        {
            findUnusedVtablesToolStripMenuItem.Checked = SearchCategory == SearchType.UnusedVTables;
            findUnusedVirtualToolStripMenuItem.Checked = SearchCategory == SearchType.UnusedVirtual;
            findMSVCExtraPaddingToolStripMenuItem.Checked = SearchCategory == SearchType.MSVCExtraPadding;
            findMSVCEmptyBaseClassToolStripMenuItem.Checked = SearchCategory == SearchType.MSVCEmptyBaseClass;
            findUnusedInterfacesToolStripMenuItem.Checked = SearchCategory == SearchType.UnusedInterfaces;
            findMaskingFunctionsToolStripMenuItem.Checked = SearchCategory == SearchType.MaskingFunction;
            findRemovedInlineToolStripMenuItem.Checked = SearchCategory == SearchType.RemovedInline;
        }

        private void PopulateDataTable()
        {
            _Table.Rows.Clear();

            _Table.BeginLoadData();

            foreach (var symbolInfo in _SymbolAnalyzer.Symbols.Values)
                switch (SearchCategory)
                {
                    case SearchType.None:
                        AddSymbolToTable(symbolInfo);
                        break;
                    case SearchType.UnusedVTables:
                        if (symbolInfo.HasVtable && !symbolInfo.HasBaseClass && symbolInfo.DerivedClasses == null)
                            AddSymbolToTable(symbolInfo);
                        break;
                    case SearchType.MSVCExtraPadding:
                        if (symbolInfo.HasMSVCExtraPadding) AddSymbolToTable(symbolInfo);
                        break;
                    case SearchType.MSVCEmptyBaseClass:
                        if (symbolInfo.HasMSVCEmptyBaseClass) AddSymbolToTable(symbolInfo);
                        break;
                    case SearchType.UnusedInterfaces:
                        if (symbolInfo.IsAbstract && symbolInfo.DerivedClasses == null) AddSymbolToTable(symbolInfo);
                        break;
                    case SearchType.UnusedVirtual:
                        foreach (var function in symbolInfo.Functions)
                            if (function.UnusedVirtual)
                                if (!_FunctionsToIgnore.Contains(function.Name))
                                {
                                    AddSymbolToTable(symbolInfo);
                                    break;
                                }

                        break;
                    case SearchType.MaskingFunction:
                        foreach (var function in symbolInfo.Functions)
                            if (function.IsMasking)
                                if (!_FunctionsToIgnore.Contains(function.Name))
                                {
                                    AddSymbolToTable(symbolInfo);
                                    break;
                                }

                        break;
                    case SearchType.RemovedInline:
                        foreach (var function in symbolInfo.Functions)
                            if (function.WasInlineRemoved)
                                if (!_FunctionsToIgnore.Contains(function.Name))
                                {
                                    AddSymbolToTable(symbolInfo);
                                    break;
                                }

                        break;
                }

            _Table.EndLoadData();
        }

        private void btnLoad_Click(object sender, EventArgs e)
        {
            if (backgroundWorker.IsBusy)
            {
                backgroundWorker.CancelAsync();
                toolStripStatusLabel.Text = "Cancelling...";
            }
            else
            {
                LoadPdb(_FileName, false);
                btnLoad.Text = "Cancel";
            }
        }

        private void checkBoxMatchCase_CheckedChanged(object sender, EventArgs e)
        {
            _Table.CaseSensitive = checkBoxMatchCase.Checked;
            bindingSourceSymbols.Filter = GetFilterString();
        }

        private void checkBoxMatchWholeExpression_CheckedChanged(object sender, EventArgs e)
        {
            bindingSourceSymbols.Filter = GetFilterString();
        }

        private void checkBoxRegularExpressions_CheckedChanged(object sender, EventArgs e)
        {
            if (checkBoxRegularExpressions.Checked)
            {
                checkBoxMatchWholeExpression.Checked = false;
                checkBoxMatchWholeExpression.Enabled = false;
            }
            else
            {
                checkBoxMatchWholeExpression.Enabled = true;
            }

            bindingSourceSymbols.Filter = GetFilterString();
        }

        private void checkBoxPadding_CheckedChanged(object sender, EventArgs e)
        {
            if (dataGridViewSymbolInfo.SelectedRows.Count != 0)
            {
                var selectedRow = dataGridViewSymbolInfo.SelectedRows[0];
                RefreshSymbolGrid(selectedRow.Index);
            }
            else
            {
                RefreshSymbolGrid(0);
            }
        }

        private void checkBoxBitPadding_CheckedChanged(object sender, EventArgs e)
        {
            if (dataGridViewSymbolInfo.SelectedRows.Count != 0)
            {
                var selectedRow = dataGridViewSymbolInfo.SelectedRows[0];
                RefreshSymbolGrid(selectedRow.Index);
            }
            else
            {
                RefreshSymbolGrid(0);
            }
        }
    }
}