Пример #1
0
 private void TreeProjectFiles_CustomColumnSort(object sender, CustomColumnSortEventArgs e)
 {
     if (e.NodeValue1 is string && e.NodeValue2 is string)
     {
         e.Result = StringLogicalComparer.Compare(Convert.ToString(e.NodeValue1), Convert.ToString(e.NodeValue2));
     }
 }
Пример #2
0
        public int CompareTo(object obj)
        {
            IComparer _comp = new StringLogicalComparer();

            //System.Collections.IComparer _comp = System.Collections.Comparer.Default;
            return(_comp.Compare(ToString(), obj.ToString()));
        }
Пример #3
0
        static void Main(string[] args)
        {
            // 排序类.
            StringLogicalComparer sl = new StringLogicalComparer();
            
            // 数据列表.
            List<string> al = new List<string>();
            al.Add("1f");
            al.Add("1");
            al.Add("1f1a");
            al.Add("1f1");
            al.Add("1fa1");
            al.Add("1af2");
            al.Add("1ab3");
            al.Add("1ab23");
            al.Add("1b1");
            al.Add("11w");
            al.Add("2a");
            al.Add("12");
            al.Add("22");
            al.Add("21");

            // 按特定方式排序.
            al.Sort(sl);

            // 输出排序结果.
            foreach (string a in al)
            {
                Console.WriteLine(a);
            }

            Console.ReadLine();

        }
        /// <summary>
        /// This method is inherited from the IComparer interface.  It compares the two objects passed using a case insensitive comparison.
        /// </summary>
        /// <param name="x">First object to be compared</param>
        /// <param name="y">Second object to be compared</param>
        /// <returns>The result of the comparison. "0" if equal, negative if 'x' is less than 'y' and positive if 'x' is greater than 'y'</returns>
        public int Compare(object x, object y)
        {
            int          compareResult;
            ListViewItem listviewX, listviewY;

            // Cast the objects to be compared to ListViewItem objects
            listviewX = (ListViewItem)x;
            listviewY = (ListViewItem)y;

            // Compare the two items
            compareResult = StringLogicalComparer.Compare(listviewX.SubItems[ColumnToSort].Text, listviewY.SubItems[ColumnToSort].Text);

            // Calculate correct return value based on object comparison
            if (OrderOfSort == SortOrder.Ascending)
            {
                // Ascending sort is selected, return normal result of compare operation
                return(compareResult);
            }
            else if (OrderOfSort == SortOrder.Descending)
            {
                // Descending sort is selected, return negative result of compare operation
                return(-compareResult);
            }
            else
            {
                // Return '0' to indicate they are equal
                return(0);
            }
        }
Пример #5
0
        static void Main(string[] args)
        {
            // 排序类.
            StringLogicalComparer sl = new StringLogicalComparer();

            // 数据列表.
            List <string> al = new List <string>();

            al.Add("1f");
            al.Add("1");
            al.Add("1f1a");
            al.Add("1f1");
            al.Add("1fa1");
            al.Add("1af2");
            al.Add("1ab3");
            al.Add("1ab23");
            al.Add("1b1");
            al.Add("11w");
            al.Add("2a");
            al.Add("12");
            al.Add("22");
            al.Add("21");

            // 按特定方式排序.
            al.Sort(sl);

            // 输出排序结果.
            foreach (string a in al)
            {
                Console.WriteLine(a);
            }

            Console.ReadLine();
        }
Пример #6
0
        public static void Sort(List <LP_Category> list)
        {
            var logicalComparer    = new StringLogicalComparer();
            var comparisonComparer = new ComparisonComparer <LP_Category>((x, y) => CategoryComparer(logicalComparer, x, y));

            list.Sort(comparisonComparer);
        }
 private static String[] Sort(String[] input, String cultureName)
 {
     var culture = new CultureInfo(cultureName);
     var shuffled = input.Reverse().Shuffle().ToArray();
     var comparer = new StringLogicalComparer(culture);
     return shuffled.OrderBy(x => x, comparer)
                    .ToArray();
 }
Пример #8
0
 public int Compare(object x, object y)
 {
     if ((x is string) && (y is string))
     {
         return StringLogicalComparer.Compare((string)x, (string)y);
     }
     return -1;
 }
 public int Compare(object x, object y)
 {
     if ((x is TreeNode) && (y is TreeNode))
     {
         return(StringLogicalComparer.Compare(((TreeNode)x).Text, ((TreeNode)y).Text));
     }
     return(-1);
 }
        public int Compare(object x, object y)
        {
            var info = x as PhysicalControlInfo;

            if (info != null && y is PhysicalControlInfo)
            {
                return(StringLogicalComparer.Compare(info.Alias, ((PhysicalControlInfo)y).Alias));
            }
            return(-1);
        }
        public int Compare(object x, object y)
        {
            var node = x as TreeNode;

            if (node != null && y is TreeNode)
            {
                return(StringLogicalComparer.Compare(node.Text, ((TreeNode)y).Text));
            }
            return(-1);
        }
        /// <summary>
        /// Class constructor.  Initializes various elements
        /// </summary>
        public ListViewColumnSorter()
        {
            // Initialize the column to '0'
            ColumnToSort = 0;

            // Initialize the sort order to 'none'
            OrderOfSort = SortOrder.None;

            // Initialize the CaseInsensitiveComparer object
            ObjectCompare = new StringLogicalComparer();
        }
