← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/Commands/SortSelectionCommand.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/Commands/SortSelectionCommand.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using System.Linq;
 
6
using ICSharpCode.Core;
 
7
using ICSharpCode.SharpDevelop.Editor;
 
8
using ICSharpCode.SharpDevelop.Gui;
 
9
using System.Collections.Generic;
 
10
 
 
11
namespace ICSharpCode.AvalonEdit.AddIn.Commands
 
12
{
 
13
        public class SortSelectionCommand : AbstractMenuCommand
 
14
        {
 
15
                public override void Run()
 
16
                {
 
17
                        SortOptionsDialog dlg = new SortOptionsDialog();
 
18
                        dlg.Owner = WorkbenchSingleton.MainWindow;
 
19
                        if (dlg.ShowDialog() == true) {
 
20
                                StringComparer comparer = SortOptions.CaseSensitive ? StringComparer.CurrentCulture : StringComparer.CurrentCultureIgnoreCase;
 
21
                                if (SortOptions.IgnoreTrailingWhitespaces)
 
22
                                        comparer = new IgnoreTrailingWhitespaceComparer(comparer);
 
23
                                if (SortOptions.SortDirection == SortDirection.Descending)
 
24
                                        comparer = new DescendingStringComparer(comparer);
 
25
                                
 
26
                                ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
 
27
                                if (provider != null) {
 
28
                                        ITextEditor editor = provider.TextEditor;
 
29
                                        if (editor.SelectionLength > 0) {
 
30
                                                int start = editor.Document.GetLineForOffset(editor.SelectionStart).LineNumber;
 
31
                                                int end = editor.Document.GetLineForOffset(editor.SelectionStart + editor.SelectionLength).LineNumber;
 
32
                                                SortLines(editor.Document, start, end, comparer, SortOptions.RemoveDuplicates);
 
33
                                        } else {
 
34
                                                SortLines(editor.Document, 1, editor.Document.TotalNumberOfLines, comparer, SortOptions.RemoveDuplicates);
 
35
                                        }
 
36
                                }
 
37
                        }
 
38
                }
 
39
                
 
40
                public void SortLines(IDocument document, int startLine, int endLine, StringComparer comparer, bool removeDuplicates)
 
41
                {
 
42
                        List<string> lines = new List<string>();
 
43
                        for (int i = startLine; i <= endLine; ++i) {
 
44
                                IDocumentLine line = document.GetLine(i);
 
45
                                lines.Add(document.GetText(line.Offset, line.Length));
 
46
                        }
 
47
                        
 
48
                        lines.Sort(comparer);
 
49
                        
 
50
                        if (removeDuplicates) {
 
51
                                lines = lines.Distinct(comparer).ToList();
 
52
                        }
 
53
                        
 
54
                        using (document.OpenUndoGroup()) {
 
55
                                for (int i = 0; i < lines.Count; ++i) {
 
56
                                        IDocumentLine line = document.GetLine(startLine + i);
 
57
                                        document.Replace(line.Offset, line.Length, lines[i]);
 
58
                                }
 
59
                                
 
60
                                // remove removed duplicate lines
 
61
                                for (int i = startLine + lines.Count; i <= endLine; ++i) {
 
62
                                        IDocumentLine line = document.GetLine(startLine + lines.Count);
 
63
                                        document.Remove(line.Offset, line.TotalLength);
 
64
                                }
 
65
                        }
 
66
                }
 
67
                
 
68
                sealed class DescendingStringComparer : StringComparer
 
69
                {
 
70
                        StringComparer baseComparer;
 
71
                        
 
72
                        public DescendingStringComparer(StringComparer baseComparer)
 
73
                        {
 
74
                                this.baseComparer = baseComparer;
 
75
                        }
 
76
                        
 
77
                        public override int Compare(string x, string y)
 
78
                        {
 
79
                                return -baseComparer.Compare(x, y);
 
80
                        }
 
81
                        
 
82
                        public override bool Equals(string x, string y)
 
83
                        {
 
84
                                return baseComparer.Equals(x, y);
 
85
                        }
 
86
                        
 
87
                        public override int GetHashCode(string obj)
 
88
                        {
 
89
                                return baseComparer.GetHashCode(obj);
 
90
                        }
 
91
                }
 
92
                
 
93
                sealed class IgnoreTrailingWhitespaceComparer : StringComparer
 
94
                {
 
95
                        StringComparer baseComparer;
 
96
                        
 
97
                        public IgnoreTrailingWhitespaceComparer(StringComparer baseComparer)
 
98
                        {
 
99
                                this.baseComparer = baseComparer;
 
100
                        }
 
101
                        
 
102
                        public override int Compare(string x, string y)
 
103
                        {
 
104
                                if (x != null)
 
105
                                        x = x.TrimEnd();
 
106
                                if (y != null)
 
107
                                        y = y.TrimEnd();
 
108
                                return baseComparer.Compare(x, y);
 
109
                        }
 
110
                        
 
111
                        public override bool Equals(string x, string y)
 
112
                        {
 
113
                                if (x != null)
 
114
                                        x = x.TrimEnd();
 
115
                                if (y != null)
 
116
                                        y = y.TrimEnd();
 
117
                                return baseComparer.Equals(x, y);
 
118
                        }
 
119
                        
 
120
                        public override int GetHashCode(string obj)
 
121
                        {
 
122
                                if (obj != null)
 
123
                                        obj = obj.TrimEnd();
 
124
                                return baseComparer.GetHashCode(obj);
 
125
                        }
 
126
                }
 
127
        }
 
128
        
 
129
        public static class SortOptions
 
130
        {
 
131
                public static bool RemoveDuplicates {
 
132
                        get { return PropertyService.Get("ICSharpCode.SharpDevelop.Gui.SortOptionsDialog.RemoveDuplicateLines", false); }
 
133
                        set { PropertyService.Set("ICSharpCode.SharpDevelop.Gui.SortOptionsDialog.RemoveDuplicateLines", value); }
 
134
                }
 
135
                
 
136
                public static bool CaseSensitive {
 
137
                        get { return PropertyService.Get("ICSharpCode.SharpDevelop.Gui.SortOptionsDialog.CaseSensitive", true); }
 
138
                        set { PropertyService.Set("ICSharpCode.SharpDevelop.Gui.SortOptionsDialog.CaseSensitive", value); }
 
139
                }
 
140
                
 
141
                public static bool IgnoreTrailingWhitespaces {
 
142
                        get { return PropertyService.Get("ICSharpCode.SharpDevelop.Gui.SortOptionsDialog.IgnoreWhitespaces", false); }
 
143
                        set { PropertyService.Set("ICSharpCode.SharpDevelop.Gui.SortOptionsDialog.IgnoreWhitespaces", value); }
 
144
                }
 
145
                
 
146
                public static SortDirection SortDirection {
 
147
                        get { return PropertyService.Get("ICSharpCode.SharpDevelop.Gui.SortOptionsDialog.SortDirection", SortDirection.Ascending); }
 
148
                        set { PropertyService.Set("ICSharpCode.SharpDevelop.Gui.SortOptionsDialog.SortDirection", value); }
 
149
                }
 
150
        }
 
151
        
 
152
        public enum SortDirection
 
153
        {
 
154
                Ascending,
 
155
                Descending
 
156
        }
 
157
}