internal static bool ExecCommandOnProjectSourceNode(HierarchyNode node, Guid cmdGroup, uint cmd, uint cmdexecopt, IntPtr pvaIn, IntPtr pvaOut, out int returnCode) { if (cmdGroup == VsMenus.guidStandardCommandSet2K) { switch ((VsCommands2K)cmd) { case VsCommands2K.INCLUDEINPROJECT: returnCode = ((IProjectSourceNode)node).IncludeInProject(); return true; case VsCommands2K.EXCLUDEFROMPROJECT: returnCode = ((IProjectSourceNode)node).ExcludeFromProject(); return true; case OpenFolderInExplorerCmdId: System.Diagnostics.Process.Start(node.Url); returnCode = VSConstants.S_OK; return true; } } // just an arbitrary value, it doesn't matter if method hasn't handled the request returnCode = VSConstants.S_FALSE; // not handled return false; }
public static HierarchyNode<ContentItem> CreateDirectoryNode(IFileSystem fs, ContentItem directory, HierarchyNode<ContentItem> parent, List<ContentItem> selectionTrail) { var node = new HierarchyNode<ContentItem>(directory); ExpandRecursive(fs, node, selectionTrail); return node; }
public void OnMenuChangeAddServiceReference(object sender, EventArgs e) { try { Store store = this.CurrentDocView.CurrentDiagram.Store; Proxy proxy = DomainModelHelper.GetSelectedElement(this.ServiceProvider) as Proxy; if (proxy != null && !string.IsNullOrWhiteSpace(proxy.ClientApplication.ImplementationProject) && proxy.ClientApplication.ImplementationTechnology != null) { IVsSolution solution = this.ServiceProvider.GetService(typeof(SVsSolution)) as IVsSolution; using (HierarchyNode projectNode = new HierarchyNode(solution, proxy.ClientApplication.ImplementationProject)) { if (projectNode != null) { IVsAddWebReferenceResult result = VsShellDialogs.AddWebReferenceDialog(this.ServiceProvider, null, projectNode); if (result != null) { result.Save(); // IVsWCFReferenceGroup refGropup = (IVsWCFReferenceGroup)result.Save() } } } } } catch (Exception error) { Logger.Write(error); } }
private void Fire(HierarchyNode node, Action<IVsExtensibility3, ProjectItem> fire) { // When we are in suspended mode. Do not fire anything if (this._suspended) { return; } // Project has to be opened if (!this._project.IsProjectOpened) { return; } // We don't want to fire events for references here. OAReferences should do the job if (node is ReferenceNode) { return; } IVsExtensibility3 vsExtensibility = this._project.GetService(typeof(IVsExtensibility)) as IVsExtensibility3; if (vsExtensibility != null) { object obj = node.GetAutomationObject(); ProjectItem item = obj as ProjectItem; if (item != null) { fire(vsExtensibility, item); } } }
public static void Replace(RustProjectNode root, HierarchyNode old, Func<HierarchyNode> newN) { if (root == null) throw new ArgumentNullException("root"); if (old == null) throw new ArgumentNullException("old"); if (newN == null) throw new ArgumentNullException("newN"); __VSHIERARCHYITEMSTATE visualState = old.GetItemState(__VSHIERARCHYITEMSTATE.HIS_Selected | __VSHIERARCHYITEMSTATE.HIS_Expanded); HierarchyNode parent = old.Parent; HierarchyNode newNode; if(parent is UntrackedFolderNode) { using(((UntrackedFolderNode)parent).SuspendChildrenTracking()) { newNode = ReplaceCore(root, old, newN, parent); ((UntrackedFolderNode)parent).OnChildReplaced(old, newNode); } } else { newNode = ReplaceCore(root, old, newN, parent); } if ((visualState & __VSHIERARCHYITEMSTATE.HIS_Expanded) != 0) newNode.ExpandItem(EXPANDFLAGS.EXPF_ExpandFolder); if ((visualState & __VSHIERARCHYITEMSTATE.HIS_Selected) != 0) newNode.ExpandItem(EXPANDFLAGS.EXPF_SelectItem); }
public static void SelectItemInSolutionExplorer(this IVsUIShell uiShell, HierarchyNode node) { if (node != null) { uiShell.GetSolutionExplorer().ExpandItem((node.Hierarchy as IVsUIHierarchy), node.ItemId, EXPANDFLAGS.EXPF_SelectItem); } }
public override HierarchyNode<ContentItem> Build() { if (_initialItem == _lastAncestor && !_appendAdditionalLevel) return new HierarchyNode<ContentItem>(_initialItem); HierarchyNode<ContentItem> previousNode = null; foreach (ContentItem currentItem in Find.EnumerateParents(_initialItem, _lastAncestor, _appendAdditionalLevel)) { HierarchyNode<ContentItem> currentNode = new HierarchyNode<ContentItem>(currentItem); if (previousNode != null) previousNode.Parent = currentNode; foreach (ContentItem childItem in GetChildren(currentItem)) { if (previousNode != null && (previousNode.Current == childItem || previousNode.Current.TranslationOf == childItem)) { currentNode.Children.Add(previousNode); } else { HierarchyNode<ContentItem> childNode = new HierarchyNode<ContentItem>(childItem); currentNode.Children.Add(childNode); childNode.Parent = currentNode; } } previousNode = currentNode; } return previousNode; }
internal static void Write(HierarchyNode<ContentItem> hierarchy, ContentItem selectedItem, IContentAdapterProvider adapters, ItemFilter filter, string selectableTypes, string selectableExtensions, bool excludeRoot, string target, TextWriter writer) { N2.Web.Tree.Using(hierarchy) .OpenTo(selectedItem) .Filters(filter) .IdProvider(n => "u" + n.Current.ID, n => "l" + n.Current.ID) .LinkWriter((n, w) => { BuildLink(adapters.ResolveAdapter<NodeAdapter>(n.Current), n.Current, n.Current.Path == selectedItem.Path, target, IsSelectable(n.Current, selectableTypes, selectableExtensions)).WriteTo(w); if (n.Children.Count == 0 && adapters.ResolveAdapter<NodeAdapter>(n.Current).HasChildren(n.Current, filter)) { var ul = new TagBuilder("ul"); ul.AddCssClass("ajax"); w.Write(ul.ToString(TagRenderMode.StartTag)); var li = new TagBuilder("li"); li.InnerHtml = "{url:" + Url.ParseTokenized("{ManagementUrl}/Content/Navigation/LoadTree.ashx") .AppendQuery("target", target) .AppendQuery(SelectionUtility.SelectedQueryKey, HttpUtility.UrlEncode(n.Current.Path)) .AppendQuery("selectableTypes", selectableTypes) .AppendQuery("selectableExtensions", selectableExtensions) + "}"; w.Write(li.ToString()); w.Write(ul.ToString(TagRenderMode.EndTag)); } }) .ExcludeRoot(excludeRoot) .WriteTo(writer); }
/// <summary> /// Private helper to facilitate the previous CreateItem methods. /// </summary> private static IItemContainer CreateItem(IServiceProvider serviceProvider, HierarchyNode parent, uint selectedItemid) { using (HierarchyNode current = new HierarchyNode(parent, selectedItemid)) { return ItemFactory.CreateItem(serviceProvider, current); } }
private static void EnsureDetachedFromFormerParent(HierarchyNode hierarchyNode, ChangeSetBuilder pendingChanges) { if (hierarchyNode.Parent != null) { pendingChanges.Add(new DetachChildCommand(hierarchyNode.Parent.Id, hierarchyNode.Id)); } }
/// <summary> /// Builds this instance. /// </summary> /// <returns></returns> public override HierarchyNode<ContentItem> Build() { if (initialItem == lastAncestor && !appendAdditionalLevel) { return new HierarchyNode<ContentItem>(initialItem); } HierarchyNode<ContentItem> previousNode = null; foreach (ContentItem currentItem in Find.EnumerateParents(initialItem, lastAncestor, appendAdditionalLevel, UseMasterVersion)) { HierarchyNode<ContentItem> currentNode = new HierarchyNode<ContentItem>(currentItem); if (previousNode != null) { previousNode.Parent = currentNode; } foreach (ContentItem childItem in GetChildren(currentItem)) { if (previousNode != null && childItem.Equals(previousNode.Current)) { currentNode.Children.Add(previousNode); } else { HierarchyNode<ContentItem> childNode = new HierarchyNode<ContentItem>(childItem); currentNode.Children.Add(childNode); childNode.Parent = currentNode; } } previousNode = currentNode; } return previousNode; }
protected override void OnInit(EventArgs e) { var selected = Selection.SelectedItem; if (IsPostBack && !string.IsNullOrEmpty(inputFile.PostedFile.FileName)) { string uploadFolder = Request["inputLocation"]; if(!IsAvailable(uploadFolder)) throw new N2Exception("Cannot upload to " + Server.HtmlEncode(uploadFolder)); string fileName = System.IO.Path.GetFileName(inputFile.PostedFile.FileName); string filePath = VirtualPathUtility.Combine(uploadFolder, fileName); FS.WriteFile(filePath, inputFile.PostedFile.InputStream); ClientScript.RegisterStartupScript(typeof(Tree), "select", "updateOpenerWithUrlAndClose('" + ResolveUrl(filePath) + "');", true); } else if (Request["location"] == "files" || Request["location"] == "filesselection") { IHost host = Engine.Resolve<IHost>(); HierarchyNode<ContentItem> root = new HierarchyNode<ContentItem>(Engine.Persister.Get(host.DefaultSite.RootItemID)); var selectionTrail = new List<ContentItem>(); if (selected is AbstractNode) { selectionTrail = new List<ContentItem>(Find.EnumerateParents(selected, null, true)); } else { TrySelectingPrevious(ref selected, ref selectionTrail); } foreach (string uploadFolder in Engine.EditManager.UploadFolders) { var dd = FS.GetDirectory(uploadFolder); var node = CreateDirectoryNode(FS, new Directory(FS, dd, root.Current), root, selectionTrail); root.Children.Add(node); } AddSiteFilesNodes(root, host.DefaultSite, selectionTrail); foreach (var site in host.Sites) { AddSiteFilesNodes(root, site, selectionTrail); } siteTreeView.Nodes = root; siteTreeView.SelectedItem = selected; } else { var filter = Engine.EditManager.GetEditorFilter(Page.User); siteTreeView.Filter = filter; siteTreeView.RootNode = RootNode; siteTreeView.SelectedItem = selected; } siteTreeView.DataBind(); base.OnInit(e); }
/// <summary> /// Create an IItemContainer wrapper object against pHier /// </summary> internal static IItemContainer CreateItem(IServiceProvider serviceProvider, IVsSolution solution, IVsHierarchy pHier) { Debug.Assert(serviceProvider != null && solution != null && pHier != null); using (HierarchyNode current = new HierarchyNode(solution, pHier)) { return CreateItem(serviceProvider, current); } }
/// <summary> /// Create an IItemContainer wrapper object against IVsSolution /// </summary> internal static IItemContainer CreateItem(IServiceProvider serviceProvider, IVsSolution solution, uint selectedItemid) { Debug.Assert(serviceProvider != null && solution != null); using (HierarchyNode parent = new HierarchyNode(solution)) { return CreateItem(serviceProvider, parent, selectedItemid); } }
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, IServiceProvider provider, object value) { IVsSolution vsSolution = (IVsSolution)ServiceHelper.GetService(provider, typeof(IVsSolution), this); using (HierarchyNode root = new HierarchyNode(vsSolution)) { return EditValue(provider, root, value as HierarchyNode); } }
private void Print(HierarchyNode<IContainable> current) { System.Diagnostics.Debug.WriteLine(current.Current); System.Diagnostics.Debug.Indent(); foreach (var child in current.Children) Print(child); System.Diagnostics.Debug.Unindent(); }
/// <summary> /// Adds a directory to the project hierarchy with the specified parent. /// </summary> protected void AddDirectory(HierarchyNode parent, bool isSearchPath, string subfolder) { var existing = parent.FindChild(Path.GetFileName(subfolder)); if (existing == null) { FolderNode folderNode = CreateFolderNode(subfolder); parent.AddChild(folderNode); CreateHierarchy(folderNode, subfolder, isSearchPath); } }
private static string GetNodeNameForPackage(HierarchyNode node) { var project = node as ProjectNode; if (project != null) { return CommonUtils.GetFileOrDirectoryName(project.ProjectHome); } else { return node.Caption; } }
public HierarchyNode(ArtistViewModel artistViewModel, HierarchyNode parent, int level) { ArtistViewModel = artistViewModel; GraphNodeViewModel = null; Parent = parent; Children = new List<HierarchyNode>(); Level = level; }
public override void RemoveChild(HierarchyNode node) { base.RemoveChild(node); if (!suspendTracking && (node is UntrackedFileNode || node is UntrackedFolderNode)) { DecrementTrackedCount(); } }
public static TagWrapper Begin(string tagName, HierarchyNode<ContentItem> node, Action<HierarchyNode<ContentItem>, TagBuilder> tagModifier, TextWriter writer) { var tag = new TagBuilder(tagName); if (tagModifier != null) tagModifier(node, tag); return new TagWrapper(tag, writer); }
protected virtual HierarchyNode<ContentItem> BuildTree(ContentItem currentItem, int remainingDepth) { HierarchyNode<ContentItem> node = new HierarchyNode<ContentItem>(currentItem); if (remainingDepth > 1) foreach (ContentItem childItem in GetChildren(currentItem)) node.Children.Add(BuildTree(childItem, remainingDepth - 1)); return node; }
public void NamePropertySetCorrectly() { string name = "MyName"; MockVSHierarchy hierarchy = new MockVSHierarchy(name, Guid.NewGuid()); MockVsSolution solution = new MockVsSolution(hierarchy); HierarchyNode node = new HierarchyNode(solution); Assert.AreEqual<string>(name, node.Name); }
void buildChild(HierarchyNode<Function> item, List<Function> list) { foreach (var _item in item.ChildNodes) { _item.Entity.Level = _item.Depth; list.Add(_item.Entity); buildChild(_item, list); } }
public NodeProperties(HierarchyNode node) : base(GetProjectManager(node)) { if(node == null) { throw new ArgumentNullException("node"); } this.node = node; }
public static void ExpandRecursive(IFileSystem fs, HierarchyNode<ContentItem> parent, List<ContentItem> selectionTrail) { int index = selectionTrail.FindIndex(ci => string.Equals(ci.Url, parent.Current.Url, StringComparison.InvariantCultureIgnoreCase)); if (index < 0) return; foreach (var child in parent.Current.GetChildPagesUnfiltered()) { parent.Children.Add(CreateDirectoryNode(fs, child, parent, selectionTrail)); } }
public override void AddChild(HierarchyNode node) { if (node == null) throw new ArgumentNullException("node"); // make sure the node is in the map. Object nodeWithSameID = this.ProjectMgr.ItemIdMap[node.ID]; if (!Object.ReferenceEquals(node, nodeWithSameID as HierarchyNode)) { if (nodeWithSameID == null && node.ID <= this.ProjectMgr.ItemIdMap.Count) // reuse our hierarchy id if possible. this.ProjectMgr.ItemIdMap.SetAt(node.ID, this); else throw new InvalidOperationException(); } HierarchyNode previous = null; for (HierarchyNode n = this.FirstChild; n != null; n = n.NextSibling) { if (this.ProjectMgr.CompareNodes(node, n) > 0) break; previous = n; } // insert "node" after "previous". if (previous != null) { node.NextSibling = previous.NextSibling; previous.NextSibling = node; if (previous == this.LastChild) this.LastChild = node; } else { if (this.LastChild == null) this.LastChild = node; node.NextSibling = this.FirstChild; this.FirstChild = node; } node.Parent = this; this.OnItemAdded(this, node); NemerleProjectNode project = ProjectMgr as NemerleProjectNode; if (project != null && project.ProjectInfo.IsLoaded) { ReferenceNode referenceNode = (ReferenceNode)node; //TODO: Добавлять только если project.ProjectInfo.IsLoaded == екгу project.ProjectInfo.AddMacroAssembly(referenceNode); } }
/// <summary> /// Adds a file to the project hierarchy with the specified parent. /// </summary> /// <param name="parent"></param> /// <param name="isSearchPath"></param> /// <param name="file"></param> protected void AddFile(HierarchyNode parent, bool isSearchPath, string file) { var existing = parent.FindChild(file); if (existing == null) { FileNode fileNode = CreateFileNode(file); //Files in search path are not considered memebers of the project itself fileNode.SetProperty((int)__VSHPROPID.VSHPROPID_IsNonMemberItem, isSearchPath); parent.AddChild(fileNode); } }
protected void ReloadHierarchy(HierarchyNode parent, IEnumerable<IPackage> modules) { // We're going to reuse nodes for which matching modules exist in the new set. // The reason for this is that we want to preserve the expansion state of the // hierarchy. If we just bin everything off and recreate it all from scratch // it'll all be in the collapsed state, which will be annoying for users who // have drilled down into the hierarchy var recycle = new Dictionary<string, DependencyNode>(); var remove = new List<HierarchyNode>(); for (var current = parent.FirstChild; null != current; current = current.NextSibling) { var dep = current as DependencyNode; if (null == dep) { if (!(current is GlobalModulesNode) && !(current is LocalModulesNode)) { remove.Add(current); } continue; } if (modules != null && modules.Any( module => module.Name == dep.Package.Name && module.Version == dep.Package.Version && module.IsBundledDependency == dep.Package.IsBundledDependency && module.IsDevDependency == dep.Package.IsDevDependency && module.IsListedInParentPackageJson == dep.Package.IsListedInParentPackageJson && module.IsMissing == dep.Package.IsMissing && module.IsOptionalDependency == dep.Package.IsOptionalDependency)) { recycle[dep.Package.Name] = dep; } else { remove.Add(current); } } foreach (var obsolete in remove) { parent.RemoveChild(obsolete); ProjectMgr.OnItemDeleted(obsolete); } if (modules != null) { foreach (var package in modules) { DependencyNode child; if (recycle.ContainsKey(package.Name)) { child = recycle[package.Name]; child.Package = package; } else { child = new DependencyNode(_projectNode, parent as DependencyNode, package); parent.AddChild(child); } ReloadHierarchy(child, package.Modules); if (ProjectMgr.ParentHierarchy != null) { child.ExpandItem(EXPANDFLAGS.EXPF_CollapseFolder); } } } }
void buildChild(HierarchyNode<DanhMuc> item, List<DanhMuc> list) { foreach (HierarchyNode<DanhMuc> _item in item.ChildNodes) { _item.Entity.Level = _item.Depth; list.Add(_item.Entity); buildChild(_item, list); } }
public void Add(HierarchyNode node) { selection.Add(new NodeProperties(node)); }
/// <summary> /// Invokes the specified generator /// </summary> /// <param name="fileNode">The node on which to invoke the generator.</param> protected internal virtual void InvokeGenerator(FileNode fileNode) { if (fileNode == null) { throw new ArgumentNullException("fileNode"); } SingleFileGeneratorNodeProperties nodeproperties = fileNode.NodeProperties as SingleFileGeneratorNodeProperties; if (nodeproperties == null) { throw new InvalidOperationException(); } string customToolProgID = nodeproperties.CustomTool; if (String.IsNullOrEmpty(customToolProgID)) { return; } string customToolNamespace = nodeproperties.CustomToolNamespace; try { ThreadHelper.ThrowIfNotOnUIThread(); if (!this.runningGenerator) { //Get the buffer contents for the current node string moniker = fileNode.GetMkDocument(); this.runningGenerator = true; //Get the generator IVsSingleFileGenerator generator; int generateDesignTimeSource; int generateSharedDesignTimeSource; int generateTempPE; SingleFileGeneratorFactory factory = new SingleFileGeneratorFactory(this.projectMgr.ProjectGuid, this.projectMgr.Site); ErrorHandler.ThrowOnFailure(factory.CreateGeneratorInstance(customToolProgID, out generateDesignTimeSource, out generateSharedDesignTimeSource, out generateTempPE, out generator)); //Check to see if the generator supports siting IObjectWithSite objWithSite = generator as IObjectWithSite; if (objWithSite != null) { objWithSite.SetSite(fileNode.OleServiceProvider); } //Determine the namespace if (String.IsNullOrEmpty(customToolNamespace)) { customToolNamespace = this.ComputeNamespace(moniker); } //Run the generator IntPtr[] output = new IntPtr[1]; output[0] = IntPtr.Zero; uint outPutSize = 0; string extension = String.Empty; try { ErrorHandler.ThrowOnFailure(generator.DefaultExtension(out extension)); } catch (Exception e) { if (System.Diagnostics.Debugger.IsAttached) { Debug.WriteLine("generator.DefaultExtension failed: " + e.Message); } } // IVsTextStream stream; string inputFileContents = this.GetBufferContents(moniker, out stream); // // HACK To support T4 Template // //bool utf8 = false; if (String.Compare(Path.GetExtension(fileNode.FileName), ".tt", true) == 0) { // Per default, for a T4 template, convert to UTF8 // utf8 = true; ? to be done ?? // The Output Extension may be modified by the Template. Check it Regex t4ParsingRegex = new Regex("output.*\\sextension\\s*=\\s*\"(?<pvalue>.*?)(?<=[^\\\\](\\\\\\\\)*)\"", RegexOptions.IgnorePatternWhitespace | RegexOptions.Singleline | RegexOptions.ExplicitCapture); MatchCollection matchs = t4ParsingRegex.Matches(inputFileContents); if (matchs.Count > 0) { Match match = matchs[0]; Group group = match.Groups["pvalue"]; extension = group.Value; } // Any Encoding in the Template ? t4ParsingRegex = new Regex("output.*\\sencoding\\s*=\\s*\"(?<pvalue>.*?)(?<=[^\\\\](\\\\\\\\)*)\"", RegexOptions.IgnorePatternWhitespace | RegexOptions.Singleline | RegexOptions.ExplicitCapture); matchs = t4ParsingRegex.Matches(inputFileContents); if (matchs.Count > 0) { Match match = matchs[0]; Group group = match.Groups["pvalue"]; //utf8 = false; } } //Find if any dependent node exists string dependentNodeName = Path.GetFileNameWithoutExtension(fileNode.FileName) + extension; HierarchyNode dependentNode = fileNode.FirstChild; while (dependentNode != null) { if (String.Compare(dependentNode.ItemNode.GetMetadata(ProjectFileConstants.DependentUpon), fileNode.FileName, StringComparison.OrdinalIgnoreCase) == 0) { dependentNodeName = ((FileNode)dependentNode).FileName; break; } dependentNode = dependentNode.NextSibling; } //If you found a dependent node. if (dependentNode != null) { //Then check out the node and dependent node from SCC if (!this.CanEditFile(dependentNode.GetMkDocument())) { throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED); } } else //It is a new node to be added to the project { // Check out the project file if necessary. if (!this.projectMgr.QueryEditProjectFile(false)) { throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED); } } try { ErrorHandler.ThrowOnFailure(generator.Generate(moniker, inputFileContents, customToolNamespace, output, out outPutSize, this)); } catch (Exception e) { if (System.Diagnostics.Debugger.IsAttached) { Debug.WriteLine("generator.Generate failed: " + e.Message); } } if (outPutSize > 0) { byte[] data = new byte[outPutSize]; if (output[0] != IntPtr.Zero) { Marshal.Copy(output[0], data, 0, (int)outPutSize); Marshal.FreeCoTaskMem(output[0]); } // HACK T4 Support /* * utf8 = false; * if (utf8) * { * System.Text.StringBuilder sb = new System.Text.StringBuilder(); * sb.Append(System.Text.Encoding.ASCII.GetString(data, 0, (int)outPutSize)); * // * System.Text.Encoding enc = new System.Text.UTF8Encoding(true); * byte[] preamble = enc.GetPreamble(); * byte[] encData = enc.GetBytes(sb.ToString()); * // * outPutSize = (uint)encData.Length + (uint)preamble.Length; * data = new byte[outPutSize]; * Array.Copy(preamble, data, preamble.Length); * Array.Copy(encData, 0, data, preamble.Length, encData.Length); * } */ //Todo - Create a file and add it to the Project string fileToAdd = this.UpdateGeneratedCodeFile(fileNode, data, (int)outPutSize, dependentNodeName); } } } finally { this.runningGenerator = false; } }
/// <summary> /// Constructor. /// </summary> /// <param name="project">The associated project.</param> /// <param name="nodeWithItems">The node that defines the items.</param> public OANavigableProjectItems(OAProject project, HierarchyNode nodeWithItems) { this.project = project; this.nodeWithItems = nodeWithItems; this.items = this.GetListOfProjectItems(); }
public FileNodeProperties(HierarchyNode node) : base(node) { }
protected override void OnInit(EventArgs e) { FS = Engine.Resolve <IFileSystem>(); Config = Engine.Resolve <ConfigurationManagerWrapper>().Sections.Management; Register.JQueryUi(Page); var selected = Selection.SelectedItem; if (IsPostBack && !string.IsNullOrEmpty(inputFile.PostedFile.FileName)) { string uploadFolder = Request[inputLocation.UniqueID]; if (!IsAvailable(uploadFolder)) { throw new N2Exception("Cannot upload to " + Server.HtmlEncode(uploadFolder)); } string fileName = System.IO.Path.GetFileName(inputFile.PostedFile.FileName); string filePath = Url.Combine(uploadFolder, fileName); FS.WriteFile(filePath, inputFile.PostedFile.InputStream); ClientScript.RegisterStartupScript(typeof(Tree), "select", "updateOpenerWithUrlAndClose('" + ResolveUrl(filePath) + "');", true); } else if (Request["location"] == "files" || Request["location"] == "filesselection") { IHost host = Engine.Resolve <IHost>(); HierarchyNode <ContentItem> root = new HierarchyNode <ContentItem>(Engine.Persister.Get(host.DefaultSite.RootItemID)); var selectionTrail = new List <ContentItem>(); if (selected is AbstractNode) { selectionTrail = new List <ContentItem>(Find.EnumerateParents(selected, null, true)); } else { TrySelectingPrevious(ref selected, ref selectionTrail); } foreach (var upload in Engine.Resolve <UploadFolderSource>().GetUploadFoldersForAllSites()) { var dir = N2.Management.Files.FolderNodeProvider.CreateDirectory(upload, FS, Engine.Persister, Engine.Resolve <IDependencyInjector>()); if (!Engine.SecurityManager.IsAuthorized(dir, User)) { continue; } var node = CreateDirectoryNode(FS, dir, root, selectionTrail); root.Children.Add(node); } siteTreeView.Nodes = root; siteTreeView.SelectedItem = selected; } else { var filter = Engine.EditManager.GetEditorFilter(Page.User); siteTreeView.Filter = filter; siteTreeView.RootNode = Engine.Resolve <Navigator>().Navigate(Request["root"] ?? "/"); siteTreeView.SelectedItem = selected; } siteTreeView.SelectableTypes = Request["selectableTypes"]; siteTreeView.SelectableExtensions = Request["selectableExtensions"]; siteTreeView.DataBind(); inputLocation.Value = siteTreeView.SelectedItem.Url; base.OnInit(e); }
private static HierarchyNode <ContentItem> CreateDirectoryNode(IFileSystem fs, ContentItem directory, HierarchyNode <ContentItem> parent, List <ContentItem> selectionTrail) { var node = new HierarchyNode <ContentItem>(directory); ExpandRecursive(fs, node, selectionTrail); return(node); }
/// <summary> /// Constructor. /// </summary> /// <param name="project">The associated project.</param> /// <param name="nodeWithItems">The node that defines the items.</param> internal OANavigableProjectItems(OAProject project, HierarchyNode nodeWithItems) { this.project = project; this.nodeWithItems = nodeWithItems; }
public FolderNodeProperties(HierarchyNode node) : base(node) { }
internal InterpretersNodeProperties(HierarchyNode node) : base(node) { }
private async Task ChildCreatedAsync(HierarchyNode child) { if (this.project.IsFileHidden(this.path)) { // don't add hidden files/folders return; } // creating a new item, need to create the on all files node var parent = this.project.GetParentFolderForPath(this.path); if (parent == null) { // we've hit an error while adding too many files, the file system watcher // couldn't keep up. That's alright, we'll merge the files in correctly // in a little while... return; } var wasExpanded = parent.GetIsExpanded(); if (Directory.Exists(this.path)) { if (IsFileSymLink(this.path)) { var parentDir = CommonUtils.GetParent(this.path); if (IsRecursiveSymLink(parentDir, this.path)) { // don't add recusrive sym link directory return; } // otherwise we're going to need a new file system watcher this.project.CreateSymLinkWatcher(this.path); } var folderNode = this.project.AddAllFilesFolder(parent, this.path); var folderNodeWasExpanded = folderNode.GetIsExpanded(); // then add the folder nodes await this.project.MergeDiskNodesAsync(folderNode, this.path).ConfigureAwait(true); // Assert we're back on the UI thread this.project.Site.GetUIThread().MustBeCalledFromUIThread(); this.project.OnInvalidateItems(folderNode); folderNode.ExpandItem(folderNodeWasExpanded ? EXPANDFLAGS.EXPF_ExpandFolder : EXPANDFLAGS.EXPF_CollapseFolder); } else if (File.Exists(this.path)) { // rapid changes can arrive out of order, make sure the file still exists this.project.AddAllFilesFile(parent, this.path); if (StringComparer.OrdinalIgnoreCase.Equals(this.project.GetStartupFile(), this.path)) { this.project.BoldStartupItem(); } } parent.ExpandItem(wasExpanded ? EXPANDFLAGS.EXPF_ExpandFolder : EXPANDFLAGS.EXPF_CollapseFolder); }
public NodeProperties(HierarchyNode node) { this.node = node; }
public void CustomizeModel(PfeDataModel model, IWebEasRepositoryBase repository, HierarchyNode node, string filter, HierarchyNode masterNode, string kodPolozkyModulu) { /* * if (model.Fields != null) * { * var icoField = model.Fields.FirstOrDefault(p => p.Name == nameof(ICO)); * if (icoField != null) * { * icoField.SearchFieldDefinition = new List<PfeSearchFieldDefinition> * { * new PfeSearchFieldDefinition * { * Code = "osa-oso-po", * NameField = nameof(PO_OsobaView.D_PO_Osoba_Id), * DisplayField = nameof(PO_OsobaView.ICO), * InputSearchField = nameof(PO_OsobaView.InputSearchField) * } * }; * } * } */ }
public void CustomizeModel(PfeDataModel model, IWebEasRepositoryBase repository, HierarchyNode node, string filter, HierarchyNode masterNode, string kodPolozkyModulu) { int isoZdroj = (int)repository.GetNastavenieI("cfe", "ISOZdroj"); var isoZdrojNazov = repository.GetNastavenieS("cfe", "ISOZdrojNazov"); if (model.Fields != null) { var poradieField = model.Fields.FirstOrDefault(p => p.Name == nameof(Poradie)); if (poradieField != null) { poradieField.Validator = new PfeValidator { Rules = new List <PfeRule> { new PfeRule { ValidatorType = PfeValidatorType.SetMin, Min = "1" } } }; } if (repository.GetNastavenieI("cfe", "eSAMRezim") != 1 && repository.Session.AdminLevel != AdminLevel.SysAdmin) { model.Fields.FirstOrDefault(p => p.Name == nameof(DCOM)).Text = "_DCOM"; } if (isoZdroj == 0 && repository.Session.AdminLevel != AdminLevel.SysAdmin) { model.Fields.FirstOrDefault(p => p.Name == nameof(ISO)).Text = "_ISO"; } } if (isoZdroj > 0 && repository.Session.Roles.Where(w => w.Contains("REG_MIGRATOR")).Any() && model.Type != PfeModelType.Form) { if (node.Actions.Any(x => x.ActionType == NodeActionType.MenuButtonsAll)) { var polozkaMenuAll = node.Actions.Where(x => x.ActionType == NodeActionType.MenuButtonsAll && x.Caption == "ISO").FirstOrDefault(); if (polozkaMenuAll != null) { polozkaMenuAll.Caption = isoZdrojNazov; } } } else { node.Actions.RemoveAll(x => x.ActionType == NodeActionType.MenuButtonsAll && x.Caption == "ISO"); } }
public override object GetRowDefaultValues(string code, string masterCode, string masterRowId, string copyId) { //Odkomentovať keď to chcem použiť var root = RenderModuleRootNode; var node = root.TryFindNode(code); HierarchyNode masternode = null; if (!masterCode.IsNullOrEmpty()) { masternode = root.TryFindNode(masterCode); } #region D_PRI_0, D_VYD_0 if (node != null && (node.ModelType == typeof(V_PRI_0View) || node.ModelType == typeof(V_VYD_0View))) { var FirstOrj = GetList <tblK_ORJ_0>().OrderBy(x => x.Serial_No).FirstOrDefault(); var FirstSkl = GetList <tblK_SKL_0>().OrderBy(x => x.Serial_No).FirstOrDefault(); return(new Pri0Vyd0Defaults() { DAT_DKL = DateTime.Now.Date, K_ORJ_0 = (int)(FirstOrj?.K_ORJ_0 ?? null), K_SKL_0 = (int)(FirstSkl?.K_SKL_0 ?? null) }); } #endregion #region D_SIM_0 if (node != null && node.ModelType == typeof(V_SIM_0View)) { short r = 1; byte t = 1; if (masternode == null || string.IsNullOrEmpty(masterRowId)) { //nic } else if (masternode.ModelType == typeof(V_PRI_0View)) { var poslednaPolozka = GetList <tblD_SIM_0>(x => x.D_PRI_0 == Convert.ToInt16(masterRowId)).OrderByDescending(x => x.RANK).FirstOrDefault(); r = (short)((poslednaPolozka?.RANK ?? 0) + 1); t = 1; //"+" - PV3DCombo.GetText } else if (masternode.ModelType == typeof(V_VYD_0View)) { var poslednaPolozka = GetList <tblD_SIM_0>(x => x.D_VYD_0 == Convert.ToInt16(masterRowId)).OrderByDescending(x => x.RANK).FirstOrDefault(); r = (short)((poslednaPolozka?.RANK ?? 0) + 1); t = 2; //"-" - PV3DCombo.GetText } return(new SimDefaults() { RANK = r, PV = t }); } #endregion #region D_PRI_1, D_VYD_1 if (node != null && masternode != null && !string.IsNullOrEmpty(masterRowId) && (node.ModelType == typeof(V_PRI_1View) || node.ModelType == typeof(V_VYD_1View))) { Pri1Vyd1Defaults def = new Pri1Vyd1Defaults() { RANK = 1 }; if (masternode.ModelType == typeof(V_PRI_0View)) { var poslednaPolozka = GetList <tblD_PRI_1>(x => x.D_PRI_0 == Convert.ToInt16(masterRowId)).OrderByDescending(x => x.RANK).FirstOrDefault(); if (poslednaPolozka != null) { def.RANK = (short)((poslednaPolozka?.RANK ?? 0) + 1); } var masterRow = GetById <V_PRI_0View>(masterRowId); if (masterRow != null) { def.K_SKL_0 = masterRow.K_SKL_0; } } else if (masternode.ModelType == typeof(V_VYD_0View)) { var poslednaPolozka = GetList <tblD_VYD_1>(x => x.D_VYD_0 == Convert.ToInt16(masterRowId)).OrderByDescending(x => x.RANK).FirstOrDefault(); if (poslednaPolozka != null) { def.RANK = (short)((poslednaPolozka?.RANK ?? 0) + 1); } var masterRow = GetById <V_VYD_0View>(masterRowId); if (masterRow != null) { def.K_SKL_0 = masterRow.K_SKL_0; } } return(def); } #endregion return(new object()); }
public void ComboCustomize(IWebEasRepositoryBase repository, string column, string kodPolozky, Dictionary <string, string> requiredFields, ref PfeComboAttribute comboAttribute, HierarchyNode node) { //if (kodPolozky.Equals("fin-bnk-ban") || kodPolozky.Equals("fin-bnk-ppp")) if (kodPolozky.Equals("fin-bnk-ban")) //Prevodné príkazy majú zobraziť všetky bank. účty { comboAttribute.FilterByOrsPravo = true; } if (kodPolozky.Equals("fin-bnk-ppp")) { comboAttribute.AdditionalWhereSql += $" AND C_Mena_Id = {(int)MenaEnum.EUR}"; } }
internal OAProjectItems(OAProject project, HierarchyNode nodeWithItems) : base(project, nodeWithItems) { }
/// <summary> /// Constructor. /// </summary> /// <param name="project">The associated project.</param> /// <param name="items">A list of items that will make up the items defined by this object.</param> /// <param name="nodeWithItems">The node that defines the items.</param> public OANavigableProjectItems(OAProject project, IList <EnvDTE.ProjectItem> items, HierarchyNode nodeWithItems) { this.items = items; this.project = project; this.nodeWithItems = nodeWithItems; }
public SelectionContainer(HierarchyNode node) { selection = new ArrayList(); selection.Add(new NodeProperties(node)); }
public HierarchyNodeEventArgs(HierarchyNode child) { this.child = child; }
protected internal virtual void InvokeGeneratorEx(FileNode fileNode, String document, bool runEvenIfNotDirty) { base.InvokeGenerator(fileNode); Utilities.ArgumentNotNull("fileNode", fileNode); SingleFileGeneratorNodeProperties nodeproperties = fileNode.NodeProperties as SingleFileGeneratorNodeProperties; if (nodeproperties == null) { throw new InvalidOperationException(); } string customToolProgID = nodeproperties.CustomTool; if (string.IsNullOrEmpty(customToolProgID)) { return; } // not sure what to do if BuildAction is set to "MSBuild:Compile". IronPython doesn't handle this correctly either. // This build action is set for .xaml files but doing nothing doesn't seem to cause problems, so for now we ignore this // generator type and do nothing too. If we don't do this, we get lots of message boxes when the clsid of this non-existent // single file generator isn't found. // We should try to find out what the proper action is here. There is no "MSBuild:Compile" entry in the registry // for the C# or VB project system single file generators, so there must be some special handling for this build type // otherwise it would just be blank. Naturally, the IronPython sample isn't any help here. if (customToolProgID.StartsWith("MSBuild:Compile", StringComparison.OrdinalIgnoreCase)) { var project = fileNode.ProjectMgr as XSharpProjectNode; if (project.IsXamlFile(document)) { // need to generate the .g.prg file. project.Build(project.CurrentConfig.ConfigCanonicalName, "BuildGenerateSources"); // BuildGenerateSources } // The C# project system then calls a InvokeMsBuild method with the following contents /* * HRESULT CVsProjBaseFileNode::InvokeMSBuildTarget(_In_z_ LPCWSTR wszMSBuildTarget) * { * HRESULT hr = NOERROR; * * if (wszMSBuildTarget != NULL) * { * CLangBuildMgr *pBuildMgr = GetProject()->GetBuildMgr(); * CComPtr<MSBuildEngine::IProject> srpMSBuildProject = pBuildMgr->GetMSBuildProject(); * * if (CXMakeHelper::DoesTargetExist(srpMSBuildProject, wszMSBuildTarget) && pBuildMgr->HasPassedSecurityChecks()) * { * // Initialize the build engine for this project and configuration. * CSmartMSBuildInitializer smsbi; * CLangProjectConfig *pProjConfig = pBuildMgr->GetConfigs()->GetActiveConfig(); * hr = smsbi.Initialize(pBuildMgr, pProjConfig); * * if (SUCCEEDED(hr)) * { * // Build the specified target in the MSBuild project. * hr = pBuildMgr->BuildTarget(wszMSBuildTarget); * } * * // Don't bother keeping the return value here--we want to * // return failure from Initialize or BuildTarget instead. * smsbi.Restore(pBuildMgr); * } * } * * return hr; * } */ return; } string customToolNamespace = nodeproperties.CustomToolNamespace; try { if (!this.runningGenerator) { //Find if any dependent node exists string dependentNodeName = null; HierarchyNode dependentNode = fileNode.FirstChild; while (dependentNode != null) { string dependentUpon = dependentNode.ItemNode.GetMetadata(ProjectFileConstants.DependentUpon); if (!String.IsNullOrEmpty(dependentUpon)) { if (!Path.IsPathRooted(dependentUpon)) { dependentUpon = Path.Combine(Path.GetDirectoryName(fileNode.Url), dependentUpon); } if (string.Compare(dependentUpon, fileNode.Url, StringComparison.OrdinalIgnoreCase) == 0) { dependentNodeName = ((FileNode)dependentNode).FileName; break; } } dependentNode = dependentNode.NextSibling; } bool outputOutOfDate = dependentNodeName == null; if ((!runEvenIfNotDirty) && !outputOutOfDate) { string generatedFile = Path.Combine(Path.GetDirectoryName(fileNode.GetMkDocument()), dependentNodeName); outputOutOfDate = !File.Exists(generatedFile); if (!outputOutOfDate) { outputOutOfDate = File.GetLastWriteTime(fileNode.GetMkDocument()) > File.GetLastWriteTime(generatedFile); if (!outputOutOfDate) { IVsHierarchy rdtHier; IVsPersistDocData perDocData; uint cookie; outputOutOfDate = this.VerifyFileDirtyInRdt(document, out rdtHier, out perDocData, out cookie); } } } //if (runEvenIfNotDirty || outputOutOfDate) { //Get the buffer contents for the current node string moniker = fileNode.GetMkDocument(); this.runningGenerator = true; anyGeneratorsRunning++; //Get the generator IVsSingleFileGenerator generator; int generateDesignTimeSource; int generateSharedDesignTimeSource; int generateTempPE; SingleFileGeneratorFactory factory = new SingleFileGeneratorFactory(this.ProjectMgr.ProjectGuid, this.ProjectMgr.Site); ErrorHandler.ThrowOnFailure(factory.CreateGeneratorInstance(customToolProgID, out generateDesignTimeSource, out generateSharedDesignTimeSource, out generateTempPE, out generator)); //Check to see if the generator supports siting IObjectWithSite objWithSite = generator as IObjectWithSite; if (objWithSite != null) { objWithSite.SetSite(fileNode.OleServiceProvider); } //Determine the namespace if (string.IsNullOrEmpty(customToolNamespace)) { customToolNamespace = this.ComputeNamespace(moniker); } //Run the generator IntPtr[] output = new IntPtr[1]; output[0] = IntPtr.Zero; uint outPutSize; if (dependentNodeName == null) { string extension = null; try { generator.DefaultExtension(out extension); } catch (Exception e) { if (System.Diagnostics.Debugger.IsAttached) { Debug.WriteLine(e); } } if (!String.IsNullOrEmpty(extension)) { dependentNodeName = Path.GetFileNameWithoutExtension(fileNode.FileName) + extension; } else { dependentNodeName = fileNode.FileName; } } //If you found a dependent node. if (dependentNode != null) { //Then check out the node and dependent node from SCC if (!this.CanEditFile(dependentNode.GetMkDocument())) { throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED); } } else //It is a new node to be added to the project { // Check out the project file if necessary. if (!this.ProjectMgr.QueryEditProjectFile(false)) { throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED); } } IVsTextStream stream; string inputFileContents = this.GetBufferContents(moniker, out stream); var res = generator.Generate(moniker, inputFileContents, customToolNamespace, output, out outPutSize, this); byte[] data = new byte[outPutSize]; if (output[0] != IntPtr.Zero) { Marshal.Copy(output[0], data, 0, (int)outPutSize); Marshal.FreeCoTaskMem(output[0]); } //Todo - Create a file and add it to the Project string fileToAdd = this.UpdateGeneratedCodeFile(fileNode, data, (int)outPutSize, dependentNodeName, dependentNode); } } } finally { this.runningGenerator = false; anyGeneratorsRunning--; } }
private IEnumerable <HierarchyNode <IContainable> > AddContainersToRootContainer(HierarchyNode <IContainable> rootContainer, IEnumerable <IContainable> containersToProcess) { var addedContainers = new List <HierarchyNode <IContainable> >(new HierarchyNode <IContainable>[] { rootContainer }); var queue = new Queue <IContainable>(containersToProcess); while (queue.Count > 0) { var current = queue.Dequeue(); if (current.ContainerName == current.Name) { throw new N2Exception("The container '{0}' cannot reference itself as containing container. Change the ContainerName property.", current.Name); } string containerName = current.ContainerName; var container = addedContainers.FirstOrDefault(c => c.Current.Name == containerName); if (container != null) { // the container was previously in the loop var node = new HierarchyNode <IContainable>(current); container.Add(node); addedContainers.Add(node); } else if (!queue.Any(c => c.Name == containerName)) { // no container - add to root var node = new HierarchyNode <IContainable>(current); rootContainer.Add(node); addedContainers.Add(node); } else { // the container is in the queue - add this to end queue.Enqueue(current); } } return(addedContainers); }
/// <summary> /// Invokes the specified generator /// </summary> /// <param name="fileNode">The node on which to invoke the generator.</param> protected internal virtual void InvokeGenerator(FileNode fileNode) { if (fileNode == null) { throw new ArgumentNullException("node"); } SingleFileGeneratorNodeProperties nodeproperties = fileNode.NodeProperties as SingleFileGeneratorNodeProperties; if (nodeproperties == null) { throw new InvalidOperationException(); } string customToolProgID = nodeproperties.CustomTool; if (string.IsNullOrEmpty(customToolProgID)) { return; } string customToolNamespace = nodeproperties.CustomToolNamespace; try { if (!this.runningGenerator) { //Get the buffer contents for the current node string moniker = fileNode.GetMkDocument(); this.runningGenerator = true; //Get the generator IVsSingleFileGenerator generator; int generateDesignTimeSource; int generateSharedDesignTimeSource; int generateTempPE; SingleFileGeneratorFactory factory = new SingleFileGeneratorFactory(this.projectMgr.ProjectGuid, this.projectMgr.Site); ErrorHandler.ThrowOnFailure(factory.CreateGeneratorInstance(customToolProgID, out generateDesignTimeSource, out generateSharedDesignTimeSource, out generateTempPE, out generator)); //Check to see if the generator supports siting IObjectWithSite objWithSite = generator as IObjectWithSite; if (objWithSite != null) { objWithSite.SetSite(fileNode.OleServiceProvider); } //Determine the namespace if (string.IsNullOrEmpty(customToolNamespace)) { customToolNamespace = this.ComputeNamespace(moniker); } //Run the generator IntPtr[] output = new IntPtr[1]; output[0] = IntPtr.Zero; uint outPutSize; string extension; ErrorHandler.ThrowOnFailure(generator.DefaultExtension(out extension)); //Find if any dependent node exists string dependentNodeName = Path.GetFileNameWithoutExtension(fileNode.FileName) + extension; HierarchyNode dependentNode = fileNode.FirstChild; while (dependentNode != null) { if (string.Compare(dependentNode.ItemNode.GetMetadata(ProjectFileConstants.DependentUpon), fileNode.FileName, StringComparison.OrdinalIgnoreCase) == 0) { dependentNodeName = ((FileNode)dependentNode).FileName; break; } dependentNode = dependentNode.NextSibling; } //If you found a dependent node. if (dependentNode != null) { //Then check out the node and dependent node from SCC if (!this.CanEditFile(dependentNode.GetMkDocument())) { throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED); } } else //It is a new node to be added to the project { // Check out the project file if necessary. if (!this.projectMgr.QueryEditProjectFile(false)) { throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED); } } IVsTextStream stream; string inputFileContents = this.GetBufferContents(moniker, out stream); ErrorHandler.ThrowOnFailure(generator.Generate(moniker, inputFileContents, customToolNamespace, output, out outPutSize, this)); byte[] data = new byte[outPutSize]; if (output[0] != IntPtr.Zero) { Marshal.Copy(output[0], data, 0, (int)outPutSize); Marshal.FreeCoTaskMem(output[0]); } //Todo - Create a file and add it to the Project string fileToAdd = this.UpdateGeneratedCodeFile(fileNode, data, (int)outPutSize, dependentNodeName); } } finally { this.runningGenerator = false; } }
public void Set(HierarchyNode node) { selection.Clear(); selection.Add(new NodeProperties(node)); }
public SingleFileGeneratorNodeProperties(HierarchyNode node) : base(node) { }
public NemerleProjectReferencesProperties(HierarchyNode node, string className) : base(node) { _className = className + "!"; }
public OAProjectItems(OAProject project, HierarchyNode nodeWithItems) : base(project, nodeWithItems) { }
protected virtual Node <TreeNode> GetStructure(HierarchyNode <ContentItem> structure, ItemFilter filter) { return(structure.CreateNode(engine.Resolve <IContentAdapterProvider>(), filter)); }
public ReferenceNodeProperties(HierarchyNode node) : base(node) { }
/// <summary> /// Handles command status on source a node. Should be overridden by descendant nodes. /// </summary> /// <param name="node">A HierarchyNode that implements the IProjectSourceNode interface.</param> /// <param name="guidCmdGroup">A unique identifier of the command group. The pguidCmdGroup parameter can be NULL to specify the standard group.</param> /// <param name="cmd">The command to query status for.</param> /// <param name="result">An out parameter specifying the QueryStatusResult of the command.</param> /// <param name="returnCode">If the method succeeds, it returns S_OK. If it fails, it returns an error code.</param> /// <returns>Returns true if the status request is handled, false otherwise.</returns> internal static bool QueryStatusOnProjectSourceNode(HierarchyNode node, Guid guidCmdGroup, uint cmd, ref QueryStatusResult result, out int returnCode) { if (guidCmdGroup == VsMenus.guidStandardCommandSet2K) { IProjectSourceNode sourceNode = node as IProjectSourceNode; switch ((VsCommands2K)cmd) { case VsCommands2K.SHOWALLFILES: { WixProjectNode projectNode = node.ProjectMgr as WixProjectNode; result |= QueryStatusResult.SUPPORTED | QueryStatusResult.ENABLED; if (projectNode != null && projectNode.ShowAllFilesEnabled) { result |= QueryStatusResult.LATCHED; // it should be displayed as pressed } returnCode = VSConstants.S_OK; return(true); // handled. } case VsCommands2K.INCLUDEINPROJECT: // if it is a non member item node, the we support "Include In Project" command if (sourceNode != null && sourceNode.IsNonMemberItem) { result |= QueryStatusResult.SUPPORTED | QueryStatusResult.ENABLED; returnCode = VSConstants.S_OK; return(true); // handled. } break; case VsCommands2K.EXCLUDEFROMPROJECT: // if it is a non member item node, then we don't support "Exclude From Project" command if (sourceNode != null && sourceNode.IsNonMemberItem) { returnCode = (int)OleConstants.MSOCMDERR_E_NOTSUPPORTED; return(true); // handled. } break; } } if (VsMenus.guidStandardCommandSet97 == guidCmdGroup) { switch ((VsCommands)cmd) { case VsCommands.AddNewItem: case VsCommands.AddExistingItem: result = QueryStatusResult.SUPPORTED | QueryStatusResult.ENABLED; returnCode = VSConstants.S_OK; return(true); case VsCommands.SetStartupProject: result = QueryStatusResult.SUPPORTED | QueryStatusResult.INVISIBLE; returnCode = VSConstants.S_OK; return(true); } } // just an arbitrary value, it doesn't matter if method hasn't handled the request returnCode = VSConstants.S_FALSE; // not handled return(false); }
protected virtual string UpdateGeneratedCodeFile(FileNode fileNode, byte[] data, int size, string fileName, HierarchyNode dependentNode) { string filePath = Path.Combine(Path.GetDirectoryName(fileNode.GetMkDocument()), fileName); IVsRunningDocumentTable rdt = this.ProjectMgr.GetService(typeof(SVsRunningDocumentTable)) as IVsRunningDocumentTable; // (kberes) Shouldn't this be an InvalidOperationException instead with some not to annoying errormessage to the user? if (rdt == null) { ErrorHandler.ThrowOnFailure(VSConstants.E_FAIL); } IVsHierarchy hier; uint cookie; uint itemid; IntPtr docData = IntPtr.Zero; ErrorHandler.ThrowOnFailure(rdt.FindAndLockDocument((uint)(_VSRDTFLAGS.RDT_NoLock), filePath, out hier, out itemid, out docData, out cookie)); if (docData != IntPtr.Zero) { Marshal.Release(docData); IVsTextStream srpStream; string inputFileContents = this.GetBufferContents(filePath, out srpStream); if (srpStream != null) { int oldLen = 0; int hr = srpStream.GetSize(out oldLen); if (ErrorHandler.Succeeded(hr)) { IntPtr dest = IntPtr.Zero; try { if (data.Length > 2 && data[0] == 0xEF && data[1] == 0xBB && data[2] == 0xBF) { // the data is in UTF-8 format and must be converted to Unicode, since the IVsTextStream // buffer is always Unicode // // The ResXCodeGenerator generates UTF-8 code, other SingleFileGenerators might do the same thing, who knows? string txt = new System.Text.UTF8Encoding().GetString(data, 3, data.Length - 3); // skip over encoding preamble UnicodeEncoding enc = new UnicodeEncoding(); int len = enc.GetByteCount(txt); Byte[] unicodeData = new Byte[len]; enc.GetBytes(txt, 0, txt.Length, unicodeData, 0); dest = Marshal.AllocCoTaskMem(len); Marshal.Copy(unicodeData, 0, dest, unicodeData.Length); ErrorHandler.ThrowOnFailure(srpStream.ReplaceStream(0, oldLen, dest, len / 2)); // Note: 4th param is # of chars, not bytes! } // end of changes else { dest = Marshal.AllocCoTaskMem(data.Length); Marshal.Copy(data, 0, dest, data.Length); ErrorHandler.ThrowOnFailure(srpStream.ReplaceStream(0, oldLen, dest, size / 2)); } // for now, always save the generated file. Otherwise we have issues when the source file is dirty and the user // builds the project. The generator runs (because of the overridden SaveItem() in the project node) but the generated // file ends up dirty and when the project is built, everything should be saved. // We could probably force a save on that node, but it seems cleaner to always save the generated file. int canceled; ErrorHandler.ThrowOnFailure(this.ProjectMgr.SaveItem(VSSAVEFLAGS.VSSAVE_SilentSave, filePath, dependentNode.ID, docData, out canceled)); } finally { if (dest != IntPtr.Zero) { Marshal.Release(dest); } } } } } else { using (FileStream generatedFileStream = File.Open(filePath, FileMode.OpenOrCreate)) { generatedFileStream.Write(data, 0, size); // adjust length, in case the file shrinks in size.. generatedFileStream.SetLength(size); } EnvDTE.ProjectItem projectItem = fileNode.GetAutomationObject() as EnvDTE.ProjectItem; if (projectItem != null && (this.ProjectMgr.FindChild(fileNode.FileName) == null)) { projectItem.ProjectItems.AddFromFile(filePath); } } return(filePath); }