Пример #13
0
        public int Compare(DataObjectFriend x, DataObjectFriend y)
        {
            if (!blnDesc)
            {
                return(StringLogicalComparer.Compare(x.Nickname, y.Nickname));
            }

            else
            {
                return(StringLogicalComparer.Compare(y.Nickname, x.Nickname));
            }
        }
Пример #14
0
        protected static string GetProcessPath(bool isScript)
        {
            var rKey = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\R-core\R64");

            if (rKey == null)
            {
                rKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\R-core\R64");
            }
            bool is_x64 = rKey != null;

            if (rKey == null)
            {
                rKey = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\R-core\R");
            }
            if (rKey == null)
            {
                rKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\R-core\R");
            }

            if (rKey == null)
            {
                return(null);
            }

            string path = null;

            try
            {
                path = Convert.ToString(rKey.GetValue("InstallPath"));

                var version = Convert.ToString(rKey.GetValue("Current Version"));

                path = Path.Combine(path, "bin");

                if (StringLogicalComparer.Compare(version, "2.12.0.0", true) >= 0)
                {
                    path = Path.Combine(path, is_x64 ? "x64" : "i386");
                }

                var cmdFile = isScript ? "Rscript.exe" : "Rterm.exe";

                path = Path.Combine(path, cmdFile);
            }
            finally
            {
                rKey.Close();
            }

            return(path);
        }
Пример #15
0
        public int Compare(TaggedText x, TaggedText y)
        {
            if (Column < 1 || Column >= x.Fields.Length + 1)
            {
                return(0);
            }

            int result = StringLogicalComparer.Compare(
                x.Fields[Column - 1], y.Fields[Column - 1]);

            // If the sort order is descending then return inverted
            // value that was returned by String.Compare.
            //
            return(Sorting == SortOrder.Descending ? -result : result);
        }
Пример #16
0
        private void _sort()
        {
            if (this.Count < 2)
            {
                return;
            }
            Action <int, int> sort = null;

            sort = (low, high) =>
            {
                int i = low;
                int j = high;
                ConnectionViewModel m = this[(i + j) / 2];
                do
                {
                    while (StringLogicalComparer.Compare(this[i].Name, m.Name) < 0)
                    {
                        i++;
                    }
                    while (StringLogicalComparer.Compare(this[j].Name, m.Name) > 0)
                    {
                        j--;
                    }
                    if (i <= j)
                    {
                        ConnectionViewModel temp = this[i];
                        this[i] = this[j];
                        this[j] = temp;
                        i++; j--;
                    }
                } while (i <= j);
                if (low < j)
                {
                    sort(low, j);
                }
                if (i < high)
                {
                    sort(i, high);
                }
            };
            sort(0, this.Count - 1);
        }
Пример #17
0
        public int CompareTo(TableBlock other)
        {
            //sort by group, object type, name, modified
            int groupComparison = this.Group.CompareTo(other.Group);

            if (groupComparison == 0)
            {
                int objectTypeComparison = this.ObjectType.CompareTo(other.ObjectType);
                if (objectTypeComparison == 0)
                {
                    int nameComparison = StringLogicalComparer.Compare(this.Name, other.Name);
                    if (nameComparison == 0)
                    {
                        return(this.Modified.CompareTo(other.Modified));
                    }

                    return(nameComparison);
                }

                return(objectTypeComparison);
            }

            return(groupComparison);
        }
