private void Instance_DisplayHexaNumbersChanged()
 {
     if (threadsGrid.RowCount != 0)
     {
         for (int i = 0; i < threadsGrid.RowCount; i++)
         {
             GridEXCell idCell = threadsGrid.GetRow(i).Cells[0];
             idCell.Value = NuGenHelperFunctions.FormatNumber(NuGenHelperFunctions.TaggedObjects[(int)idCell.Value]);
         }
     }
 }
 private decimal GetDecimalValueSafe(GridEXCell cell)
 {
     if (cell.Value == null || cell.Value == DBNull.Value)
     {
         return 0;
     }
     else
     {
         return Convert.ToDecimal(cell.Value);
     }
 }
 private decimal GetDecimalValueSafe(GridEXCell cell)
 {
     if (cell.Value == null || cell.Value == DBNull.Value)
     {
         return(0);
     }
     else
     {
         return(Convert.ToDecimal(cell.Value));
     }
 }
Exemple #4
0
        private void grdTestResult_FormattingRow(object sender, RowLoadEventArgs e)
        {
            if (e == null)
            {
                return;
            }
            var        gf         = new GridEXFormatStyle();
            GridEXCell gridExCell = e.Row.Cells[TResultDetail.Columns.TestResult];

            gf.TextAlignment       = Utility.IsNumeric(gridExCell.Value) ? TextAlignment.Far : TextAlignment.Center;
            gridExCell.FormatStyle = gf;
        }
Exemple #5
0
        public static void ConfigureAsColor(this GridEXColumn column, Color?defaultColor = null)
        {
            column.ColumnType = ColumnType.Text;
            column.EditType   = EditType.Custom;

            {
                // Fancy scope so that the colorControl is not captured in FormattingRow
                var colorControl = new UIColorButton();
                colorControl.Configure();
                if (defaultColor.HasValue)
                {
                    colorControl.ColorPicker.AutomaticColor = defaultColor.Value;
                }

                column.GridEX.InitCustomEdit += (sender, e) =>
                {
                    if (e.Column == column)
                    {
                        if (e.Value != null)
                        {
                            colorControl.SelectedColor = (Color)e.Value;
                        }
                        e.EditControl = colorControl;
                    }
                };

                column.GridEX.EndCustomEdit += (sender, e) =>
                {
                    if (e.Column == column)
                    {
                        e.Value       = colorControl.SelectedColor;
                        e.DataChanged = true;
                    }
                };
            }

            column.GridEX.FormattingRow += (sender, e) =>
            {
                if (e.Row.RowType == RowType.Record)
                {
                    GridEXCell cell  = e.Row.Cells[column];
                    var        color = (Color)cell.Value;
                    cell.FormatStyle           = new GridEXFormatStyle();
                    cell.FormatStyle.BackColor = color;
                    cell.Text        = color.Description();
                    cell.ToolTipText = cell.Text;
                }
            };
        }
        private string GetChosenMenuText(object sender)
        {
            ToolStripItem menuItem    = (ToolStripItem)sender;
            GridEXRow     selectedRow = SelectedItems[0].GetRow();
            StringBuilder result      = new StringBuilder();

            if (menuItem.Tag == null)
            {
                for (int index = 0; index < selectedRow.Cells.Count; index++)
                {
                    GridEXCell cell = selectedRow.Cells[index];

                    if (cell.Value != null)
                    {
                        result.Append(Convert.ToString(cell.Value));

                        if (index < selectedRow.Cells.Count - 1)
                        {
                            result.Append("\t");
                        }
                    }
                }
            }
            else
            {
                GridEXColumn sourceColumn = (GridEXColumn)menuItem.Tag;
                GridEXCell   cell         = selectedRow.Cells[sourceColumn.Index];

                if (cell.Value != null)
                {
                    result.Append(Convert.ToString(cell.Value));
                }
            }

            return(result.ToString());
        }
 private void AssignNumberValueToCell <T>(GridEXCell cell, T tag)
 {
     NuGenHelperFunctions.TaggedObjects.Add(cell.Value.ToString(), tag);
     cell.Value = NuGenHelperFunctions.FormatNumber(tag);
 }
 private void FormatNumberInCell(GridEXCell cell)
 {
     cell.Value = NuGenHelperFunctions.FormatNumber(NuGenHelperFunctions.TaggedObjects[cell.Value.ToString()]);
 }
        private void ShowThreads()
        {
            threadsGrid.BeginGridUpdate();
            threadsGrid.ClearItems();
            List <ThreadWrapper> threads = NuGenDebugEventHandler.Instance.EventObjects.Controller.EnumerateThreads();

            foreach (ThreadWrapper thread in threads)
            {
                EvaluatedThreadName = "<no name>";
                ValueWrapper threadObject       = null;
                ValueWrapper dereferencedObject = null;

                if (!HasSearchedForNameMethod)
                {
                    threadObject = thread.GetObject();

                    if (threadObject != null && !threadObject.IsNull())
                    {
                        dereferencedObject = threadObject.DereferenceValue();

                        if (dereferencedObject != null)
                        {
                            ClassWrapper  threadClass     = dereferencedObject.GetClassInformation();
                            uint          threadTypeToken = threadClass.GetToken();
                            ModuleWrapper module          = threadClass.GetModule();

                            FindGetThreadNameMethod(threadTypeToken, module);
                        }
                    }
                }

                if (HasSearchedForNameMethod)
                {
                    if (GetThreadNameMethod == null)
                    {
                        EvaluatedThreadName = "<definition of the Thread class is not loaded>";
                    }
                    else
                    {
                        if (threadObject == null)
                        {
                            threadObject = thread.GetObject();

                            if (threadObject != null && !threadObject.IsNull())
                            {
                                dereferencedObject = threadObject.DereferenceValue();
                            }
                        }

                        if (dereferencedObject != null)
                        {
                            FrameWrapper threadActiveFrame = thread.GetActiveFrame();

                            if (threadActiveFrame != null)
                            {
                                NuGenFrameRefresher threadActiveFrameRefresher = new NuGenFrameRefresher(thread, threadActiveFrame.ChainIndex, threadActiveFrame.FrameIndex, threadActiveFrame.IsActiveFrame);

                                GetThreadName(thread, threadObject, threadActiveFrameRefresher);
                            }
                        }
                    }
                }

                GridEXRow row = threadsGrid.AddItem();

                uint       threadID = thread.GetID();
                GridEXCell idCell   = row.Cells[0];
                NuGenHelperFunctions.TaggedObjects.Add((int)idCell.Value, threadID);
                idCell.Value       = NuGenHelperFunctions.FormatNumber(threadID);
                row.Cells[1].Value = EvaluatedThreadName;

                AppDomainWrapper appDomain = thread.GetAppDomain();

                if (appDomain != null)
                {
                    row.Cells[2].Value = appDomain.GetName();
                }

                NuGenHelperFunctions.TaggedObjects.Add((String)row.Cells[1].Value + (String)row.Cells[2].Value, thread);
            }

            threadsGrid.EndGridUpdate();
        }