public WatchInputBox(string text, string caption) : base()
{
InitializeComponent();
// UI
text = StringParser.Parse(text);
this.Title = StringParser.Parse(caption);
this.ConsolePanel.Content = console;
if (ProjectService.CurrentProject == null)
{
language = GetLanguageFromActiveViewContent();
}
else
{
language = GetLanguage(ProjectService.CurrentProject.Language);
}
resolver = new NRefactoryResolver(LanguageProperties.GetLanguage(language.ToString()));
switch (language)
{
case SupportedLanguage.CSharp:
console.SetHighlighting("C#");
break;
case SupportedLanguage.VBNet:
console.SetHighlighting("VBNET");
break;
}
// get process
this.Process = ((WindowsDebugger)DebuggerService.CurrentDebugger).DebuggedProcess;
}
public WatchListAutoCompleteCell()
{
InitializeComponent();
console = new ConsoleControl();
console.TextAreaTextEntered += new TextCompositionEventHandler(consoleControl_TextAreaTextEntered);
console.TextAreaPreviewKeyDown += new KeyEventHandler(console_TextAreaPreviewKeyDown);
console.LostFocus += new RoutedEventHandler(console_LostFocus);
console.HideScrollBar();
ConsolePanel.Content = console;
// get language
if (ProjectService.CurrentProject == null)
{
language = "C#";
}
else
{
language = ProjectService.CurrentProject.Language;
}
resolver = new NRefactoryResolver(LanguageProperties.GetLanguage(language));
// FIXME set language
if (language == "VB" || language == "VBNet")
{
console.SetHighlighting("VBNET");
}
else
{
console.SetHighlighting("C#");
}
}
public override void Run()
{
if (ParserService.LoadSolutionProjectsThreadRunning)
{
return;
}
if (WorkbenchSingleton.Workbench == null)
{
return;
}
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
if (provider == null)
{
return;
}
LanguageProperties language = ParserService.CurrentProjectContent.Language;
if (language == null)
{
return;
}
RefactoringProvider rp = language.RefactoringProvider;
Run(provider.TextEditor, rp);
}
public void AddLanguage(string name)
{
LanguageProperties languageProperties = new LanguageProperties();
languageProperties._name = name;
_languages.Add(languageProperties);
}
// usingMode: 0 = one using-statement for each namespace (correctly cased)
// 1 = mixture of using statements and default imports (incorrectly cased)
// 2 = all default imports (incorrectly cased)
ICompilationUnit Prepare(LanguageProperties language, int usingMode)
{
DefaultProjectContent pc = new DefaultProjectContent();
pc.ReferencedContents.Add(projectContentRegistry.Mscorlib);
pc.Language = language;
DefaultCompilationUnit cu = new DefaultCompilationUnit(pc);
if (usingMode == 1)
{
cu.Usings.Add(CreateUsing(pc, "syStEm.coLLectIons"));
pc.DefaultImports = new DefaultUsing(pc);
pc.DefaultImports.Usings.Add("syStEm");
pc.DefaultImports.Usings.Add("syStEm.coLLEctionS.GeNeRic");
}
else if (usingMode == 2)
{
pc.DefaultImports = new DefaultUsing(pc);
pc.DefaultImports.Usings.Add("syStEm");
pc.DefaultImports.Usings.Add("syStEm.coLLEctioNs");
pc.DefaultImports.Usings.Add("syStEm.coLLEctionS.GeNeRic");
}
else // usingMode == 0
{
cu.Usings.Add(CreateUsing(pc, "System"));
cu.Usings.Add(CreateUsing(pc, "System.Collections"));
cu.Usings.Add(CreateUsing(pc, "System.Collections.Generic"));
}
return(cu);
}
public ToolStripItem[] BuildSubmenu(Codon codon, object owner)
{
List <ToolStripItem> resultItems = new List <ToolStripItem>();
RefactoringMenuContext context = (RefactoringMenuContext)owner;
LocalResolveResult lrr = context.ResolveResult as LocalResolveResult;
if (lrr == null || lrr.CallingClass == null || lrr.ResolvedType == null)
{
return(resultItems.ToArray());
}
LanguageProperties language = lrr.CallingClass.ProjectContent.Language;
if (language != LanguageProperties.CSharp)
{
return(resultItems.ToArray());
}
IClass parameterTypeClass = lrr.ResolvedType.GetUnderlyingClass();
if (parameterTypeClass == null || parameterTypeClass.ClassType != ClassType.Enum && parameterTypeClass.ClassType != ClassType.Struct)
{
// the parameter is a reference type
resultItems.Add(MakeItem("Add check for null", delegate { AddCheckForNull(context); }));
}
if (parameterTypeClass != null)
{
if (parameterTypeClass.FullyQualifiedName == "System.Int32")
{
resultItems.Add(MakeItem("Add range check", delegate { AddRangeCheck(context); }));
}
}
return(resultItems.ToArray());
}
public NRefactoryInsightWindowHandler(SupportedLanguage language)
{
this.language = language;
if (language == SupportedLanguage.CSharp)
{
eofToken = CSTokens.EOF;
commaToken = CSTokens.Comma;
openParensToken = CSTokens.OpenParenthesis;
closeParensToken = CSTokens.CloseParenthesis;
openBracketToken = CSTokens.OpenSquareBracket;
closeBracketToken = CSTokens.CloseSquareBracket;
openBracesToken = CSTokens.OpenCurlyBrace;
closeBracesToken = CSTokens.CloseCurlyBrace;
statementEndToken = CSTokens.Semicolon;
languageProperties = LanguageProperties.CSharp;
}
else
{
eofToken = VBTokens.EOF;
commaToken = VBTokens.Comma;
openParensToken = VBTokens.OpenParenthesis;
closeParensToken = VBTokens.CloseParenthesis;
openBracketToken = -1;
closeBracketToken = -1;
openBracesToken = VBTokens.OpenCurlyBrace;
closeBracesToken = VBTokens.CloseCurlyBrace;
statementEndToken = VBTokens.EOL;
languageProperties = LanguageProperties.VBNet;
}
}
protected virtual void OKButtonClick(object sender, RoutedEventArgs e)
{
ParseInformation parseInfo = ParserService.GetParseInformation(editor.FileName);
if (optionBindings != null)
{
foreach (OptionBinding binding in optionBindings)
{
binding.Save();
}
}
if (parseInfo != null)
{
LanguageProperties language = parseInfo.CompilationUnit.Language;
IClass current = parseInfo.CompilationUnit.GetInnermostClass(anchor.Line, anchor.Column);
using (editor.Document.OpenUndoGroup()) {
// GenerateCode could modify the document.
// So read anchor.Offset after code generation.
string code = GenerateCode(language, current) ?? "";
editor.Document.Insert(anchor.Offset, code);
}
}
Deactivate();
}
public static NRefactoryResolver CreateResolverForContext(LanguageProperties language, ITextEditor context)
{
NRefactoryResolver resolver = new NRefactoryResolver(language);
resolver.Initialize(ParserService.GetParseInformation(context.FileName), context.Caret.Line, context.Caret.Column);
return(resolver);
}
protected NRefactoryCodeCompletionBinding(SupportedLanguage language)
{
this.language = language;
if (language == SupportedLanguage.CSharp)
{
eofToken = CSTokens.EOF;
commaToken = CSTokens.Comma;
openParensToken = CSTokens.OpenParenthesis;
closeParensToken = CSTokens.CloseParenthesis;
openBracketToken = CSTokens.OpenSquareBracket;
closeBracketToken = CSTokens.CloseSquareBracket;
openBracesToken = CSTokens.OpenCurlyBrace;
closeBracesToken = CSTokens.CloseCurlyBrace;
languageProperties = LanguageProperties.CSharp;
}
else
{
eofToken = VBTokens.EOF;
commaToken = VBTokens.Comma;
openParensToken = VBTokens.OpenParenthesis;
closeParensToken = VBTokens.CloseParenthesis;
openBracketToken = -1;
closeBracketToken = -1;
openBracesToken = VBTokens.OpenCurlyBrace;
closeBracesToken = VBTokens.CloseCurlyBrace;
languageProperties = LanguageProperties.VBNet;
}
}
public NRefactoryResolver(IProjectContent projectContent, LanguageProperties languageProperties)
{
if (projectContent == null)
{
throw new ArgumentNullException("projectContent");
}
if (languageProperties == null)
{
throw new ArgumentNullException("languageProperties");
}
this.languageProperties = languageProperties;
this.projectContent = projectContent;
if (languageProperties is LanguageProperties.CSharpProperties)
{
language = NR.SupportedLanguage.CSharp;
}
else if (languageProperties is LanguageProperties.VBNetProperties)
{
language = NR.SupportedLanguage.VBNet;
}
else
{
throw new NotSupportedException("The language " + languageProperties.ToString() + " is not supported in the resolver");
}
}
static void MoveClassToFile(IClass c, string newFileName)
{
LanguageProperties language = c.ProjectContent.Language;
string existingCode = ParserService.GetParseableFileContent(c.CompilationUnit.FileName);
DomRegion fullRegion = language.RefactoringProvider.GetFullCodeRangeForType(existingCode, c);
if (fullRegion.IsEmpty)
{
return;
}
string newCode = ExtractCode(c, fullRegion, c.BodyRegion.BeginLine);
newCode = language.RefactoringProvider.CreateNewFileLikeExisting(existingCode, newCode);
IWorkbenchWindow window = FileService.NewFile(newFileName, "Text", newCode);
window.ViewContent.Save(newFileName);
IProject project = (IProject)c.ProjectContent.Project;
if (project != null)
{
FileProjectItem projectItem = new FileProjectItem(project, ItemType.Compile);
projectItem.FileName = newFileName;
ProjectService.AddProjectItem(project, projectItem);
project.Save();
ProjectBrowserPad.Instance.ProjectBrowserControl.RefreshView();
}
}
public override ICompletionItemList GenerateCompletionList(ITextEditor editor)
{
ParseInformation parseInfo = ParserService.GetParseInformation(editor.FileName);
if (parseInfo == null)
{
return(null);
}
IClass c = parseInfo.CompilationUnit.GetInnermostClass(editor.Caret.Line, editor.Caret.Column);
if (c == null)
{
return(null);
}
LanguageProperties language = c.ProjectContent.Language;
OverrideCompletionItemList result = new OverrideCompletionItemList();
foreach (IMember m in GetOverridableMembers(c))
{
if (language.ShowMemberInOverrideCompletion(m))
{
result.Items.Add(new OverrideCompletionItem(m));
}
}
result.SortItems();
return(result);
}
public NRefactoryCtrlSpaceCompletionItemProvider(LanguageProperties language)
{
if (language == null)
{
throw new ArgumentNullException("language");
}
this.language = language;
}
public NRefactoryCtrlSpaceCompletionItemProvider(LanguageProperties language, ExpressionContext overrideContext)
: base(overrideContext)
{
if (language == null)
{
throw new ArgumentNullException("language");
}
this.language = language;
}
public CompilationUnitHelper()
{
CompilationUnit = MockRepository.GenerateStub <ICompilationUnit>();
LanguageProperties language = MockRepository.GenerateStub <LanguageProperties>(StringComparer.InvariantCultureIgnoreCase);
language.Stub(lang => lang.CodeGenerator).Return(FakeCodeGenerator);
CompilationUnit.Stub(unit => unit.Language).Return(language);
CompilationUnit.Stub(unit => unit.Classes).Return(Classes);
CompilationUnit.Stub(unit => unit.UsingScope).Return(UsingScopeHelper.UsingScope);
}
public NRefactoryCtrlSpaceCompletionItemProvider(LanguageProperties language, IProjectContent projectContent)
: base(projectContent)
{
if (language == null)
{
throw new ArgumentNullException("language");
}
_language = language;
_projectContent = projectContent;
}
protected NRefactoryCodeCompletionBinding(SupportedLanguage language,
IProjectContent projectContent,
ICompletionItemProviderFactory completionItemProviderFactory)
{
ProjectContent = projectContent;
CompletionItemProviderFactory = completionItemProviderFactory;
_languageProperties = language == SupportedLanguage.CSharp ? LanguageProperties.CSharp : LanguageProperties.VBNet;
insightHandler = new NRefactoryInsightWindowHandler(language, ProjectContent);
}
protected void LoadLanguageAudioClip(LanguageProperties language)
{
string str = language._languageFolder + "/" + _audioClipReference.Replace(".wav", "");
str += language._languagePrefix;
str = str.Replace("\\", "/");
if (_dialogAudioLoadedFrom == DialogAudioLoadedFrom.Resources)
{
base.AudioClip = (Resources.Load(str) as AudioClip);
}
}
public LanguageProperties Define(string path)
{
var result = new LanguageProperties();
FileInfo info = new FileInfo(path);
if (!_languages.TryGetValue(info.Extension, out result))
{
throw new Exception("Unsupported programming language.");
}
return(result);
}
public void AddNamespaceContents(ArrayList list, string subNameSpace, LanguageProperties language, bool lookInReferences)
{
// Add the namespaces to the list.
foreach (string ns in namespacesToAdd)
{
list.Add(ns);
}
// Add the classes in this project content.
foreach (IClass c in classesInProjectContent)
{
list.Add(c);
}
}
protected NRefactoryCodeCompletionBinding(SupportedLanguage language)
{
this.language = language;
if (language == SupportedLanguage.CSharp)
{
languageProperties = LanguageProperties.CSharp;
}
else
{
languageProperties = LanguageProperties.VBNet;
}
insightHandler = new NRefactoryInsightWindowHandler(language);
}
void CheckNamespace(string @namespace, string className, LanguageProperties language)
{
ICompilationUnit cu = Prepare(language);
string ns = cu.ProjectContent.SearchNamespace(@namespace, null, cu, 1, 1);
Assert.IsNotNull(ns, @namespace + " not found");
foreach (object o in cu.ProjectContent.GetNamespaceContents(ns))
{
IClass c = o as IClass;
if (c != null && c.Name == className)
{
return;
}
}
}
StringComparer GetNameComparer(IClass c)
{
if (c != null)
{
IProjectContent projectContent = c.ProjectContent;
if (projectContent != null)
{
LanguageProperties language = projectContent.Language;
if (language != null)
{
return(language.NameComparer);
}
}
}
return(null);
}
public bool IsValid(object caller, Condition condition)
{
if (WorkbenchSingleton.Workbench == null)
{
return(false);
}
ITextEditorProvider provider = WorkbenchSingleton.Workbench.ActiveViewContent as ITextEditorProvider;
if (provider == null)
{
return(false);
}
LanguageProperties language = ParserService.CurrentProjectContent.Language;
if (language == null)
{
return(false);
}
if (string.IsNullOrEmpty(provider.TextEditor.FileName))
{
return(false);
}
RefactoringProvider rp = language.RefactoringProvider;
if (!rp.IsEnabledForFile(provider.TextEditor.FileName))
{
return(false);
}
string supports = condition.Properties["supports"];
if (supports == "*")
{
return(true);
}
Type t = rp.GetType();
try {
return((bool)t.InvokeMember("Supports" + supports, BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetProperty, null, rp, null));
} catch (Exception ex) {
LoggingService.Warn(ex.ToString());
return(false);
}
}
ICompilationUnit Prepare(LanguageProperties language)
{
DefaultProjectContent pc = new DefaultProjectContent();
pc.ReferencedContents.Add(projectContentRegistry.Mscorlib);
pc.Language = language;
DefaultCompilationUnit cu = new DefaultCompilationUnit(pc);
if (language == LanguageProperties.VBNet)
{
cu.Usings.Add(CreateUsing(pc, "syStEm"));
}
else
{
cu.Usings.Add(CreateUsing(pc, "System"));
}
return(cu);
}
private IEnumerator LoadPlayCoroutine(ComponentInstance zComponentInstance, float target, float curve, bool dontPlayComponents)
{
int languageIndex = FabricManager.Instance.GetLanguageIndex();
if (languageIndex >= 0)
{
LanguageProperties language = FabricManager.Instance.GetLanguagePropertiesByIndex(languageIndex);
if (language != null)
{
_loadPlayCoroutineActive = true;
yield return(StartCoroutine(FabricManager.Instance._customAudioClipLoader.LoadAudioClip(_audioClipReference, language)));
base.AudioClip = FabricManager.Instance._customAudioClipLoader._audioClip;
base.PlayInternal(zComponentInstance, target, curve, dontPlayComponents);
_loadPlayCoroutineActive = false;
}
}
}
private void Load()
{
string text = GetAudioClipReferenceFilename();
if (_languageSupported)
{
int languageIndex = FabricManager.Instance.GetLanguageIndex();
if (languageIndex >= 0)
{
LanguageProperties languagePropertiesByIndex = FabricManager.Instance.GetLanguagePropertiesByIndex(languageIndex);
if (languagePropertiesByIndex != null)
{
text = text.Replace("LANGUAGE", languagePropertiesByIndex._languageFolder);
}
}
}
www = new WWW(text);
base.AudioClip = WWWAudioExtensions.GetAudioClip(www, _is3D, _isStreaming, _audioType);
}
public void AddNamespaceContents(ArrayList list, string subNameSpace, LanguageProperties language, bool lookInReferences)
{
addNamespaceContentsCalled = true;
namespaceAddedName = subNameSpace;
this.lookInReferences = lookInReferences;
languagePassedToAddNamespaceContents = language;
// Add the namespaces to the list.
foreach (string ns in namespacesToAdd)
{
list.Add(ns);
}
// Add the classes in this project content.
foreach (IClass c in classesInProjectContent)
{
list.Add(c);
}
}
protected override string GenerateCode(LanguageProperties language, IClass currentClass)
{
string[] fields = listBox.SelectedItems.OfType <PropertyOrFieldWrapper>().Select(f2 => f2.MemberName).ToArray();
Ast.PrimitiveExpression formatString = new Ast.PrimitiveExpression(GenerateFormatString(currentClass, language.CodeGenerator, fields));
List <Ast.Expression> param = new List <Ast.Expression>()
{
formatString
};
Ast.ReturnStatement ret = new Ast.ReturnStatement(new Ast.InvocationExpression(
new Ast.MemberReferenceExpression(new Ast.TypeReferenceExpression(new Ast.TypeReference("System.String", true)), "Format"),
param.Concat(fields.Select(f => new Ast.IdentifierExpression(f))).ToList()
));
insertedCode = language.CodeGenerator.GenerateCode(ret, "").Trim();
return(insertedCode);
}
