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