bool IsInComment(SharpDevelopTextAreaControl editor)
{
VBExpressionFinder ef = new VBExpressionFinder();
int cursor = editor.ActiveTextAreaControl.Caret.Offset - 1;
return(ef.FilterComments(editor.Document.GetText(0, cursor + 1), ref cursor) == null);
}
bool DoCaseCompletion(SharpDevelopTextAreaControl editor)
{
ICSharpCode.TextEditor.Caret caret = editor.ActiveTextAreaControl.Caret;
NRefactoryResolver r = new NRefactoryResolver(LanguageProperties.CSharp);
if (r.Initialize(ParserService.GetParseInformation(editor.FileName), caret.Line + 1, caret.Column + 1))
{
AST.INode currentMember = r.ParseCurrentMember(editor.Text);
if (currentMember != null)
{
CaseCompletionSwitchFinder ccsf = new CaseCompletionSwitchFinder(caret.Line + 1, caret.Column + 1);
currentMember.AcceptVisitor(ccsf, null);
if (ccsf.bestStatement != null)
{
r.RunLookupTableVisitor(currentMember);
ResolveResult rr = r.ResolveInternal(ccsf.bestStatement.SwitchExpression, ExpressionContext.Default);
if (rr != null && rr.ResolvedType != null)
{
return(ProvideContextCompletion(editor, rr.ResolvedType, ' '));
}
}
}
}
return(false);
}
public TaskListPad()
{
instance = this;
this.displayedTokens = new Dictionary <string, bool>();
RedrawContent();
InitializeToolStrip();
TaskService.Cleared += new EventHandler(TaskServiceCleared);
TaskService.Added += new TaskEventHandler(TaskServiceAdded);
TaskService.Removed += new TaskEventHandler(TaskServiceRemoved);
TaskService.InUpdateChanged += new EventHandler(TaskServiceInUpdateChanged);
WorkbenchSingleton.Workbench.ActiveViewContentChanged += new EventHandler(WorkbenchActiveViewContentChanged);
if (WorkbenchSingleton.Workbench.ActiveViewContent != null)
{
UpdateItems();
if (WorkbenchSingleton.Workbench.ActiveViewContent.Control is SharpDevelopTextAreaControl)
{
SharpDevelopTextAreaControl ctrl = WorkbenchSingleton.Workbench.ActiveViewContent.Control as SharpDevelopTextAreaControl;
ctrl.ActiveTextAreaControl.Caret.PositionChanged += new EventHandler(CaretPositionChanged);
}
}
ProjectService.SolutionLoaded += OnSolutionOpen;
ProjectService.SolutionClosed += OnSolutionClosed;
ProjectService.CurrentProjectChanged += ProjectServiceCurrentProjectChanged;
this.isInitialized = true;
}
public override bool HandleKeyPress(SharpDevelopTextAreaControl editor, char ch)
{
if (this.CompletionPossible(editor, ch))
{
ResourceResolveResult result = ResourceResolverService.Resolve(editor, ch);
if (result != null)
{
IResourceFileContent content;
if ((content = result.ResourceFileContent) != null)
{
// If the resolved resource set is the local ICSharpCode.Core resource set
// (this may happen through the ICSharpCodeCoreNRefactoryResourceResolver),
// we will have to merge in the host resource set (if available)
// for the code completion window.
if (result.ResourceSetReference.ResourceSetName == ICSharpCodeCoreResourceResolver.ICSharpCodeCoreLocalResourceSetName)
{
IResourceFileContent hostContent = ICSharpCodeCoreResourceResolver.GetICSharpCodeCoreHostResourceSet(editor.FileName).ResourceFileContent;
if (hostContent != null)
{
content = new MergedResourceFileContent(content, new IResourceFileContent[] { hostContent });
}
}
editor.ShowCompletionWindow(new ResourceCodeCompletionDataProvider(content, this.OutputVisitor, result.CallingClass != null ? result.CallingClass.Name + "." : null), ch);
return(true);
}
}
}
return(false);
}
/// <summary>
/// Overrides the base class method so a code completion window is
/// not displayed but the fact that this method is called is
/// recorded.
/// </summary>
protected override void ShowCodeCompletionWindow(SharpDevelopTextAreaControl textAreaControl, ICompletionDataProvider completionDataProvider, char ch)
{
textAreaControlUsedToShowCompletionWindow = textAreaControl;
codeCompletionWindowDisplayed = true;
completionCharacter = ch;
completionProviderUsedWhenDisplayingCodeCompletionWindow = completionDataProvider;
}
bool IsInComment(SharpDevelopTextAreaControl editor)
{
ExpressionFinder ef = new ExpressionFinder(editor.FileName);
int cursor = editor.ActiveTextAreaControl.Caret.Offset - 1;
return(ef.SimplifyCode(editor.Document.GetText(0, cursor + 1), cursor) == null);
}
public override bool InsertAction(ICompletionData data, ICSharpCode.TextEditor.TextArea textArea, int insertionOffset, char key)
{
CodeCompletionData ccData = data as CodeCompletionData;
if (IsAttributeCompletion && ccData != null)
{
textArea.Caret.Position = textArea.Document.OffsetToPosition(insertionOffset);
textArea.InsertString(ccData.Text + "=\"\"");
textArea.Caret.Column -= 1;
SharpDevelopTextAreaControl editor = textArea.MotherTextEditorControl as SharpDevelopTextAreaControl;
if (editor != null)
{
WorkbenchSingleton.SafeThreadAsyncCall(
delegate {
XamlCompletionDataProvider provider = new XamlCompletionDataProvider();
provider.AllowCompleteExistingExpression = true;
editor.ShowCompletionWindow(provider, '\0');
}
);
}
return(false);
}
else
{
return(base.InsertAction(data, textArea, insertionOffset, key));
}
}
public bool HandleKeyPress(SharpDevelopTextAreaControl editor, char ch)
{
if (ch == '<')
{
editor.ShowCompletionWindow(new XamlCompletionDataProvider(XamlExpressionContext.Empty), ch);
return(true);
}
else if (char.IsLetter(ch))
{
int offset = editor.ActiveTextAreaControl.TextArea.Caret.Offset;
if (offset > 0)
{
char c = editor.Document.GetCharAt(offset - 1);
if (c == ' ' || c == '\t')
{
XmlElementPath path = XmlParser.GetActiveElementStartPathAtIndex(editor.Text, offset);
if (path != null && path.Elements.Count > 0)
{
editor.ShowCompletionWindow(
new XamlCompletionDataProvider(
new XamlExpressionContext(path, "", false)
)
{
IsAttributeCompletion = true
}
, '\0');
return(false);
}
}
}
}
return(false);
}
public override void Execute(TextArea services)
{
SharpDevelopTextAreaControl sdtac = (SharpDevelopTextAreaControl)services.MotherTextEditorControl;
services.AutoClearSelection = false;
sdtac.ShowCompletionWindow(new TemplateCompletionDataProvider(), '\0');
}
bool ShowNewCompletion(SharpDevelopTextAreaControl editor)
{
CSharpExpressionFinder ef = CreateExpressionFinder(editor.FileName);
int cursor = editor.ActiveTextAreaControl.Caret.Offset;
string documentToCursor = editor.Document.GetText(0, cursor);
ExpressionResult expressionResult = ef.FindExpression(documentToCursor, cursor);
LoggingService.Debug("ShowNewCompletion: expression is " + expressionResult);
if (expressionResult.Context.IsObjectCreation)
{
LineSegment currentLine = editor.Document.GetLineSegmentForOffset(cursor);
string lineText = editor.Document.GetText(currentLine.Offset, cursor - currentLine.Offset);
// when the new follows an assignment, improve code-completion by detecting the
// type of the variable that is assigned to
if (lineText.Replace(" ", "").EndsWith("=new"))
{
int pos = lineText.LastIndexOf('=');
ExpressionContext context = FindExactContextForNewCompletion(editor, documentToCursor,
currentLine, pos);
if (context != null)
{
expressionResult.Context = context;
}
}
editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(expressionResult.Context), ' ');
return(true);
}
return(false);
}
public bool CtrlSpace(SharpDevelopTextAreaControl editor)
{
XamlCompletionDataProvider provider = new XamlCompletionDataProvider();
provider.AllowCompleteExistingExpression = true;
editor.ShowCompletionWindow(provider, '\0');
return(true);
}
public SharpSnippetCompilerControl()
{
InitializeComponent();
textEditor = new SharpDevelopTextAreaControl();
textEditor.Dock = DockStyle.Fill;
this.Controls.Add(textEditor);
}
public override void Execute(TextArea textArea)
{
SharpDevelopTextAreaControl sdtac = (SharpDevelopTextAreaControl)textArea.MotherTextEditorControl;
CodeCompletionDataProvider ccdp = new CodeCompletionDataProvider();
ccdp.DebugMode = true;
sdtac.ShowCompletionWindow(ccdp, '.');
}
public override void Execute(TextArea textArea)
{
SharpDevelopTextAreaControl sdtac = (SharpDevelopTextAreaControl)textArea.MotherTextEditorControl;
if (!sdtac.ExpandTemplateOnTab())
{
base.Execute(textArea);
}
}
public override void Execute(TextArea textArea)
{
SharpDevelopTextAreaControl sdtac = (SharpDevelopTextAreaControl)textArea.MotherTextEditorControl;
CtrlSpaceCompletionDataProvider provider = new CtrlSpaceCompletionDataProvider();
provider.AllowCompleteExistingExpression = true;
provider.DebugMode = true;
sdtac.ShowCompletionWindow(provider, '\0');
}
bool TryDeclarationTypeInference(SharpDevelopTextAreaControl editor, LineSegment curLine)
{
string lineText = editor.Document.GetText(curLine.Offset, curLine.Length);
ILexer lexer = ParserFactory.CreateLexer(SupportedLanguage.VBNet, new System.IO.StringReader(lineText));
if (lexer.NextToken().Kind != VBTokens.Dim)
{
return(false);
}
if (lexer.NextToken().Kind != VBTokens.Identifier)
{
return(false);
}
if (lexer.NextToken().Kind != VBTokens.As)
{
return(false);
}
Token t1 = lexer.NextToken();
if (t1.Kind != VBTokens.QuestionMark)
{
return(false);
}
Token t2 = lexer.NextToken();
if (t2.Kind != VBTokens.Assign)
{
return(false);
}
string expr = lineText.Substring(t2.Location.Column);
LoggingService.Debug("DeclarationTypeInference: >" + expr + "<");
ResolveResult rr = ParserService.Resolve(new ExpressionResult(expr),
editor.ActiveTextAreaControl.Caret.Line + 1,
t2.Location.Column, editor.FileName,
editor.Document.TextContent);
if (rr != null && rr.ResolvedType != null)
{
ClassFinder context = new ClassFinder(ParserService.GetParseInformation(editor.FileName), editor.ActiveTextAreaControl.Caret.Line, t1.Location.Column);
VBNetAmbience ambience = new VBNetAmbience();
if (CodeGenerator.CanUseShortTypeName(rr.ResolvedType, context))
{
ambience.ConversionFlags = ConversionFlags.None;
}
else
{
ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedTypeNames;
}
string typeName = ambience.Convert(rr.ResolvedType);
editor.Document.Replace(curLine.Offset + t1.Location.Column - 1, 1, typeName);
editor.ActiveTextAreaControl.Caret.Column += typeName.Length - 1;
return(true);
}
return(false);
}
public void SetUpFixture()
{
if (!PropertyService.Initialized)
{
PropertyService.InitializeService(String.Empty, String.Empty, String.Empty);
}
textAreaControl = new SharpDevelopTextAreaControl();
codeCompletionBinding = new DerivedPythonCodeCompletionBinding();
handlesImportKeyword = codeCompletionBinding.HandleKeyword(textAreaControl, "from");
}
public override void Run()
{
SharpDevelopTextAreaControl textEditor = this.Owner as SharpDevelopTextAreaControl;
if (textEditor == null || DebuggerService.CurrentDebugger == null)
{
return;
}
DebuggerService.CurrentDebugger.SetInstructionPointer(textEditor.FileName, textEditor.ActiveTextAreaControl.Caret.Line + 1, textEditor.ActiveTextAreaControl.Caret.Column);
}
ExpressionContext FindExactContextForNewCompletion(SharpDevelopTextAreaControl editor, string documentToCursor,
LineSegment currentLine, int pos)
{
CSharpExpressionFinder ef = CreateExpressionFinder(editor.FileName);
// find expression on left hand side of the assignment
ExpressionResult lhsExpr = ef.FindExpression(documentToCursor, currentLine.Offset + pos);
if (lhsExpr.Expression != null)
{
ResolveResult rr = ParserService.Resolve(lhsExpr, currentLine.LineNumber, pos, editor.FileName, editor.Text);
if (rr != null && rr.ResolvedType != null)
{
ExpressionContext context;
IClass c;
if (rr.ResolvedType.IsArrayReturnType)
{
// when creating an array, all classes deriving from the array's element type are allowed
IReturnType elementType = rr.ResolvedType.CastToArrayReturnType().ArrayElementType;
c = elementType != null?elementType.GetUnderlyingClass() : null;
context = ExpressionContext.TypeDerivingFrom(elementType, false);
}
else
{
// when creating a normal instance, all non-abstract classes deriving from the type
// are allowed
c = rr.ResolvedType.GetUnderlyingClass();
context = ExpressionContext.TypeDerivingFrom(rr.ResolvedType, true);
}
if (c != null && context.ShowEntry(c))
{
// Try to suggest an entry (List<int> a = new => suggest List<int>).
string suggestedClassName = LanguageProperties.CSharp.CodeGenerator.GenerateCode(
CodeGenerator.ConvertType(
rr.ResolvedType,
new ClassFinder(ParserService.GetParseInformation(editor.FileName), editor.ActiveTextAreaControl.Caret.Line + 1, editor.ActiveTextAreaControl.Caret.Column + 1)
), "");
if (suggestedClassName != c.Name)
{
// create an IClass instance that includes the type arguments in its name
context.SuggestedItem = new RenamedClass(c, suggestedClassName);
}
else
{
context.SuggestedItem = c;
}
}
return(context);
}
}
return(null);
}
bool ShowNewCompletion(SharpDevelopTextAreaControl editor)
{
CSharpExpressionFinder ef = new CSharpExpressionFinder(editor.FileName);
int cursor = editor.ActiveTextAreaControl.Caret.Offset;
ExpressionContext context = ef.FindExpression(editor.Document.GetText(0, cursor) + " T.", cursor + 2).Context;
if (context.IsObjectCreation)
{
editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(context), ' ');
return(true);
}
return(false);
}
public override bool HandleKeyPress(SharpDevelopTextAreaControl editor, char ch)
{
if (ch == ':')
{
if (editor.ActiveTextAreaControl.Caret.Offset >= 5 && editor.Document.GetText(editor.ActiveTextAreaControl.Caret.Offset - 5, 5) == "${res")
{
IResourceFileContent content = ICSharpCodeCoreResourceResolver.GetICSharpCodeCoreLocalResourceSet(editor.FileName).ResourceFileContent;
#if DEBUG
if (content != null)
{
LoggingService.Debug("ResourceToolkit: Found local ICSharpCode.Core resource file: " + content.FileName);
}
#endif
IResourceFileContent hostContent = ICSharpCodeCoreResourceResolver.GetICSharpCodeCoreHostResourceSet(editor.FileName).ResourceFileContent;
if (hostContent != null)
{
#if DEBUG
LoggingService.Debug("ResourceToolkit: Found host ICSharpCode.Core resource file: " + hostContent.FileName);
#endif
if (content != null)
{
content = new MergedResourceFileContent(content, new IResourceFileContent[] { hostContent });
}
else
{
content = hostContent;
}
}
if (content != null)
{
editor.ShowCompletionWindow(new ResourceCodeCompletionDataProvider(content, null, null), ch);
return(true);
}
}
}
else if (ch == '$')
{
// Provide ${res: as code completion
// in an ICSharpCode.Core application
if (ICSharpCodeCoreResourceResolver.GetICSharpCodeCoreHostResourceSet(editor.FileName).ResourceFileContent != null ||
ICSharpCodeCoreResourceResolver.GetICSharpCodeCoreLocalResourceSet(editor.FileName).ResourceFileContent != null)
{
editor.ShowCompletionWindow(new ICSharpCodeCoreTagCompletionDataProvider(), ch);
return(true);
}
}
return(false);
}
/// <summary>
/// Shows the code completion window if the keyword is handled.
/// </summary>
/// <param name="word">The keyword string.</param>
/// <returns>true if the keyword is handled; otherwise false.</returns>
public override bool HandleKeyword(SharpDevelopTextAreaControl editor, string word)
{
if (word != null)
{
switch (word.ToLowerInvariant())
{
case "import":
case "from":
ICompletionDataProvider dataProvider = CreateCompletionDataProvider();
ShowCodeCompletionWindow(editor, dataProvider, ' ');
return(true);
}
}
return(false);
}
void WorkbenchActiveViewContentChanged(object sender, EventArgs e)
{
if (WorkbenchSingleton.Workbench.ActiveViewContent == null)
{
return;
}
if (isInitialized)
{
UpdateItems();
}
if (WorkbenchSingleton.Workbench.ActiveViewContent.Control is SharpDevelopTextAreaControl)
{
SharpDevelopTextAreaControl ctrl = WorkbenchSingleton.Workbench.ActiveViewContent.Control as SharpDevelopTextAreaControl;
ctrl.ActiveTextAreaControl.Caret.PositionChanged += new EventHandler(CaretPositionChanged);
}
}
public override void Run()
{
SharpDevelopTextAreaControl textEditor = this.Owner as SharpDevelopTextAreaControl;
WindowsDebugger winDebugger = DebuggerService.CurrentDebugger as WindowsDebugger;
if (textEditor == null || winDebugger == null)
{
return;
}
Breakpoint breakpoint = winDebugger.DebuggerCore.AddBreakpoint(textEditor.FileName, null, textEditor.ActiveTextAreaControl.Caret.Line + 1, textEditor.ActiveTextAreaControl.Caret.Column, true);
breakpoint.Hit += delegate { breakpoint.Remove(); };
winDebugger.DebuggedProcess.Paused += delegate { breakpoint.Remove(); };
if (!winDebugger.IsProcessRunning)
{
winDebugger.Continue();
}
}
public override bool HandleKeyPress(SharpDevelopTextAreaControl editor, char ch)
{
if (ch == '(' && EnableMethodInsight && CodeCompletionOptions.InsightEnabled)
{
editor.ShowInsightWindow(new MethodInsightDataProvider());
return(true);
}
else if (ch == ',' && CodeCompletionOptions.InsightRefreshOnComma && CodeCompletionOptions.InsightEnabled)
{
if (InsightRefreshOnComma(editor, ch))
{
return(true);
}
}
else if (ch == '\n')
{
TryDeclarationTypeInference(editor, editor.Document.GetLineSegmentForOffset(editor.ActiveTextAreaControl.Caret.Offset));
}
return(base.HandleKeyPress(editor, ch));
}
public override bool HandleKeyword(SharpDevelopTextAreaControl editor, string word)
{
switch (word.ToLowerInvariant())
{
case "import":
editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(ExpressionContext.Importable), ' ');
return(true);
case "as":
case "isa":
if (IsInComment(editor))
{
return(false);
}
editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(ExpressionContext.Type), ' ');
return(true);
default:
return(base.HandleKeyword(editor, word));
}
}
bool TryDeclarationTypeInference(SharpDevelopTextAreaControl editor, LineSegment curLine)
{
string lineText = editor.Document.GetText(curLine.Offset, curLine.Length);
ILexer lexer = ParserFactory.CreateLexer(SupportedLanguage.CSharp, new System.IO.StringReader(lineText));
Token typeToken = lexer.NextToken();
if (typeToken.kind == CSTokens.Question)
{
if (lexer.NextToken().kind == CSTokens.Identifier)
{
Token t = lexer.NextToken();
if (t.kind == CSTokens.Assign)
{
string expr = lineText.Substring(t.col);
LoggingService.Debug("DeclarationTypeInference: >" + expr + "<");
ResolveResult rr = ParserService.Resolve(new ExpressionResult(expr),
editor.ActiveTextAreaControl.Caret.Line + 1,
t.col, editor.FileName,
editor.Document.TextContent);
if (rr != null && rr.ResolvedType != null)
{
ClassFinder context = new ClassFinder(editor.FileName, editor.ActiveTextAreaControl.Caret.Line, t.col);
if (CodeGenerator.CanUseShortTypeName(rr.ResolvedType, context))
{
CSharpAmbience.Instance.ConversionFlags = ConversionFlags.None;
}
else
{
CSharpAmbience.Instance.ConversionFlags = ConversionFlags.UseFullyQualifiedNames;
}
string typeName = CSharpAmbience.Instance.Convert(rr.ResolvedType);
editor.Document.Replace(curLine.Offset + typeToken.col - 1, 1, typeName);
editor.ActiveTextAreaControl.Caret.Column += typeName.Length - 1;
return(true);
}
}
}
}
return(false);
}
public override bool HandleKeyPress(SharpDevelopTextAreaControl editor, char ch)
{
if (ch == '[')
{
int cursor = editor.ActiveTextAreaControl.Caret.Offset;
for (int i = cursor - 1; i > 0; i--)
{
char c = editor.Document.GetCharAt(i);
if (c == '\n' || c == '(' || c == ',')
{
// -> Attribute completion
editor.ShowCompletionWindow(new AttributesDataProvider(ExpressionFinder.BooAttributeContext.Instance), ch);
return(true);
}
if (!char.IsWhiteSpace(c))
{
break;
}
}
}
return(base.HandleKeyPress(editor, ch));
}
public EditorTabItem(string moduleName)
{
InitializeComponent();
textEditorControl = new SharpDevelopTextAreaControl();
textEditorControl.Dock = DockStyle.Fill;
textEditorControl.BorderStyle = BorderStyle.Fixed3D;
this.Controls.Add(textEditorControl);
this.TabText = Resources.Document_ + counter;
counter++;
textEditorControl.FileNameChanged += new EventHandler(_EditorControl_FileNameChanged);
textEditorControl.TextChanged += new EventHandler(textEditorControl_TextChanged);
textEditorControl.Tag = this;
this.Padding = new Padding(2, 2, 2, 2);
this.DockableAreas = DockAreas.Document;
secondaryViewContentCollection = new SecondaryViewContentCollection(this);
InitFiles();
file = FileService.CreateUntitledOpenedFile(TabText, new byte[] { });
file.CurrentView = this;
textEditorControl.FileName = file.FileName;
files.Clear();
files.Add(file);
this.SetSyntaxLanguage(moduleName);
this.textEditorControl.ShowMatchingBracket = true;
this.textEditorControl.BracketMatchingStyle = BracketMatchingStyle.Before;
}
/// <summary>
/// Shows the code completion window.
/// </summary>
protected virtual void ShowCodeCompletionWindow(SharpDevelopTextAreaControl textAreaControl, ICompletionDataProvider completionDataProvider, char ch)
{
textAreaControl.ShowCompletionWindow(completionDataProvider, ch);
}
