private ISyntax CreateAbnfSyntax()
{
var syntax = new Syntax();
syntax.DefaultConverter.Add(CommonConverters.GuidConverter);
syntax.DefaultConverter.Add(CommonConverters.Int32Converter);
HostExtenderRef.Setup(syntax);
HostExtenders.Setup(syntax);
//LibidReference.Setup(syntax);
ProjectId.Setup(syntax);
ProjectDocModule.Setup(syntax);
ProjectStdModule.Setup(syntax);
ProjectClassModule.Setup(syntax);
ProjectDesignerModule.Setup(syntax);
ProjectPackage.Setup(syntax);
ProjectProperties.Setup(syntax);
ProjectReference.Setup(syntax);
ProjectWindow.Setup(syntax);
ProjectWindowState.Setup(syntax);
ProjectWindowRecord.Setup(syntax);
ProjectWorkspace.Setup(syntax);
VBAPROJECTText.Setup(syntax);
return(syntax);
}
internal static ITextBuffer GetBufferAt(string filePath, IServiceProvider provider)
{
//var package = (Microsoft.VisualStudio.OLE.Interop.IServiceProvider)node.GetService(typeof(EnvDTE.DTE));
//var serviceProvider = ;//new Microsoft.VisualStudio.Shell.ServiceProvider(package);
//ProjectItem pi = (ProjectItem)node.GetAutomationObject();
IVsUIHierarchy uiHierarchy;
uint itemID;
IVsWindowFrame windowFrame;
if (VsShellUtilities.IsDocumentOpen(
provider,
filePath,
Guid.Empty,
out uiHierarchy,
out itemID,
out windowFrame))
{
IVsTextView view = VsShellUtilities.GetTextView(windowFrame);
IVsTextLines lines;
if (view.GetBuffer(out lines) == 0)
{
var buffer = lines as IVsTextBuffer;
if (buffer != null)
{
var componentModel = (IComponentModel)ProjectPackage.GetGlobalService(typeof(SComponentModel));
var editorAdapterFactoryService = componentModel.GetService <IVsEditorAdaptersFactoryService>();
return(editorAdapterFactoryService.GetDataBuffer(buffer));
}
}
}
return(null);
}
protected override void InitializeProjectProperties()
{
base.InitializeProjectProperties();
SQLanguageServiceEX objectLibrary = (SQLanguageServiceEX)ProjectPackage.GetGlobalService(typeof(ISQLanguageService));
objectLibrary.RegisterProjectNode(this);
}
public ProjectTestClass(ProjectPackage package)
: base(package)
{
// To avoid having to mock the SCC stuff simply disable it
this.IsSccDisabled = true;
this.DisableQueryEdit = true;
}
public ProjectTestClass(ProjectPackage package)
: base(package)
{
// To avoid having to mock the SCC stuff simply disable it
this.IsSccDisabled = true;
this.DisableQueryEdit = true;
}
public override int InitializeForOuter(string filename, string location, string name, uint flags, ref Guid iid, out IntPtr projectPointer, out int canceled)
{
int result = base.InitializeForOuter(filename, location, name, flags, ref iid, out projectPointer, out canceled);
SQLanguageServiceEX objectLibrary = (SQLanguageServiceEX)ProjectPackage.GetGlobalService(typeof(ISQLanguageService));
objectLibrary.RegisterProjectNode(this);
return(result);
}
public override int InitializeForOuter(string filename, string location, string name, uint flags, ref Guid iid, out IntPtr projectPointer, out int canceled)
{
int result = base.InitializeForOuter(filename, location, name, flags, ref iid, out projectPointer, out canceled);
//RegisterUserProperty(GeneralPropertyPageTags.IntellisenseEnabled.ToString());
SQLanguageServiceEX objectLibrary = (SQLanguageServiceEX)ProjectPackage.GetGlobalService(typeof(ISQLanguageService));
return(result);
}
public override void RemovePackage(string moduleName)
{
ProjectPackage p = GetPackage(moduleName);
Directory.Delete(GetModulePackagePath(p), true);
m_PackageList.Remove(p);
SavePackageList(m_PackageList);
}
public override void OnUserPropertyLoad(string propertyname, string value)
{
SQLanguageServiceEX languageservice = (SQLanguageServiceEX)ProjectPackage.GetGlobalService(typeof(ISQLanguageService));
if (propertyname == GeneralPropertyPageTags.IntellisenseEnabled.ToString())
{
languageservice.IntellisenseEnabled = value.ToLower() == "true";
}
}
public JavaProjectNode(ProjectPackage package)
: base(package)
{
_sharedBuildOptions = new JavaBuildOptions();
CanProjectDeleteItems = true;
OleServiceProvider.AddService(typeof(VSLangProj.VSProject), HandleCreateService, false);
AddCatIdMapping(typeof(JavaFileNodeProperties), typeof(FileNodeProperties).GUID);
}
public void AddPackage(ProjectPackage item)
{
if (!items.TryGetValue(item.Id, out var cacheVersionList))
{
cacheVersionList = new Dictionary <string, ProjectPackage>(StringComparer.OrdinalIgnoreCase);
items[item.Id] = cacheVersionList;
}
cacheVersionList[item.Version] = item;
}
//=====================================================================
/// <summary>
/// This is overridden to create the project node
/// </summary>
/// <returns>A project node</returns>
protected override ProjectNode CreateProject()
{
ProjectPackage package = (ProjectPackage)this.Package;
SandcastleBuilderProjectNode project = new SandcastleBuilderProjectNode(package);
project.SetSite((IOleServiceProvider)((IServiceProvider)package).GetService(typeof(IOleServiceProvider)));
return(project);
}
public void ShowPackageDetails()
{
ProjectPackage package = (ProjectPackage)CurrentNode.DataItem;
// package.ParsePackage ();
PackageDetails details = new PackageDetails(package);
details.Show();
}
public void RomoveItem()
{
ProjectPackage package = (ProjectPackage)CurrentNode.DataItem;
CProject project = (CProject)CurrentNode.GetParentDataItem(
typeof(CProject), false);
project.Packages.Remove(package);
IdeApp.ProjectOperations.SaveProject(project);
}
public override void DeleteItem()
{
ProjectPackage package = CurrentNode.DataItem as ProjectPackage;
ValaProject project = CurrentNode.GetParentDataItem(
typeof(ValaProject), false) as ValaProject;
project.Packages.Remove(package);
IdeApp.ProjectOperations.Save(project);
}
/// <summary>
/// Explicitly defined default constructor.
/// </summary>
public NestedProjectNode(ProjectPackage package)
: base(package)
{
this.SupportsProjectDesigner = true;
this.CanProjectDeleteItems = true;
// Add Category IDs mapping in order to support properties for project items
AddCatIdMapping(typeof(FileNodeProperties), typeof(FileNodeProperties).GUID);
AddCatIdMapping(typeof(ProjectNodeProperties), typeof(ProjectNodeProperties).GUID);
AddCatIdMapping(typeof(FolderNodeProperties), typeof(FolderNodeProperties).GUID);
AddCatIdMapping(typeof(ReferenceNodeProperties), typeof(ReferenceNodeProperties).GUID);
}
private void SQVSProjectNode_OnProjectPropertyChanged(object sender, ProjectPropertyChangedArgs e)
{
if (e.NewValue != null)
{
SQLanguageServiceEX languageservice = (SQLanguageServiceEX)ProjectPackage.GetGlobalService(typeof(ISQLanguageService));
/*if (e.PropertyName == GeneralPropertyPageTags.IntellisenseEnabled.ToString())
* languageservice.IntellisenseEnabled = SQVSUtils.GetProjectPropertyBool(this, GeneralPropertyPageTags.IntellisenseEnabled.ToString());
* else if (e.PropertyName == GeneralPropertyPageTags.ClassViewEnabled.ToString())
* languageservice.ClassViewEnabled = SQVSUtils.GetProjectPropertyBool(this, GeneralPropertyPageTags.ClassViewEnabled.ToString());*/
}
}
public override FileNode CreateFileNode(ProjectElement item)
{
SQProjectFileNode node = new SQProjectFileNode(this, item);
node.OleServiceProvider.AddService(typeof(EnvDTE.Project), new OleServiceProvider.ServiceCreatorCallback(this.CreateServices), false);
node.OleServiceProvider.AddService(typeof(ProjectItem), node.ServiceCreator, false);
node.OleServiceProvider.AddService(typeof(VSProject), new OleServiceProvider.ServiceCreatorCallback(this.CreateServices), false);
SQLanguageServiceEX objectLibrary = (SQLanguageServiceEX)ProjectPackage.GetGlobalService(typeof(ISQLanguageService));
objectLibrary.RegisterFileNode(node);
return(node);
}
public override void RemoveTarget(string moduleName, string moduleVersion)
{
ProjectPackage p = GetPackage(moduleName);
ProjectConfig t = p.GetInstallTarget(moduleVersion);
string dataPath = GetTargetDataPath(t);
if (Directory.Exists(dataPath))
{
Directory.Delete(dataPath, true);
}
p.ModuleVersions.RemoveAll(x => x == moduleVersion);
SavePackageList(m_PackageList);
}
internal static IVsWindowFrame OpenDocumentInNewWindow(string filePath, IServiceProvider provider, int lineid = -1, int columnid = -1, int length = -1)
{
if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
{
return(null);
}
IVsUIHierarchy hierarchy;
uint itemId;
IVsWindowFrame frame = null;
if (!VsShellUtilities.IsDocumentOpen(provider, filePath,
VSConstants.LOGVIEWID_Primary, out hierarchy, out itemId, out frame))
{
VsShellUtilities.OpenDocument(provider, filePath,
VSConstants.LOGVIEWID_Primary, out hierarchy, out itemId, out frame);
}
if (frame != null && frame.Show() == VSConstants.S_OK && lineid != -1)
{
var vsTextView = VsShellUtilities.GetTextView(frame);
var componentModel = (IComponentModel)ProjectPackage.GetGlobalService(typeof(SComponentModel));
var editorAdapterFactoryService = componentModel.GetService <IVsEditorAdaptersFactoryService>();
var wpfTextView = editorAdapterFactoryService.GetWpfTextView(vsTextView);
var p = wpfTextView.TextSnapshot.GetLineFromLineNumber(lineid).Start;
if (columnid > -1)
{
p += columnid;
}
wpfTextView.Caret.MoveTo(p);
SnapshotSpan span;
if (length > 0)
{
span = new SnapshotSpan(p, length);
}
else if (columnid != -1)
{
var linespan = wpfTextView.TextSnapshot.GetLineFromLineNumber(lineid).End;
span = new SnapshotSpan(p, linespan);
}
else
{
span = wpfTextView.TextSnapshot.GetLineFromLineNumber(lineid).Extent;
}
wpfTextView.Selection.Select(span, false);
wpfTextView.Caret.EnsureVisible();
//System.Windows.Forms.SendKeys.Send("{RIGHT}");
}
return(frame);
}
//=====================================================================
/// <summary>
/// Constructor
/// </summary>
/// <param name="package">The package to which the project node is
/// related.</param>
public SandcastleBuilderProjectNode(ProjectPackage package)
: base(package)
{
// Add the project node images
imageIndex = this.ImageHandler.ImageList.Images.Count;
foreach (Image img in imageList.Images)
{
this.ImageHandler.AddImage(img);
}
// Allow destructive deletes
this.CanProjectDeleteItems = true;
// Use the project designer for the property pages
this.SupportsProjectDesigner = true;
this.InitializeCATIDs();
}
public override void AddPackage(ProjectConfig target, string moduleDataPath)
{
ProjectPackage package;
if (!HasPackage(target.ProjectName))
{
package = new ProjectPackage(this, target.ProjectName, new string[0]);
m_PackageList.Add(package);
}
else
{
package = GetPackage(target.ProjectName);
}
if (package.HasTarget(target.ProjectVersion))
{
EventManager <WarningEvent> .SendEvent(
new ProjectVersionAlreadyExistsEvent(
target.ProjectName,
target.ProjectVersion
)
);
string dataDir = GetTargetDataPath(target);
if (Directory.Exists(dataDir))
{
Directory.Delete(dataDir, true);
}
}
package.ModuleVersions.Add(target.ProjectVersion);
string data = GetTargetDataPath(target);
Directory.CreateDirectory(data);
File.Copy(moduleDataPath, GetTargetDataUri(target));
ProjectConfig.Save(GetTargetInfoUri(package, target.ProjectVersion), target);
SavePackageList(m_PackageList);
}
public override void OnNodeDrop(object dataObject, DragOperation operation)
{
if (dataObject is ProjectPackage)
{
ProjectPackage package = (ProjectPackage)dataObject;
ITreeNavigator nav = CurrentNode;
CProject dest = nav.GetParentDataItem(typeof(CProject), true) as CProject;
nav.MoveToObject(dataObject);
CProject source = nav.GetParentDataItem(typeof(CProject), true) as CProject;
dest.Packages.Add(package);
IdeApp.ProjectOperations.SaveProject(dest);
if (operation == DragOperation.Move)
{
source.Packages.Remove(package);
IdeApp.ProjectOperations.SaveProject(source);
}
}
else if (dataObject is CProject)
{
CProject draggedProject = (CProject)dataObject;
CProject destProject = (CurrentNode.DataItem as ProjectPackageCollection).Project;
draggedProject.WriteMDPkgPackage();
ProjectPackage package = new ProjectPackage(draggedProject);
if (!destProject.Packages.Contains(package))
{
destProject.Packages.Add(package);
IdeApp.ProjectOperations.SaveProject(destProject);
}
}
}
public BooLangProjectFactory(Package package)
: base(package)
{
this.package = (ProjectPackage)package;
this.BuildEngine.GlobalProperties["GenerateFullPaths"] = new BuildProperty("GenerateFullPaths", "True");
string booBinPath = "";
RegistryKey booBinPathKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\BooLangStudio");
if (booBinPathKey != null)
booBinPath = booBinPathKey.GetValue("BooBinPath") as string;
if(string.IsNullOrEmpty(booBinPath))
{
IVsOutputWindowPane generalOut = Package.GetOutputPane(
VSConstants.GUID_OutWindowGeneralPane,
"Error List");
if(generalOut!=null)
generalOut.OutputStringThreadSafe(Resources.BooBinPathMissing);
}
this.BuildEngine.GlobalProperties["BooBinPath"] = new BuildProperty("BooBinPath", booBinPath);
}
public NodeProjectFactory(ProjectPackage package)
: base(package)
{
_package = package;
}
public override void OnNodeDrop (object dataObject, DragOperation operation)
{
if (dataObject is ProjectPackage) {
ProjectPackage package = (ProjectPackage)dataObject;
ITreeNavigator nav = CurrentNode;
ValaProject dest = nav.GetParentDataItem (typeof(ValaProject), true) as ValaProject;
nav.MoveToObject (dataObject);
ValaProject source = nav.GetParentDataItem (typeof(ValaProject), true) as ValaProject;
dest.Packages.Add (package);
IdeApp.ProjectOperations.Save (dest);
if (operation == DragOperation.Move) {
source.Packages.Remove (package);
IdeApp.ProjectOperations.Save (source);
}
} else if (dataObject is ValaProject) {
ValaProject draggedProject = (ValaProject)dataObject;
ValaProject destProject = (CurrentNode.DataItem as ProjectPackageCollection).Project;
draggedProject.WriteMDPkgPackage (IdeApp.Workspace.ActiveConfiguration);
ProjectPackage package = new ProjectPackage (draggedProject);
if (!destProject.Packages.Contains (package)) {
destProject.Packages.Add (package);
IdeApp.ProjectOperations.Save (destProject);
}
}
}
public abstract string GetModulePackagePath(ProjectPackage package);
public NesteProjectNodeFake(ProjectPackage package)
: base(package)
{
}
//=====================================================================
/// <summary>
/// Constructor
/// </summary>
/// <param name="package">The package reference</param>
public SandcastleBuilderProjectFactory(ProjectPackage package) : base(package)
{
}
public PuppetProjectFactory(ProjectPackage package)
: base(package)
{
this.package = package;
}
public override string GetModulePackagePath(ProjectPackage package)
{
return(Path.Combine(ModuleRoot.OriginalString, s_ModulePath, package.ModuleName));
}
public abstract string GetTargetInfoUri(ProjectPackage package, string moduleVersion);
public override string GetTargetInfoUri(ProjectPackage package, string moduleVersion)
{
return(Path.Combine(GetModulePackagePath(package), moduleVersion, s_ModuleTarget));
}
