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); }