← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/Debugger/Debugger.AddIn/Pads/Controls/ConditionCell.xaml.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/Debugger/Debugger.AddIn/Pads/Controls/ConditionCell.xaml.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.IO;
 
6
using System.Windows;
 
7
using System.Windows.Controls;
 
8
using System.Windows.Input;
 
9
 
 
10
using ICSharpCode.AvalonEdit;
 
11
using ICSharpCode.Core;
 
12
using ICSharpCode.Core.Presentation;
 
13
using ICSharpCode.NRefactory;
 
14
using ICSharpCode.SharpDevelop;
 
15
using ICSharpCode.SharpDevelop.Bookmarks.Pad.Controls;
 
16
using ICSharpCode.SharpDevelop.Debugging;
 
17
using ICSharpCode.SharpDevelop.Dom;
 
18
using ICSharpCode.SharpDevelop.Dom.NRefactoryResolver;
 
19
using ICSharpCode.SharpDevelop.Editor;
 
20
using ICSharpCode.SharpDevelop.Editor.CodeCompletion;
 
21
using ICSharpCode.SharpDevelop.Gui;
 
22
using ICSharpCode.SharpDevelop.Project;
 
23
 
 
24
namespace Debugger.AddIn.Pads.Controls
 
25
{
 
26
        public partial class ConditionCell : UserControl
 
27
        {
 
28
                private string language;
 
29
                
 
30
                protected ConsoleControl console;
 
31
                
 
32
                public static readonly DependencyProperty CommandTextProperty =
 
33
                        DependencyProperty.Register("CommandText", typeof(string), typeof(ConditionCell),
 
34
                                                    new UIPropertyMetadata(null, new PropertyChangedCallback(OnCommandTextChanged)));
 
35
                
 
36
                private NRefactoryResolver resolver;
 
37
                
 
38
                public ConditionCell()
 
39
                {
 
40
                        InitializeComponent();
 
41
                        
 
42
                        console = new ConsoleControl();                 
 
43
                        console.TextAreaTextEntered += new TextCompositionEventHandler(consoleControl_TextAreaTextEntered);
 
44
                        console.TextAreaPreviewKeyDown += new KeyEventHandler(console_TextAreaPreviewKeyDown);
 
45
                        console.LostFocus += new RoutedEventHandler(console_LostFocus);
 
46
                        console.HideScrollBar();
 
47
                        ConsolePanel.Content = console;
 
48
                        
 
49
                        // get language
 
50
                        if (ProjectService.CurrentProject == null) 
 
51
                                language = "C#";
 
52
                        else
 
53
                                language = ProjectService.CurrentProject.Language;
 
54
                        resolver = new NRefactoryResolver(LanguageProperties.GetLanguage(language));
 
55
                        
 
56
                        // FIXME set language
 
57
                        if (language == "VB" || language == "VBNet") {
 
58
                                console.SetHighlighting("VBNET");
 
59
                        }
 
60
                        else {
 
61
                                console.SetHighlighting("C#");
 
62
                        }
 
63
                }
 
64
                
 
65
                /// <summary>
 
66
                /// Gets/sets the command text displayed at the command prompt.
 
67
                /// </summary>
 
68
                public string CommandText { 
 
69
                        get { return console.CommandText.Trim(); }
 
70
                        set { console.CommandText = value; }
 
71
                }
 
72
                
 
73
                private BreakpointBookmark Breakpoint {
 
74
                        get {
 
75
                                var model = Model;
 
76
                                return model.Mark as BreakpointBookmark;
 
77
                        }
 
78
                }
 
79
                
 
80
                private ListViewPadItemModel Model {
 
81
                        get { return Tag as ListViewPadItemModel; }
 
82
                }
 
83
                
 
84
                private ITextEditor TextEditor {
 
85
                        get {
 
86
                                return console.TextEditor;
 
87
                        }
 
88
                }
 
89
                
 
90
                private void console_TextAreaPreviewKeyDown(object sender, KeyEventArgs e)
 
91
                {
 
92
                        if (e.Key == Key.Return || e.Key == Key.Escape) {
 
93
                                
 
94
                                if (e.Key == Key.Escape) 
 
95
                                        CommandText = string.Empty;
 
96
                                else {
 
97
                                        if(!CheckSyntax())
 
98
                                        return;
 
99
                                }
 
100
                                
 
101
                                UpdateBreakpoint();
 
102
                                
 
103
                                e.Handled = true;
 
104
                        }
 
105
                }
 
106
                
 
107
                private void console_LostFocus(object sender, RoutedEventArgs e)
 
108
                {
 
109
                        if (string.IsNullOrEmpty(CommandText) || !this.CheckSyntax())
 
110
                                return;
 
111
                        
 
112
                        UpdateBreakpoint();
 
113
                }
 
114
                
 
115
                private void UpdateBreakpoint()
 
116
                {
 
117
                        Breakpoint.Condition = CommandText;
 
118
                        Model.Condition = CommandText;                          
 
119
                        Breakpoint.ScriptLanguage = language;
 
120
                        Model.Language = language;
 
121
                                        
 
122
                        if (!string.IsNullOrEmpty(console.CommandText)) {
 
123
                                Breakpoint.Action = BreakpointAction.Condition;
 
124
                                if (Breakpoint.IsEnabled)
 
125
                                        Model.Image = BreakpointBookmark.BreakpointConditionalImage.ImageSource;
 
126
                        }
 
127
                        else {
 
128
                                Breakpoint.Action = BreakpointAction.Break;
 
129
                                if (Breakpoint.IsEnabled)
 
130
                                        Model.Image = BreakpointBookmark.BreakpointImage.ImageSource;
 
131
                        }
 
132
                }
 
133
                
 
134
                private bool CheckSyntax()
 
135
                {
 
136
                        string command = CommandText;
 
137
                        if (string.IsNullOrEmpty(command))
 
138
                                return true;
 
139
                        
 
140
                        // FIXME workaround the NRefactory issue that needs a ; at the end
 
141
                        if (language == "C#") {
 
142
                                if(!command.EndsWith(";"))
 
143
                                        command += ";";
 
144
                                // FIXME only one string should be available; highlighting expects C#, supproted language, CSharp
 
145
                                language = "CSharp";
 
146
                        }
 
147
                        
 
148
                        SupportedLanguage supportedLanguage = (SupportedLanguage)Enum.Parse(typeof(SupportedLanguage), language.ToString(), true);
 
149
                        using (var parser = ParserFactory.CreateParser(supportedLanguage, new StringReader(TextEditor.Document.Text))) {
 
150
                                parser.ParseExpression();
 
151
                                if (parser.Errors.Count > 0) {
 
152
                                        MessageService.ShowError(parser.Errors.ErrorOutput);
 
153
                                        return false;
 
154
                                }
 
155
                        }
 
156
                        
 
157
                        return true;
 
158
                }
 
159
        
 
160
                private void consoleControl_TextAreaTextEntered(object sender, TextCompositionEventArgs e)
 
161
                {       
 
162
                        foreach (char ch in e.Text) {
 
163
                                if (ch == '.') {
 
164
                                        ShowDotCompletion(console.CommandText);
 
165
                                }
 
166
                        }
 
167
                }
 
168
                
 
169
                private void ShowDotCompletion(string currentText)
 
170
                {
 
171
                        var seg = Breakpoint;
 
172
                        
 
173
                        var expressionFinder = ParserService.GetExpressionFinder(seg.FileName.ToString());
 
174
                        var info = ParserService.GetParseInformation(seg.FileName.ToString());
 
175
                        
 
176
                        string text = ParserService.GetParseableFileContent(seg.FileName.ToString()).Text;
 
177
                        
 
178
                        int currentOffset = TextEditor.Caret.Offset - console.CommandOffset - 1;
 
179
                        
 
180
                        var expr = expressionFinder.FindExpression(currentText, currentOffset);
 
181
                        
 
182
                        expr.Region = new DomRegion(seg.LineNumber, seg.ColumnNumber, seg.LineNumber, seg.ColumnNumber);
 
183
                        
 
184
                        var rr = resolver.Resolve(expr, info, text);
 
185
                        
 
186
                        if (rr != null) {
 
187
                                TextEditor.ShowCompletionWindow(new DotCodeCompletionItemProvider().GenerateCompletionListForResolveResult(rr, expr.Context));
 
188
                        }
 
189
                }
 
190
                
 
191
                private static void OnCommandTextChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
 
192
                        var cell = d as ConditionCell;
 
193
                        cell.CommandText = e.NewValue.ToString();
 
194
                }
 
195
        }
 
196
}
 
 
b'\\ No newline at end of file'