public SyntaxTreeNode Parse(VBProject project) { var nodes = new List <SyntaxTreeNode>(); try { var components = project.VBComponents.Cast <VBComponent>().ToList(); foreach (var component in components) { var lineCount = component.CodeModule.CountOfLines; if (lineCount <= 0) { continue; } var code = component.CodeModule.Lines[1, lineCount]; var isClassModule = component.Type == vbext_ComponentType.vbext_ct_ClassModule || component.Type == vbext_ComponentType.vbext_ct_Document || component.Type == vbext_ComponentType.vbext_ct_MSForm; nodes.Add(Parse(project.Name, component.Name, code, isClassModule)); } } catch { // todo: handle exception like a chief Debug.Assert(false); } return(new ProjectNode(project, nodes)); }
public static void make_excel_file(String csv_filename) { Excel.Application excel = new Excel.Application(); excel.Visible = true; excel.DisplayAlerts = false; Excel.Workbook workbook = excel.Workbooks.Add(); Excel.Worksheet worksheet = workbook.Worksheets["Sheet1"]; VBProject project = workbook.VBProject; VBComponent component = project.VBComponents.Add(vbext_ComponentType.vbext_ct_StdModule); component.CodeModule.AddFromString(String.Format(Properties.Resources.items_info_macro, csv_filename)); excel.Run("items_info_macro"); project.VBComponents.Remove(component); String xlsx_filename = utility.show_save_dialog("Excel Workbook (*.xlsx)|*.xlsx|All Files (*.*)|*.*", 1); if (xlsx_filename != "") { workbook.SaveAs(xlsx_filename); } workbook.Close(); excel.Quit(); Marshal.ReleaseComObject(workbook); Marshal.ReleaseComObject(excel); }
public GitProvider(VBProject project, RepositorySettings repoSettings) { _project = project; _unsyncedLocalCommits = new List <Commit>(); _unsyncedRemoteCommits = new List <Commit>(); _repo = new Repository(repoSettings.LocalPath); }
private string GetReferenceProjectId(Reference reference, IReadOnlyList <VBProject> projects) { VBProject project = null; foreach (var item in projects) { try { if (item.FileName == reference.FullPath) { project = item; } } catch (IOException) { // Filename throws exception if unsaved. } } if (project != null) { return(QualifiedModuleName.GetProjectId(project)); } return(QualifiedModuleName.GetProjectId(reference)); }
/// <summary> /// Exports all code modules in the VbProject to a destination directory. Files are given the same name as their parent code Module name and file extensions are based on what type of code Module it is. /// </summary> /// <param name="project">The <see cref="VBProject"/> to be exported to source files.</param> /// <param name="directoryPath">The destination directory path.</param> public static void ExportSourceFiles(this VBProject project, string directoryPath) { foreach (VBComponent component in project.VBComponents) { component.ExportAsSourceFile(directoryPath); } }
public void Indent(VBProject project) { if (project == null) { throw new ArgumentNullException("project"); } if (project.Protection == vbext_ProjectProtection.vbext_pp_locked) { throw new InvalidOperationException("Project is protected."); } var lineCount = 0; // to set progressbar max value if (project.VBComponents.Cast<VBComponent>().All(component => !HasCode(component.CodeModule, ref lineCount))) { throw new InvalidOperationException("Project contains no code."); } _originalTopLine = _vbe.ActiveCodePane.TopLine; _originalSelection = GetSelection(_vbe.ActiveCodePane); var progress = 0; // to set progressbar value foreach (var component in project.VBComponents.Cast<VBComponent>().Where(component => HasCode(component.CodeModule))) { Indent(component, true, progress); progress += component.CodeModule.CountOfLines; } _vbe.ActiveCodePane.TopLine = _originalTopLine; _vbe.ActiveCodePane.SetSelection(_originalSelection.StartLine, _originalSelection.StartColumn, _originalSelection.EndLine, _originalSelection.EndColumn); }
/// <summary> /// Create new repository for project /// </summary> /// <param name="project">VBProject</param> public void CreateNewRepo(VBProject project) { try { EnableFileSystemWatcher = false; using (var gitCommand = new CommandInit(project)) { gitCommand.Execute(); if (gitCommand.Status == CommandStatus.Success) { RepositorySettings repo = new RepositorySettings(); repo.Name = project.GetRepoName(); repo.LocalPath = gitCommand.Repository.Info.WorkingDirectory; if (!_config.Repositories.Exists(r => (r.Name == repo.Name && r.LocalPath == repo.LocalPath && r.RemotePath == repo.RemotePath))) { _config.Repositories.Add(repo); _configService.SaveConfiguration(_config); } AddVBProject(project); } } } finally { EnableFileSystemWatcher = true; } }
public static IEnumerable <string> ComponentNames(this VBProject project) { foreach (VBComponent component in project.VBComponents) { yield return(component.Name); } }
private static string GetNextTestModuleName(VBProject project) { var names = project.ComponentNames(); var index = names.Count(n => n.StartsWith(TestModuleBaseName)) + 1; return string.Concat(TestModuleBaseName, index); }
/// <summary> /// Performs additional checks before importing. /// Checks if given component name can be found in active project. If so, will check /// its type and if the type is a document type, it will insert text inside the component /// instead of importing it. If the component is recognized as a class, will import it standard way. /// </summary> /// <param name="vbe">a reference to the VBE</param> /// <param name="item">a form to be imported</param> /// <param name="shouldOverride">true if the component should be overridden</param> public void Import(VBE vbe, Component item, bool shouldOverride) { VBProject vbProject = vbe.ActiveVBProject; IEnumerable <CodeModule> module = Extensions.VbeExtensions.FindCodeModules(vbe, item.ToString()); if (module == null || !module.ToArray().Any()) { //the component name was not found in the active project, import it standard way vbProject.VBComponents.Import(item.FullPath); } else { if (module.ToArray()[0].Parent.Type == vbext_ComponentType.vbext_ct_ClassModule) { // the item with the same name is not a document type => was replaced in calling method, we can import standard way vbProject.VBComponents.Import(item.FullPath); } else { // here is the interesting part, the imported item has the same name as one of the document type component // user want's to replace it, which is not possible for that type, so we will copy text of the imported item // to the module with the same name (its text was removed in calling method) module.ToArray()[0].AddFromFile(item.FullPath); } } }
/// <summary> /// Bevan Test Add Component method /// We can't use reflection to call the classes by name /// </summary> /// <param name="xlApp">Excel application object</param> /// <param name="sClassName">Validator Class Name</param> /// <returns>The Validator Class Reference</returns> private object GetVBAClass(Excel.Application xlApp, string sClassName) { // Grab the Class component being passed in from name // If this errors: // Click the Trust Center tab, and then click Trust Center Settings. // Click the Macro Settings tab, click to select the Trust access to the VBA project object model check box VBProject xlProj = xlApp.VBE.ActiveVBProject; VBComponent compVal = xlProj.VBComponents.Item(sClassName); // Function name to run string sFunctionName = "UNIT_TEST" + sClassName; // Add a new module/function VBComponent compModule = xlProj.VBComponents.Add(vbext_ComponentType.vbext_ct_StdModule); compModule.CodeModule.InsertLines( compModule.CodeModule.CountOfLines + 1, "Public Function " + sFunctionName + "() As " + sClassName + "\r\n Set " + sFunctionName + " = New " + sClassName + "\r\n End Function"); // Run the function object val = xlApp._Run2(sFunctionName); // Remove the function xlProj.VBComponents.Remove(compModule); // Clean the COM references System.Runtime.InteropServices.Marshal.FinalReleaseComObject(compModule); System.Runtime.InteropServices.Marshal.FinalReleaseComObject(compVal); System.Runtime.InteropServices.Marshal.FinalReleaseComObject(xlProj); // Return the object return(val); }
public void RecreateMenu(VBProject project) { int windowMenuId = 30038; var menuBarControls = _app.IDE.CommandBars[1].Controls; var beforeIndex = FindMenuInsertionIndex(menuBarControls, windowMenuId); if (_menu != null) { UnsubsribeCommandBarButtonClickEvents(); beforeIndex = _menu.Index; _menu.Delete(); } _menu = menuBarControls.Add(MsoControlType.msoControlPopup, Before: beforeIndex, Temporary: true) as CommandBarPopup; _menu.Tag = "VBAGit"; _menu.Caption = VBAGitUI.VBAGitMenu; if (_app.GetVBProjectRepository(project) != null) { _gitSync = AddButton(_menu, VBAGitUI.VBAGitMenu_Sync, false, OnGitSync, "git_sync"); _gitCommit = AddButton(_menu, VBAGitUI.VBAGitMenu_Commit, false, OnGitCommit, "git_commit"); _gitPull = AddButton(_menu, VBAGitUI.VBAGitMenu_Pull, true, OnGitPull, "git_pull"); _gitFetch = AddButton(_menu, VBAGitUI.VBAGitMenu_Fecth, false, OnGitFetch, "git_pull"); _gitPush = AddButton(_menu, VBAGitUI.VBAGitMenu_Push, false, OnGitPush, "git_push"); AddVBAGitMenu(true); } else { _gitCreate = AddButton(_menu, VBAGitUI.VBAGitMenu_Create, false, OnGitCreate, "create_repo"); AddVBAGitMenu(false); } }
/// <summary> /// Removes All VbComponents from the VbProject. /// </summary> /// <remarks> /// Document type Components cannot be physically removed from a project through the VBE. /// Instead, the code will simply be deleted from the code Module. /// </remarks> /// <param name="project"></param> public static void RemoveAllComponents(this VBProject project) { foreach (VBComponent component in project.VBComponents) { project.VBComponents.RemoveSafely(component); } }
/// <summary> /// Insert the sample macro code into the specified VBProject and call the code from VSTO. /// </summary> /// <param name="prj">Target VBProject.</param> /// <returns>The return value from the VBA function.</returns> private object InsertAndRun(VBProject prj) { // Check for existing module. foreach (VBComponent component in prj.VBComponents) { if (component.Name == ModuleName) { throw new ApplicationException("There is already a " + ModuleName + " in this VBA project."); } } // Add a standard module VBComponent mod = prj.VBComponents.Add(vbext_ComponentType.vbext_ct_StdModule); // Name the module mod.Name = ModuleName; // Add code into the module directly from a string. mod.CodeModule.AddFromString(txtVbaSub.Text); // Call the newly added VBA function. // The first parameter to the function is a string "VSTO". return(Globals.ThisAddIn.Application.Run(VbaFunctionName, "VSTO", Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing)); }
private static string GetProjectDefinitionXml(VBProject project) { var sb = new StringBuilder() .AppendLine($"<Project") .AppendLine($" Name='{project.Name}'") .AppendLine($" FileName='{project.FileName}'") .AppendLine($" HelpContextID='{project.HelpContextID}'") .AppendLine($" HelpFile='{project.HelpFile}'") .AppendLine($" Protection='{project.Protection}'") .AppendLine($" Type='{project.Type}'") .AppendLine($">"); foreach (Reference r in project.References) { sb.AppendLine($" <References") .AppendLine($" Description='{r.Description}'") .AppendLine($" FullPath='{r.FullPath}'") .AppendLine($" Guid='{r.Guid}'") .AppendLine($" Major='{r.Major}'") .AppendLine($" Minor='{r.Minor}'") .AppendLine($" Name='{r.Name}'") .AppendLine($" Type='{r.Type}'") .AppendLine($" />"); } return(sb.AppendLine("</Project>").ToString()); }
public async Task <VBProjectParseResult> ParseAsync(VBProject project) { return(await Task.Run(() => Parse(project))); // note: the above has been seen to cause issues with VBProject.Equals and break navigation... //return Parse(project); }
private static string GetNextTestModuleName(VBProject project) { var names = project.ComponentNames(); var index = names.Count(n => n.StartsWith(TestModuleBaseName)) + 1; return(string.Concat(TestModuleBaseName, index)); }
protected static void ExtractProjectModules(VBProject project, string path) { if (project == null) { throw new ArgumentNullException(nameof(project)); } var retries = 3; while (retries > 0) { try { foreach (VBComponent component in project.VBComponents) { component.Export(Path.ChangeExtension(Path.Combine(path, component.Name), TypeExtension((VbExt_ct)component.Type))); } File.WriteAllText(Path.Combine(path, "VBAProject.xml"), GetProjectDefinitionXml(project)); break; } catch (COMException ex) when(ex.HResult == unchecked ((int)0x800AC372) || ex.HResult == unchecked ((int)0x800AC373) || ex.HResult == unchecked ((int)0x800AC35C)) { if (retries-- > 0) { continue; } throw new IOException( $"A file or directory conflict occurred. Please retry.\n\nPath:\n{path}", ex); } } }
public void SetModuleState(VBComponent component, ParserState state, SyntaxErrorException parserError = null) { if (AllUserDeclarations.Count > 0) { var projectId = component.Collection.Parent.HelpFile; VBProject project = null; foreach (var item in _projects) { if (item.Value.HelpFile == projectId) { project = project != null ? null : item.Value; } } if (project == null) { // ghost component shouldn't even exist ClearStateCache(component); Status = EvaluateParserState(); return; } } var key = new QualifiedModuleName(component); _moduleStates.AddOrUpdate(key, new ModuleState(state), (c, e) => e.SetState(state)); _moduleStates.AddOrUpdate(key, new ModuleState(parserError), (c, e) => e.SetModuleException(parserError)); Logger.Debug("Module '{0}' state is changing to '{1}' (thread {2})", key.ComponentName, state, Thread.CurrentThread.ManagedThreadId); OnModuleStateChanged(component, state); Status = EvaluateParserState(); }
public void ItemAdded(VBProject VBProject) { if (VBProject.Protection == vbext_ProjectProtection.vbext_pp_none) { OnDispatch(ProjectAdded, VBProject); } }
public void Indent(VBProject project) { if (project == null) { throw new ArgumentNullException("project"); } if (project.Protection == vbext_ProjectProtection.vbext_pp_locked) { throw new InvalidOperationException("Project is protected."); } var lineCount = 0; // to set progressbar max value if (project.VBComponents.Cast <VBComponent>().All(component => !HasCode(component.CodeModule, ref lineCount))) { throw new InvalidOperationException("Project contains no code."); } _originalTopLine = _vbe.ActiveCodePane.TopLine; _originalSelection = GetSelection(_vbe.ActiveCodePane); var progress = 0; // to set progressbar value foreach (var component in project.VBComponents.Cast <VBComponent>().Where(component => HasCode(component.CodeModule))) { Indent(component, true, progress); progress += component.CodeModule.CountOfLines; } _vbe.ActiveCodePane.TopLine = _originalTopLine; _vbe.ActiveCodePane.SetSelection(_originalSelection.StartLine, _originalSelection.StartColumn, _originalSelection.EndLine, _originalSelection.EndColumn); }
public void AddProject(VBProject project) { if (project.Protection == vbext_ProjectProtection.vbext_pp_locked) { // adding protected project to parser state is asking for COMExceptions.. return; } //assign a hashcode if no helpfile is present if (string.IsNullOrEmpty(project.HelpFile)) { project.HelpFile = project.GetHashCode().ToString(); } //loop until the helpfile is unique for this host session while (!IsProjectIdUnique(project.HelpFile)) { project.HelpFile = (project.GetHashCode() ^ project.HelpFile.GetHashCode()).ToString(); } var projectId = project.HelpFile; if (!_projects.ContainsKey(projectId)) { _projects.Add(projectId, project); } foreach (VBComponent component in project.VBComponents) { _moduleStates.TryAdd(new QualifiedModuleName(component), new ModuleState(ParserState.Pending)); } }
private bool LoadXlWings(VBProject pyxelRest = null) { try { if (!TrustAccessToTheVBAObjectModel()) { return(false); } VBProject vbProject = pyxelRest == null?GetPyxelRestVBProject() : pyxelRest; if (vbProject == null) { Log.Error("PyxelRest VB Project cannot be found."); return(false); } if (PathToBasFile == null) { return(false); } vbProject.VBComponents.Import(PathToBasFile); Log.Debug("XLWings module imported."); return(true); } catch (Exception ex) { Log.Error("XlWings module could not be imported.", ex); return(false); }; }
private void OnDispatch(EventHandler<DispatcherEventArgs<VBProject>> dispatched, VBProject project) { var handler = dispatched; if (handler != null) { handler.Invoke(this, new DispatcherEventArgs<VBProject>(project)); } }
public void ItemRenamed(VBProject VBProject, string OldName) { var handler = ProjectRenamed; if (handler != null && VBProject.Protection == vbext_ProjectProtection.vbext_pp_none) { handler.Invoke(this, new DispatcherRenamedEventArgs<VBProject>(VBProject, OldName)); } }
public VBProjectParseResult Parse(IRubberduckParser parser, VBProject project) { using (var view = new ProgressDialog(parser, project)) { view.ShowDialog(); return(view.Result); } }
public VBProjectParseResult Parse(IRubberduckParser parser, VBProject project) { using (var view = new ProgressDialog(parser, project)) { view.ShowDialog(); return view.Result; } }
public static string GetProjectId(VBProject project) { if (project == null) { return string.Empty; } return string.IsNullOrEmpty(project.HelpFile) ? project.GetHashCode().ToString() : project.HelpFile; }
public static string GetProjectId(VBProject project) { if (project == null) { return(string.Empty); } return(string.IsNullOrEmpty(project.HelpFile) ? project.GetHashCode().ToString() : project.HelpFile); }
private void LogVbProject(VBProject vbProject, bool isActiveVbProject) { Log("Project " + vbProject.Name + ((isActiveVbProject) ? " (active)" : string.Empty)); foreach (VBComponent vbComponent in vbProject.VBComponents) { LogVbComponent(vbComponent); } }
public void RemoveProject(VBProject project) { foreach (var key in ParseResultCache.Keys.Where(k => k.Project.Equals(project))) { VBComponentParseResult result; ParseResultCache.TryRemove(key, out result); } }
/// <summary> /// Returns repository settings for project /// </summary> /// <param name="project">VBProject</param> /// <returns></returns> public RepositorySettings GetVBProjectRepository(VBProject project) { var projectRepoPath = GetVBProjectRepoPath(project); return(_config.Repositories.Find(r => (r.Name == project.GetRepoName() && NormalizePath(r.LocalPath) == NormalizePath(projectRepoPath) && Directory.Exists(r.LocalPath)))); }
public QualifiedModuleName(VBProject project) { _component = null; _componentName = null; _project = project; _projectName = project.Name; _projectHashCode = project.GetHashCode(); _contentHashCode = 0; }
public void ItemRenamed(VBProject VBProject, string OldName) { var handler = ProjectRenamed; if (handler != null && VBProject.Protection == vbext_ProjectProtection.vbext_pp_none) { handler.Invoke(this, new DispatcherRenamedEventArgs <VBProject>(VBProject, OldName)); } }
static void include_files(string[] vba_files, ref VBProject project) { foreach (string source in vba_files) { var module = project.VBComponents.Add(vbext_ComponentType.vbext_ct_StdModule); module.CodeModule.AddFromFile(source); module.Name = Path.GetFileNameWithoutExtension(source); } }
public static void WorkbookGenerateModule(Excel.Workbook wb, string moduleName, string moduleContent) { VBProject prj = wb.VBProject; VBComponent xlModule = prj.VBComponents.Add(vbext_ComponentType.vbext_ct_StdModule); xlModule.Name = moduleName; xlModule.CodeModule.AddFromString(moduleContent); }
public QualifiedModuleName(VBProject project) { _component = null; _componentName = null; _project = project; _projectName = project.Name; _projectPath = string.Empty; _projectId = GetProjectId(project); _contentHashCode = 0; }
public static IEnumerable <TestMethod> TestMethods(this VBProject project) { IHostApplication hostApp = project.VBE.HostApplication(); return(project.VBComponents .Cast <VBComponent>() .Where(component => component.Type == vbext_ComponentType.vbext_ct_StdModule && component.CodeModule.HasAttribute <TestModuleAttribute>()) .Select(component => new { Component = component, Members = component.GetMembers().Where(member => IsTestMethod(member)) }) .SelectMany(component => component.Members.Select(method => new TestMethod(project.Name, component.Component.Name, method.Name, hostApp)))); }
public ProgressDialog(IRubberduckParser parser, VBProject project) : this() { _parser = parser; _project = project; Shown += ProgressDialog_Shown; _bgw.WorkerReportsProgress = true; _bgw.DoWork += _bgw_DoWork; _bgw.RunWorkerCompleted += _bgw_RunWorkerCompleted; }
public GitProvider(VBProject project, IRepository repository, string userName, string passWord, ICodePaneWrapperFactory wrapperFactory) : this(project, repository, wrapperFactory) { _credentials = new UsernamePasswordCredentials() { Username = userName, Password = passWord }; _credentialsHandler = (url, user, cred) => _credentials; }
public GitProvider(VBProject project, IRepository repository, ICredentials<SecureString> credentials, ICodePaneWrapperFactory wrapperFactory) : this(project, repository, wrapperFactory) { _credentials = new SecureUsernamePasswordCredentials() { Username = credentials.Username, Password = credentials.Password }; _credentialsHandler = (url, user, cred) => _credentials; }
private Declaration CreateProjectDeclaration(QualifiedModuleName projectQualifiedName, VBProject project) { var qualifiedName = projectQualifiedName.QualifyMemberName(project.Name); var projectId = qualifiedName.QualifiedModuleName.ProjectId; var projectDeclaration = new ProjectDeclaration(qualifiedName, project.Name); var references = _projectReferences.Where(projectContainingReference => projectContainingReference.ContainsKey(projectId)); foreach (var reference in references) { int priority = reference[projectId]; projectDeclaration.AddProjectReference(reference.ReferencedProjectId, priority); } return projectDeclaration; }
public GitProvider(VBProject project, IRepository repository, ICodePaneWrapperFactory wrapperFactory) : base(project, repository, wrapperFactory) { _unsyncedLocalCommits = new List<ICommit>(); _unsyncedRemoteCommits = new List<ICommit>(); try { _repo = new LibGit2Sharp.Repository(CurrentRepository.LocalLocation); } catch (RepositoryNotFoundException ex) { throw new SourceControlException(SourceControlText.GitRepoNotFound, ex); } }
public GitProvider(VBProject project, IRepository repository) : base(project, repository) { _unsyncedLocalCommits = new List<ICommit>(); _unsyncedRemoteCommits = new List<ICommit>(); try { _repo = new LibGit2Sharp.Repository(CurrentRepository.LocalLocation); } catch (RepositoryNotFoundException ex) { throw new SourceControlException("Repository not found.", ex); } }
public static void SetSelection(this VBE vbe, VBProject vbProject, Selection selection, string name, ICodePaneWrapperFactory wrapperFactory) { try { var component = vbProject.VBComponents.Cast<VBComponent>().SingleOrDefault(c => c.Name == name); if (component == null) { return; } var codePane = wrapperFactory.Create(component.CodeModule.CodePane); codePane.Selection = selection; } catch (Exception e) { } }
public VBProjectParseResult Parse(VBProject project, object owner = null) { if (owner != null) { OnParseStarted(new[]{project.Name}, owner); } var results = new List<VBComponentParseResult>(); if (project.Protection == vbext_ProjectProtection.vbext_pp_locked) { return new VBProjectParseResult(project, results); } var modules = project.VBComponents.Cast<VBComponent>(); var mustResolve = false; foreach (var vbComponent in modules) { OnParseProgress(vbComponent); bool fromCache; var componentResult = Parse(vbComponent, out fromCache); if (componentResult != null) { mustResolve = mustResolve || !fromCache; results.Add(componentResult); } } var parseResult = new VBProjectParseResult(project, results); if (mustResolve) { parseResult.Progress += parseResult_Progress; parseResult.Resolve(); parseResult.Progress -= parseResult_Progress; } if (owner != null) { OnParseCompleted(new[] {parseResult}, owner); } return parseResult; }
public ISourceControlProvider CreateGitProvider(VBProject project, ICodePaneWrapperFactory wrapperFactory, [Optional] IRepository repository, [Optional] ICredentials credentials) { if (credentials != null) { if (repository == null) { throw new ArgumentNullException("Must supply an IRepository if supplying credentials."); } return new GitProvider(project, repository, credentials, wrapperFactory); } if (repository != null) { return new GitProvider(project, repository, wrapperFactory); } return new GitProvider(project); }
public static void SetSelection(this VBE vbe, VBProject vbProject, Selection selection, string name) { var project = vbe.VBProjects.Cast<VBProject>() .SingleOrDefault(p => p.Protection != vbext_ProjectProtection.vbext_pp_locked && ReferenceEquals(p, vbProject)); VBComponent component = null; if (project != null) { component = project.VBComponents.Cast<VBComponent>() .SingleOrDefault(c => c.Name == name); } if (component == null) { return; } component.CodeModule.CodePane.SetSelection(selection); }
public VBProjectParseResult(VBProject project, IEnumerable<VBComponentParseResult> parseResults) { _project = project; _parseResults = parseResults; _declarations = new Declarations(); var projectIdentifier = project.Name; var memberName = new QualifiedMemberName(new QualifiedModuleName(project), projectIdentifier); var projectDeclaration = new Declaration(memberName, "VBE", projectIdentifier, false, false, Accessibility.Global, DeclarationType.Project, false); _declarations.Add(projectDeclaration); foreach (var declaration in VbaStandardLib.Declarations) { _declarations.Add(declaration); } foreach (var declaration in _parseResults.SelectMany(item => item.Declarations)) { _declarations.Add(declaration); } }
protected SourceControlProviderBase(VBProject project, IRepository repository, ICodePaneWrapperFactory wrapperFactory) :this(project) { CurrentRepository = repository; _wrapperFactory = wrapperFactory; }
protected SourceControlProviderBase(VBProject project) { Project = project; }
public GitProvider(VBProject project, IRepository repository, ICredentials credentials, ICodePaneWrapperFactory wrapperFactory) :base(project, repository, credentials.Username, credentials.Password, wrapperFactory) { }
public GitProvider(VBProject project, IRepository repository, string userName, string passWord, ICodePaneWrapperFactory wrapperFactory) : base(project, repository, userName, passWord, wrapperFactory) { }
public GitProvider(VBProject project, IRepository repository, ICodePaneWrapperFactory wrapperFactory) : base(project, repository, wrapperFactory) { }
public GitProvider(VBProject project) : base(project) { }
public GitProvider(VBProject project) : base(project) { _unsyncedLocalCommits = new List<ICommit>(); _unsyncedRemoteCommits = new List<ICommit>(); }
protected SourceControlProviderBase(VBProject project, IRepository repository) :this(project) { this.CurrentRepository = repository; }