public void RemoveItem(CatalogItem item) { if (item != null && this.SelectedNode != null) { this.SelectedNode.Nodes.RemoveByKey(item.VPath); //Refresh(); } }
internal void Reload(CatalogItem target) { if (target != null) { foreach (TreeNode node in Nodes) { if (target.Equals(node.Tag as CatalogItem)) { node.Text = (node.Tag as CatalogItem).Name; return; } } } foreach (TreeNode node in Nodes) { if (ReloadTreeNode(target, node)) return; } }
private TreeNode[] BuildChildren(Catalog cat, CatalogItem folder) { DateTime start = DateTime.Now; //Application.DoEvents(); List<TreeNode> firstLevelNodes = new List<TreeNode>(); if (folder.IsFolder) { CatalogItem[] children = cat.FindItems(folder, "FLD", string.Empty, string.Empty, true); List<CatalogItem> childList = new List<CatalogItem>(children); childList.Sort(delegate(CatalogItem ci1, CatalogItem ci2) { if (ci1 == null && ci2 == null) return 0; if (ci1 == null) return -1; if (ci2 == null) return 1; if (ci1.ParentItemID == ci2.ParentItemID) { return (int)(ci1.ItemID - ci2.ItemID); } else { return (int)(ci1.ParentItemID - ci2.ParentItemID); } }); Dictionary<long, TreeNode> treeNodes = new Dictionary<long, TreeNode>(); for (int i = 0; i < childList.Count; i++) { TreeNode node = new TreeNode(childList[i].Name); node.Name = childList[i].VPath; node.Tag = childList[i]; node.ImageIndex = node.SelectedImageIndex = (int)childList[i].ItemType + 1; if (treeNodes.ContainsKey(childList[i].ParentItemID)) { treeNodes[childList[i].ParentItemID].Nodes.Add(node); } if (!treeNodes.ContainsKey(childList[i].ItemID)) { treeNodes.Add(childList[i].ItemID, node); } if (childList[i].ParentItemID == folder.ItemID) { firstLevelNodes.Add(node); } } } return firstLevelNodes.ToArray(); }
private void BuildMenuText(ToolStripItem tsm, string tag, CatalogItem targetItem, OPMShortcut command) { BuildMenuText(tsm, tag, (targetItem != null) ? targetItem.OrigItemPath : string.Empty, command); }
private string BuildLaunchPath(CatalogItem ci, bool singleFile) { string launchPath = string.Empty; if (ci != null && ci.OrigItemPath.StartsWith("$:")) { if (!singleFile && _prevSerialNumber == ci.RootSerialNumber) { launchPath = ci.OrigItemPath.Replace("$", _prevDriveLetter); } else { CatalogItem root = _cat.GetRootBySerialNumber(ci.RootSerialNumber); if (root != null) { InsertDriveNotifyDialog dlg = new InsertDriveNotifyDialog( ci.RootItemLabel, root.Description, ci.RootSerialNumber, (DriveType)root.ItemType); if (dlg.ShowDialog() == DialogResult.OK) { string driveLetter = dlg.ActualDriveLetter.Substring(0, 1); launchPath = ci.OrigItemPath.Replace("$", driveLetter); _prevSerialNumber = ci.RootSerialNumber; _prevDriveLetter = driveLetter; } } } } else { launchPath = ci.OrigItemPath; } return launchPath; }
private void BrowseCatalogFolder(CatalogItem folder, CatalogItem prevFolder = null) { try { Cursor = Cursors.WaitCursor; if (folder != null) { lvCatalogFolder.DisplayCatalogFolder(_cat, folder, prevFolder); _curFolder = folder; List<string> paths = new List<string>(); paths.Add(folder.VPath); RaiseNavigationAction(NavActionType.ActionSelectDirectory, paths, _cat); if (tvCatalog.SelectedNode == null || tvCatalog.SelectedNode.Tag as CatalogItem != folder) { tvCatalog.AfterSelect -= new TreeViewEventHandler(tvCatalog_AfterSelect); tvCatalog.SelectedNode = null; TreeNode[] matchingNodes = tvCatalog.Nodes.Find(folder.VPath, true); if (matchingNodes != null && matchingNodes.Length > 0) { tvCatalog.SelectedNode = matchingNodes[0]; } tvCatalog.AfterSelect += new TreeViewEventHandler(tvCatalog_AfterSelect); } } else { lvCatalogFolder.DisplayCatalogRoots(_cat); _curFolder = null; List<string> paths = new List<string>(); paths.Add(Catalog.CatalogVPath); RaiseNavigationAction(NavActionType.ActionSelectDirectory, paths, _cat); } } finally { Cursor = Cursors.Default; } }
public void RemoveItem(CatalogItem item) { if (item != null) { foreach (ListViewItem row in this.Items) { if (item.Equals(row.Tag as CatalogItem)) { this.Items.Remove(row); break; } } } }
public TreeNode FindNode(CatalogItem item) { return FindNode(this.Nodes[0], item); }
private CatalogItem[] GetItemArray(CatalogDataset.CatalogItemsRow[] rows) { CatalogItem[] instances = new CatalogItem[rows.Length]; for (int i = 0; i < rows.Length; i++) { instances[i] = new CatalogItem(this, rows[i]); } return instances; }
public CatalogItem[] FindItems(CatalogItem parent, string typeCode, string namePattern, string descPattern, bool searchSubfolders) { CatalogItemType type = CatalogItemType_GetByTypeCode(typeCode); string parentPath = null; long parentItemId = -1; if (parent != null) { if (searchSubfolders) { parentPath = parent.OrigItemPath.TrimEnd("/\\".ToCharArray()); } else { parentItemId = parent.ItemID; } } var rows = from row in CatalogItems where ( (type == null || type.TypeID == row.ItemTypeID) && (string.IsNullOrEmpty(parentPath) || (row.OrigItemPath.ToLowerInvariant().StartsWith(parentPath.ToLowerInvariant()))) && (parentItemId < 0 || row.ParentItemID == parentItemId) && (string.IsNullOrEmpty(namePattern) || row.Name.ToLowerInvariant().Contains(namePattern.ToLowerInvariant())) && (string.IsNullOrEmpty(descPattern) || row.Description.ToLowerInvariant().Contains(descPattern.ToLowerInvariant())) ) select row; return GetItemArray(rows.ToArray()); }
//public CatalogItemType[] GetAll() //{ // var rows = from row in CatalogItemTypes // select row; // return GetArray(rows); //} internal int CountChildren(CatalogItem catalogItem, bool recursive, ChildType childType) { if (CatalogItemType_GetByTypeID(catalogItem.ItemType).TypeCode == "FIL") return 0; // A file cannot have any children string typeCode = string.Empty; switch (childType) { case ChildType.File: typeCode = "FIL"; break; case ChildType.Folder: typeCode = "FLD"; break; } CatalogItem[] children = FindItems(catalogItem, typeCode, string.Empty, string.Empty, true); if (children != null) return children.Length; return 0; }
private void MergeCatalogItem(Catalog origCatalog, CatalogItem origItem, CatalogItem parentItem) { // We create a new CatalogItem, because the existing one // belongs to other catalog, and all its relations are based // on that catalog. We need, though, an item related to this catalog. CatalogItem newItem = new CatalogItem(this); // After creation we migrate all properties. newItem.OrigItemPath = origItem.OrigItemPath; newItem.IsRoot = origItem.IsRoot; newItem.RootItemLabel = origItem.RootItemLabel; newItem.RootSerialNumber = origItem.RootSerialNumber; newItem.Name = origItem.Name; newItem.ItemType = origItem.ItemType; newItem.Description = origItem.Description; if (parentItem != null) { newItem.ParentItemID = parentItem.ItemID; } // Explore children if any if (origItem.IsFolder) { CatalogItem[] children = origCatalog.GetByParentItemID(origItem.ItemID); if (children != null) { foreach (CatalogItem child in children) { MergeCatalogItem(origCatalog, child, newItem); Application.DoEvents(); } } } // Save changes. newItem.Save(); }
internal void Reload(CatalogItem target) { foreach (ListViewItem item in this.Items) { CatalogItem ci = item.Tag as CatalogItem; if (ci != null) { if (target != null) { if (target.Equals(ci)) { item.SubItems[colItemName.Index].Text = ci.Name; return; } } else { item.SubItems[colItemName.Index].Text = ci.Name; } } } }
public void FindNode(CatalogItem item) { if (this.Items != null) { foreach (ListViewItem node in this.Items) { CatalogItem nodeItem = node.Tag as CatalogItem; if (nodeItem == null) continue; if (nodeItem.VPath == item.VPath) { node.EnsureVisible(); node.Selected = true; return; } } } }
public void DisplayCatalogFolder(Catalog cat, CatalogItem folder, CatalogItem prevFolder = null) { this.Items.Clear(); _cat = cat; if (folder != null) { CatalogItem[] children = cat.GetByParentItemID(folder.ItemID); foreach (CatalogItem child in children) { int imgIndex = 0; if (child.IsFolder) { imgIndex = (int)child.ItemType + 1; } else { string ext = PathUtils.GetExtension(child.OrigItemPath); if (ilItems.Images.ContainsKey(ext)) { imgIndex = ilItems.Images.IndexOfKey(ext); } else { Image img = ImageProvider.GetIconOfFileType(ext); if (img != null) { ilItems.Images.Add(ext, img); imgIndex = ilItems.Images.Count - 1; } } } string[] data = new string[] { child.Name, child.DateCreated, child.OrigItemPath }; ListViewItem item = new ListViewItem(data); item.ImageIndex = imgIndex; item.Tag = child; this.Items.Add(item); } bool selectFirst = (this.Items.Count > 0); int lastVisibleIndex = 0; foreach (ListViewItem item in this.Items) { CatalogItem ci = item.Tag as CatalogItem; if (ci != null && prevFolder != null && ci.VPath == prevFolder.VPath) { item.Selected = true; item.Focused = true; lastVisibleIndex = item.Index; selectFirst = false; break; } } if (selectFirst) { Items[0].Selected = true; Items[0].Focused = true; } else { EnsureVisible(lastVisibleIndex); } this.Select(); this.Focus(); } }
private bool ReloadTreeNode(CatalogItem target, TreeNode tn) { CatalogItem ci = tn.Tag as CatalogItem; if (ci != null) { if (target != null) { if (target.Equals(tn.Tag as CatalogItem)) { tn.Text = (tn.Tag as CatalogItem).Name; return true; } } else { tn.Text = ci.Name; } } if (tn.Nodes != null && tn.Nodes.Count > 0) { if (target != null) { foreach (TreeNode node in tn.Nodes) { if (target.Equals(node.Tag as CatalogItem)) { node.Text = (node.Tag as CatalogItem).Name; return true; } } } foreach (TreeNode node in tn.Nodes) { if (ReloadTreeNode(target, node)) return true; } } return false; }
public void ScanFolder(Catalog cat, DirectoryInfo dir, CatalogItem parent) { if (!CanContinue()) return; ReportPseudoStepInit("TXT_SCANNING: " + dir.FullName); try { DriveInfo di = new DriveInfo(dir.Root.FullName); CatalogItem ci = new CatalogItem(cat); if (di.DriveType == DriveType.Removable || di.DriveType == DriveType.CDRom) { ci.OrigItemPath = dir.FullName.Replace(dir.Root.FullName, "$:/"); if (PathUtils.DirectorySeparator != "/") ci.OrigItemPath = ci.OrigItemPath.Replace(PathUtils.DirectorySeparator, "/"); } else { ci.OrigItemPath = dir.FullName; } ci.IsRoot = (parent == null); ci.RootItemLabel = di.VolumeLabel; ci.RootSerialNumber = Kernel32.GetVolumeSerialNumber(di.RootDirectory.FullName); ci.Name = GetName(dir, di); if (parent != null) { ci.ParentItemID = parent.ItemID; } if (ci.IsRoot) { // This is a disk ci.ItemType = (byte)di.DriveType; ci.Description = EntryDescription; } else { ci.ItemType = cat.CatalogItemType_GetByTypeCode("FLD").TypeID; // is a folder } ci.Save(); Application.DoEvents(); IEnumerable<string> strDirs = Directory.EnumerateDirectories(dir.FullName, "*", SearchOption.TopDirectoryOnly); if (strDirs != null) { foreach (string dirPath in strDirs) { ScanFolder(cat, new DirectoryInfo(dirPath), ci); } } IEnumerable<string> strFiles = Directory.EnumerateFiles(dir.FullName, "*", SearchOption.TopDirectoryOnly); if (strFiles != null) { foreach (string filePath in strFiles) { ScanFile(cat, new FileInfo(filePath), ci); } } RaiseTaskProgressEvent(null, _currentStep++); } catch(Exception ex) { ConfirmScanAbortOnException(ex); } }
private void ScanFile(Catalog cat, FileInfo file, CatalogItem parent) { if (!CanContinue()) return; ReportPseudoStepInit("TXT_SCANNING: " + file.FullName); try { CatalogItem ci = new CatalogItem(cat); ci.IsRoot = false; ci.ItemType = cat.CatalogItemType_GetByTypeCode("FIL").TypeID; // is a file ci.Name = file.Name; DriveInfo di = new DriveInfo(file.Directory.Root.FullName); if (di.DriveType == DriveType.Removable || di.DriveType == DriveType.CDRom) { ci.OrigItemPath = file.FullName.Replace(file.Directory.Root.FullName, "$:/"); if (PathUtils.DirectorySeparator != "/") ci.OrigItemPath = ci.OrigItemPath.Replace(PathUtils.DirectorySeparator, "/"); } else { ci.OrigItemPath = file.FullName; } ci.RootItemLabel = di.VolumeLabel; ci.RootSerialNumber = Kernel32.GetVolumeSerialNumber(di.RootDirectory.FullName); ci.ParentItemID = parent.ItemID; try { NativeFileInfo nfi = NativeFileInfoFactory.FromPath(file.FullName); if (nfi != null) { ci.Description = nfi.Details; } } catch(Exception ex) { Logger.LogException(ex); } ci.Save(); RaiseTaskProgressEvent(null, _currentStep++); } catch (Exception ex) { ConfirmScanAbortOnException(ex); } Application.DoEvents(); }
private TreeNode FindNode(TreeNode startNode, CatalogItem item) { CatalogItem startNodeItem = startNode.Tag as CatalogItem; if (startNodeItem != null && startNodeItem.VPath == item.VPath) { return startNode; } if (startNode.Nodes != null) { foreach (TreeNode node in startNode.Nodes) { TreeNode xNode = FindNode(node, item); if (xNode != null) return xNode; } } return null; }
private void CreateItem(CatalogItem item) { CatalogItem byRootSerialNumber = theTask.Catalog.GetRootBySerialNumber(item.RootSerialNumber); string str = (byRootSerialNumber != null) ? byRootSerialNumber.Name : Translator.Translate("TXT_NA"); int imgIndex = -1; if (item.IsFolder) { imgIndex = (int)item.ItemType + 1; } else { string ext = PathUtils.GetExtension(item.OrigItemPath); if (ilImages.Images.ContainsKey(ext)) { imgIndex = ilImages.Images.IndexOfKey(ext); } else { Image img = ImageProvider.GetIconOfFileType(ext); if (img != null) { ilImages.Images.Add(img); imgIndex = ilImages.Images.Count - 1; } } } string[] data = new string[] { "", str, item.RootItemLabel, item.OrigItemPath }; ListViewItem lvItem = new ListViewItem(data); lvItem.Tag = item.VPath; lvItem.ImageIndex = imgIndex; lvResults.Items.Add(lvItem); }