Пример #18
0
        public static DataTable GetChartDataTable(String groupMember, String yMember, String xMember, IEnumerable <DataRowView> collection, bool sortData)
        {
            var logicalComparer    = new StringLogicalComparer();
            var comparisonComparer = new ComparisonComparer <Object>((x, y) => Compare(logicalComparer, x, y));

            var dataRowViewsXQuery = (from DataRowView n in collection
                                      let v = n[xMember]
                                              select new
            {
                Grouper = v,
                DataRow = n
            });

            if (sortData)
            {
                dataRowViewsXQuery = dataRowViewsXQuery.OrderBy(n => n.Grouper, comparisonComparer);
            }

            var dataRowViewsXLp = dataRowViewsXQuery.ToLookup(n => n.Grouper);
            var verticalColumns = dataRowViewsXLp.Select(n => n.Key).ToList();

            var horizontalColumnsQuery = (from DataRowView n in collection
                                          let v = GetGrouperValue(n, groupMember, yMember)
                                                  select v);

            if (sortData)
            {
                horizontalColumnsQuery = horizontalColumnsQuery.OrderBy(n => n, comparisonComparer);
            }

            var horizontalColumns = horizontalColumnsQuery.Distinct().ToList();

            horizontalColumns.Insert(0, xMember);

            var dataTable = new DataTable();

            foreach (var horizontalColumn in horizontalColumns)
            {
                dataTable.Columns.Add(horizontalColumn).AllowDBNull = true;
            }

            foreach (var verticalColumn in verticalColumns)
            {
                var dataRow = dataTable.NewRow();
                dataRow[xMember] = Convert.ToString(verticalColumn);

                var dataRowViewsGroupQuery = from n in dataRowViewsXLp[verticalColumn]
                                             let v = GetGrouperValue(n.DataRow, groupMember, yMember)
                                                     select new
                {
                    Grouper = v,
                    DataRow = n.DataRow
                };

                if (sortData)
                {
                    dataRowViewsGroupQuery = dataRowViewsGroupQuery.OrderBy(n => n.Grouper, comparisonComparer);
                }

                var dataRowViewsGroupLp = dataRowViewsGroupQuery.ToLookup(n => n.Grouper);

                foreach (var horizontalColumn in horizontalColumns)
                {
                    if (horizontalColumn == xMember)
                    {
                        continue;
                    }

                    var dataRowViewsGroupGrp = dataRowViewsGroupLp[horizontalColumn];

                    var values = (from n in dataRowViewsGroupGrp
                                  let v = n.DataRow[yMember]
                                          let m = DataConverter.ToNullableDouble(v)
                                                  where m != null
                                                  select m);

                    var dbl = values.Sum();
                    if (dbl != null)
                    {
                        dbl = Math.Round(dbl.Value, 2);
                    }

                    var value = String.Format("{0:0.00}", dbl);
                    dataRow[horizontalColumn] = value;
                }

                dataTable.Rows.Add(dataRow);
            }

            return(dataTable);
        }
 public int CompareTo(object obj)
 {
     return(StringLogicalComparer.Compare(Text, ((DbSchemaBaseNode)obj)?.Text));
 }
Пример #20
0
 public int Compare(string x, string y)
 {
     return(StringLogicalComparer.Compare(x, y));
 }
Пример #21
0
 public override int Compare(string param1, string param2)
 {
     return(StringLogicalComparer.Compare(param1, param2, false));
 }
 public void Setup()
 {
     _comparer = new StringLogicalComparer();
 }
Пример #23
0
        public ScriptEditorPopupForm(SyntaxBoxControl editor, ScriptIntellisense intellisense)
        {
            InitializeComponent();

            _Editor       = editor;
            _Intellisense = intellisense;

            if (_Intellisense.Help != null && (_Intellisense.Help.SupportsHelp || _Intellisense.Help.SupportsOnlineHelp))
            {
                if (_Intellisense.Help.SupportsHelp && _Intellisense.Help.SupportsOnlineHelp)
                {
                    lblComments.Text = "Press<b>F1</b> for more help, <b>F2</b> for online help";
                }
                else if (_Intellisense.Help.SupportsHelp)
                {
                    lblComments.Text = "Press<b>F1</b> for more help";
                }
                else if (_Intellisense.Help.SupportsOnlineHelp)
                {
                    lblComments.Text = "Press <b>F2</b> for online help";
                }
            }
            else
            {
                lblComments.Visible = false;
            }


            _StartSearchPosition = new TextPoint()
            {
                X = _Editor.Caret.Position.X,
                Y = _Editor.Caret.Position.Y
            };

            _StartSearchPosition.X = FindStartSymbol(_Editor.Caret.CurrentRow.Text, Math.Max(_StartSearchPosition.X - 1, 0),
                                                     intellisense.UsePeriodInIntellisense, out _LastPartStart);

            _Intellisense.Items.Sort((x, y) =>
            {
                if (x.DisplayOrder != y.DisplayOrder)
                {
                    return(x.DisplayOrder.CompareTo(y.DisplayOrder));
                }
                if (x.IsMandatory.CompareTo(y.IsMandatory) != 0)
                {
                    return(-x.IsMandatory.CompareTo(y.IsMandatory));
                }
                if (x.Position.HasValue && !y.Position.HasValue)
                {
                    return(-1);
                }
                if (!x.Position.HasValue && y.Position.HasValue)
                {
                    return(1);
                }
                if (x.Position.HasValue && y.Position.HasValue && x.Position.Value.CompareTo(y.Position.Value) != 0)
                {
                    return(x.Position.Value.CompareTo(y.Position.Value));
                }
                return(StringLogicalComparer.Compare(x.Caption, y.Caption));
            });
            Grid.DataSource = _Intellisense.Items;

            lblDescription.DataBindings.Add(nameof(lblDescription.Text), _Intellisense.Items, nameof(ScriptIntellisenseItem.Description));

            _Editor.CaretChange += new EventHandler(Editor_CaretChange);
        }