/// <summary>
/// Initializes a new instance of the <see cref="ShellTreeView"/> class.
/// </summary>
public ShellTreeView()
{
// TODO: Shell tree views should be double buffered.
// Set the image list to the shell image list.
this.SetImageList(TreeViewExtensions.ImageListType.Normal, ShellImageList.GetImageList(ShellImageListSize.Small));
}
//**********************************************************************************************
public void QueueDownloadItem(bool IsDir, string source, string destination, string name, int ImageIndex, long size)
{
form.currentItem.Text = $"Queueing {source}";
Cursor.Current = Cursors.WaitCursor;
QueueItem queue = new QueueItem();
queue.Download = true;
queue.SourceIsdir = IsDir;
queue.SourcePath = source;
queue.ImageIndex = ImageIndex;
queue.Name = name;
queue.DestinationPath = Path.Combine(destination, name);
queue.Status = QueueStatus.Queue;
queue.Size = size;
InsertOnQueue(queue);
if (IsDir)
{
var task = Task.Run(async() => await remoteIO.ListDirectory(source));
var result = task.Result;
if (result.Success)
{
foreach (XwRemoteIOItem item in result.Items)
{
int image = ShellImageList.GetFileImageIndex(item.Name, (item.IsDirectory) ? FileAttributes.Directory : FileAttributes.Archive);
QueueDownloadItem(item.IsDirectory, item.FullName, queue.DestinationPath, item.Name, image, item.Size);
}
}
else
{
form.Log(result.Message, Color.Red);
}
}
}
public void LoadItems()
{
while (myWorker != null && myWorker.ThreadState == ThreadState.AbortRequested)
{
}
//BeginUpdate();
//Items.Clear();
LargeImageList.Images.Clear();
SmallImageList.Images.Clear();
AddDefaultThumb(this.LargeImageList);
AddDefaultThumb(this.SmallImageList);
string[] fileList = new string[this.Items.Count];
for (int i = 0; i < this.Items.Count; i++)
//foreach (string fileName in fileList)
{
this.Items[i].ImageIndex = 0;
Bitmap image = ShellImageList.GetIcon(((ShellItem)this.Items[i].Tag).ImageIndex, true).ToBitmap();
this.SmallImageList.Images.Add(image);
fileList[i] = ShellItem.GetRealPath((ShellItem)this.Items[i].Tag);
}
//EndUpdate();
ParameterizedThreadStart threadStart = new ParameterizedThreadStart(this.bwLoadImages_DoWork);
myWorker = new Thread(threadStart);
myWorker.CurrentCulture = Thread.CurrentThread.CurrentCulture;
myWorker.CurrentUICulture = Thread.CurrentThread.CurrentUICulture;
myWorker.IsBackground = true;
myWorker.Start(fileList);
//this.AnimateTime.Start();
}
//***********************************************************************************************
public void Load()
{
BeginUpdate();
Nodes.Clear();
desktop = new TreeNode(System.Environment.SpecialFolder.Desktop.ToString());
desktop.Tag = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
desktop.ImageIndex = desktop.SelectedImageIndex = ShellImageList.GetSpecialFolderImageIndex(ShellAPI.CSIDL.DESKTOP);
Nodes.Add(desktop);
SelectedNode = desktop;
TreeNode documents = new TreeNode(System.Environment.SpecialFolder.MyDocuments.ToString());
documents.Tag = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
documents.ImageIndex = documents.SelectedImageIndex = ShellImageList.GetFileImageIndex(documents.Tag.ToString(), FileAttributes.Directory | FileAttributes.System);
desktop.Nodes.Add(documents);
LoadNode(documents, true);
computer = new TreeNode(System.Environment.SpecialFolder.MyComputer.ToString());
computer.Tag = Environment.GetFolderPath(Environment.SpecialFolder.MyComputer);
computer.ImageIndex = computer.SelectedImageIndex = ShellImageList.GetSpecialFolderImageIndex(ShellAPI.CSIDL.DRIVES);
desktop.Nodes.Add(computer);
foreach (DriveInfo drive in DriveInfo.GetDrives())
{
if (string.Compare(drive.Name, "A:\\", true) == 0 && drive.DriveType == DriveType.Removable)
{
continue;
}
if (string.Compare(drive.Name, "B:\\", true) == 0 && drive.DriveType == DriveType.Removable)
{
continue;
}
string name = String.Format("{0} ({1})", (drive.IsReady)?drive.VolumeLabel:drive.DriveType.ToString(), drive.Name.Replace("\\", ""));
TreeNode drvNode = new TreeNode(name);
drvNode.Tag = drive.RootDirectory.FullName;
drvNode.ImageIndex = drvNode.SelectedImageIndex = ShellImageList.GetFileImageIndex(drive.Name, FileAttributes.Device);
computer.Nodes.Add(drvNode);
if (drive.IsReady)
{
DirectoryInfo checkD = new DirectoryInfo(drive.RootDirectory.FullName);
DirectoryInfo[] check = checkD.GetDirectories();
if (check.Length > 0)
{
TreeNode dummy = new TreeNode(string.Empty);
drvNode.Nodes.Add(dummy);
}
}
}
LoadNode(desktop, true);
desktop.Expand();
computer.Expand();
EndUpdate();
RegisterForDeviceChange(true);
}
//*************************************************************************************************************
private void OnLoad(object sender, EventArgs e)
{
ShellImageList.SetSmallImageList(LocalList);
ShellImageList.SetSmallImageList(RemoteList);
LocalList.Init(this);
RemoteList.Init(this, remoteIO);
QueueList.Init(this, remoteIO);
localPinTip.SetToolTip(LocalPin, "");
remotePinTip.SetToolTip(RemotePin, "");
linkTip.SetToolTip(LinkPath, "");
}
//*************************************************************************************************************
public void QueueUploadItem(bool IsDir, string source, string destination, string name, int ImageIndex, long size)
{
if (source.IsIn(".", ".."))
{
return;
}
form.statusMainLabel.Text = $"Queueing {source}";
QueueItem queue = new QueueItem();
queue.Download = false;
queue.SourceIsdir = IsDir;
queue.SourcePath = source;
queue.ImageIndex = ImageIndex;
queue.Name = name;
queue.DestinationPath = Path.Combine(destination, name);
queue.Status = QueueStatus.Queue;
queue.Size = size;
queue.CancelTokenSource = new CancellationTokenSource();
InsertOnQueue(queue);
if (IsDir)
{
DirectoryInfo DirInfo = new DirectoryInfo(source);
foreach (DirectoryInfo dir in DirInfo.GetDirectories())
{
if ((dir.Attributes & FileAttributes.Hidden) != 0)
{
continue;
}
QueueUploadItem(true, dir.FullName, queue.DestinationPath, dir.Name,
ShellImageList.GetFileImageIndex("Folder", FileAttributes.Directory), 0);
}
foreach (FileInfo file in DirInfo.GetFiles())
{
if ((file.Attributes & FileAttributes.Hidden) != 0)
{
continue;
}
QueueUploadItem(false, file.FullName, queue.DestinationPath, file.Name,
ShellImageList.GetFileImageIndex(file.Name, FileAttributes.Archive), file.Length);
}
}
}
private void selectedPlaceProps_PropertyValueChanged(object s, PropertyValueChangedEventArgs e)
{
FileDialogPlaceBase place = (FileDialogPlaceBase)placesListBox.SelectedItem;
((CurrencyManager)placesListBox.BindingContext[m_places]).Refresh();
bool multipleLines;
ToolStripButton placeButton = (ToolStripButton)placesBar.Items[placesListBox.SelectedIndex];
placeButton.Text = FileDialog.InsertLineBreaks(place.Text, out multipleLines);
placeButton.Padding = new Padding(0, multipleLines ? 3 : 8, 0, multipleLines ? 0 : 8);
if (e.ChangedItem.Label == "Path")
{
placeButton.Image = ShellImageList.GetImage(place.PIDL);
}
}
public ExplorerListView() : base()
{
imageList = ShellImageList.Instance;
mre = new ManualResetEvent(true);
HandleCreated += new EventHandler(ExplorerListView_HandleCreated);
VisibleChanged += new EventHandler(ExplorerListView_VisibleChanged);
sorter = new ExplorerListSorter();
HeaderStyle = ColumnHeaderStyle.Nonclickable;
SetStyle(ControlStyles.AllPaintingInWmPaint, true);
SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
HideSelection = false;
SetColumns();
View = View.Details;
worker = new BackgroundWorker();
InitializeBackgroundWorker();
}
//*************************************************************************************************************
private void OnLoad(object sender, EventArgs e)
{
ShellImageList.SetSmallImageList(LocalList);
ShellImageList.SetSmallImageList(RemoteList);
statusMain.Items["statusMainLabel"].Text = "";
statusLocal.Items["statusLocalLabel"].Text = "";
statusRemote.Items["statusRemoteLabel"].Text = "";
LocalList.Init(this);
RemoteList.Init(this, remoteIO);
QueueList.Init(this, remoteIO);
localPinTip.SetToolTip(LocalPin, "");
remotePinTip.SetToolTip(RemotePin, "");
linkTip.SetToolTip(LinkPath, "");
}
//*************************************************************************************************************
private void this_DragDrop(object sender, DragEventArgs e)
{
if (e.Data.GetDataPresent(DataFormats.FileDrop)) //from explorer
{
string[] filePaths = (string[])e.Data.GetData("FileDrop");
Cursor.Current = Cursors.WaitCursor;
foreach (string path in filePaths)
{
DiskItem disk;
int imageIndex = 0;
if (Directory.Exists(path))
{
disk = new DiskItem(true, false, path, Path.GetFileName(path));
imageIndex = ShellImageList.GetFileImageIndex(disk.path, FileAttributes.Directory);
}
else
{
FileInfo f = new FileInfo(path);
disk = new DiskItem(false, false, path, Path.GetFileName(path), f.Length);
imageIndex = ShellImageList.GetFileImageIndex(disk.path, File.GetAttributes(path));
}
form.QueueList.QueueUploadItem(disk.IsDirectory, disk.path,
CurrentDirectory, disk.name, imageIndex, disk.size);
}
}
else //from listview
{
System.Windows.Forms.ListView.SelectedListViewItemCollection items =
(System.Windows.Forms.ListView.SelectedListViewItemCollection)e.Data.GetData(
typeof(System.Windows.Forms.ListView.SelectedListViewItemCollection));
Cursor.Current = Cursors.WaitCursor;
foreach (ListViewItem item in items)
{
DiskItem disk = (DiskItem)item.Tag;
form.QueueList.QueueUploadItem(disk.IsDirectory, disk.path,
CurrentDirectory, disk.name, item.ImageIndex, disk.size);
}
}
form.QueueList.StartQueue();
form.LocalList.AllowDrop = true;
AllowDrop = true;
}
private void fileBrowser_SelectedFolderChanged(object sender, SelectedFolderChangedEventArgs e)
{
Icon icon = ShellImageList.GetIcon(e.Node.ImageIndex, true);
if (icon != null)
{
currentDirInfo.Image = icon.ToBitmap();
this.Icon = icon;
}
else
{
currentDirInfo.Image = null;
this.Icon = null;
}
currentDirInfo.Text = e.Node.Text;
this.Text = e.Node.Text;
}
public ExplorerTreeView()
: base()
{
sorter = new ExplorerTreeSorter();
imageList = ShellImageList.Instance;
TreeViewNodeSorter = sorter;
LoadRoot();
SetStyle(ControlStyles.AllPaintingInWmPaint, true);
SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
HotTracking = true;
HideSelection = false;
ShowLines = false;
ShowNodeToolTips = true;
HandleCreated += new EventHandler(ExplorerTreeView_HandleCreated);
HandleDestroyed += new EventHandler(ExplorerTreeView_HandleDestroyed);
VisibleChanged += new EventHandler(ExplorerTreeView_VisibleChanged);
BeforeExpand += new TreeViewCancelEventHandler(ExplorerTreeView_BeforeExpand);
BeforeCollapse += new TreeViewCancelEventHandler(ExplorerTreeView_BeforeCollapse);
}
private void AddPlace(FileDialogPlaceBase place)
{
m_places.Add(place);
((CurrencyManager)placesListBox.BindingContext[m_places]).Refresh();
bool multipleLines;
ToolStripButton placeButton = new ToolStripButton(FileDialog.InsertLineBreaks(place.Text, out multipleLines));
placeButton.Image = ShellImageList.GetImage(place.PIDL);
placeButton.ImageAlign = ContentAlignment.BottomCenter;
placeButton.Margin = new Padding(1, 0, 0, 0);
placeButton.Padding = new Padding(0, multipleLines ? 3 : 8, 0, multipleLines ? 0 : 8);
placeButton.Tag = place;
placeButton.TextImageRelation = TextImageRelation.ImageAboveText;
placesBar.Items.Add(placeButton);
placesListBox.ClearSelected();
placesListBox.SelectedIndex = placesListBox.Items.Count - 1;
}
//***********************************************************************************************
public void LoadNode(TreeNode node, bool init)
{
if ((node == desktop || node == computer) && init == false)
{
return;
}
Cursor.Current = Cursors.WaitCursor;
if (init == false)
{
node.Nodes.Clear();
}
DirectoryInfo nodeDirInfo = new DirectoryInfo(node.Tag.ToString());
foreach (DirectoryInfo dir in nodeDirInfo.GetDirectories())
{
if ((dir.Attributes & FileAttributes.Hidden) != 0)
{
continue;
}
TreeNode child = new TreeNode(dir.Name);
child.ImageIndex = child.SelectedImageIndex = ShellImageList.GetFileImageIndex(dir.FullName, dir.Attributes);
child.Tag = dir.FullName;
node.Nodes.Add(child);
try
{
DirectoryInfo[] check = dir.GetDirectories();
if (check.Length > 0)
{
TreeNode dummy = new TreeNode(string.Empty);
child.Nodes.Add(dummy);
}
}
catch { }
}
Cursor.Current = Cursors.Default;
}
//*************************************************************************************************************
public void InsertOnQueue(QueueItem queue)
{
if (queue.SourcePath == "." ||
queue.SourcePath == "..")
{
return;
}
queue.TransferID = Guid.NewGuid().ToString();
Image image = ShellImageList.GetIcon(queue.ImageIndex, true).ToBitmap();
ListViewItem listitem = InsertItem();
SetSubItemImage(listitem, 0, "In queue", Resources.bullet_arrow_up);
SetSubItemImage(listitem, 1, (queue.Download) ? queue.DestinationPath : queue.SourcePath, image);
SetSubItemImage(listitem, 2, string.Empty, (queue.Download) ? Resources.download : Resources.upload);
SetSubItemImage(listitem, 3, (queue.Download) ? queue.SourcePath : queue.DestinationPath, image);
SetSubItemText(listitem, 4, XwMaxLib.IO.Drive.GetFileSize(queue.Size));
listitem.Tag = queue;
listitem.Name = queue.TransferID;
form.TotalQueueText.Text = string.Format("{0} Items in queue", Items.Count);
}
//********************************************************************************************
private void OnLoad(object sender, EventArgs e)
{
ShellImageList.SetSmallImageList(LocalList);
ShellImageList.SetSmallImageList(RemoteList);
/*
* Don't remember why i did this
* try
* {
* IPAddress[] addresses = Dns.GetHostAddresses(this.server.Host);
* server.Host = addresses[0].ToString();
* }
* catch { }
*/
LocalList.Init(this);
RemoteList.Init(this, remoteIO);
QueueList.Init(this, remoteIO);
localPinTip.SetToolTip(LocalPin, "");
remotePinTip.SetToolTip(RemotePin, "");
linkTip.SetToolTip(LinkPath, "");
}
public BrowserComboItem(ShellItem shellItem, int indent)
{
this.shellItem = shellItem;
this.indent = indent;
this.image = ShellImageList.GetIcon(shellItem.ImageIndex, true);
}
/// <summary>
/// Once the handle is created we can assign the image list to the TreeView
/// </summary>
void BrowserTreeView_HandleCreated(object sender, EventArgs e)
{
ShellImageList.SetSmallImageList(this);
}
//********************************************************************************************
public void RealLoadList(string path, bool skipCheckLink)
{
BeginUpdate();
Items.Clear();
if (skipCheckLink)
{
form.SkipCheckLink = true;
}
if (path == string.Empty && form.LocalTree.SelectedNode != null) //my computer
{
foreach (TreeNode n in form.LocalTree.SelectedNode.Nodes)
{
ListViewItem i = Items.Add(n.Text, n.ImageIndex);
i.Tag = new DiskItem(true, false, n.Tag.ToString(), "");
}
}
else
{
try
{
if (path.Contains("\\\\") && !path.Replace("\\\\", "").Contains("\\"))
{
try
{
//New instance of the management path so we can use its properties
ManagementPath mpath = new ManagementPath();
//Set the Servername
mpath.Server = path.Replace("\\\\", "");
//Set the WMI namespace
mpath.NamespacePath = @"root\cimv2";
//Here we are using the default connections but we can also use different.
//Username and password if we need to.
ConnectionOptions oConn = new ConnectionOptions();
//Set the Scope ...Computername and WMI namespace
ManagementScope scope = new ManagementScope(path, oConn);
//Set the WMI Class
mpath.RelativePath = "Win32_Share";
//Set shares to null
ManagementClass Shares = null;
//Here we are connecting using the Servername and WMI Namespace/Class
using (Shares = new ManagementClass(scope, mpath, null))
{
//Return a collection of Shares here
ManagementObjectCollection moc = Shares.GetInstances();
//Go thru each share and display its name property in the list box.
foreach (ManagementObject mo in moc)
{
string share = mo["Name"].ToString();
ListViewItem item = new ListViewItem(share, 0);
item.Tag = new DiskItem(true, false, Path.Combine(path, share), share);
item.ImageIndex = ShellImageList.GetSpecialFolderImageIndex((ShellAPI.CSIDL) 49);
Items.Add(item);
}
}
}
catch (Exception) //catch any exceptions we might have .
{
MessageBox.Show("Unable to return sharenames . Please make share Servername is correct.");
}
}
else
{
DirectoryInfo nodeDirInfo = new DirectoryInfo(path);
ListViewItem.ListViewSubItem[] subItems;
ListViewItem item = null;
DirectoryInfo[] dirs = nodeDirInfo.GetDirectories();
ListViewItem item1 = Items.Add(".", ShellImageList.GetFileImageIndex(".", FileAttributes.Directory));
item1.Tag = new DiskItem(true, false, ".", ".");
item1.BackColor = Color.FromArgb(240, 240, 240);
ListViewItem item2 = Items.Add("..", ShellImageList.GetFileImageIndex("Folder", FileAttributes.Directory));
item2.Tag = new DiskItem(true, false, "..", "..");
item2.BackColor = Color.FromArgb(230, 230, 230);
foreach (DirectoryInfo dir in dirs)
{
if ((dir.Attributes & FileAttributes.Hidden) != 0)
{
continue;
}
item = new ListViewItem(dir.Name, 0);
subItems = new ListViewItem.ListViewSubItem[]
{
new ListViewItem.ListViewSubItem(item, " - - - "),
new ListViewItem.ListViewSubItem(item,
dir.LastWriteTime.ToString("yyyy-MM-dd HH:mm:ss"))
};
item.SubItems.AddRange(subItems);
item.Tag = new DiskItem(true, false, dir.FullName, dir.Name);
item.ImageIndex = ShellImageList.GetFileImageIndex(dir.FullName, dir.Attributes);
Items.Add(item);
}
foreach (FileInfo file in nodeDirInfo.GetFiles())
{
if ((file.Attributes & FileAttributes.Hidden) != 0)
{
continue;
}
item = new ListViewItem(file.Name, 1);
subItems = new ListViewItem.ListViewSubItem[]
{
new ListViewItem.ListViewSubItem(item, String.Format("{0:0,0}", file.Length)),
new ListViewItem.ListViewSubItem(item,
file.LastWriteTime.ToString("yyyy-MM-dd HH:mm:ss"))
};
item.SubItems.AddRange(subItems);
item.Tag = new DiskItem(false, false, file.FullName, file.Name, file.Length);
//item.ImageIndex = ShellImageList.GetFileImageIndex(file.FullName, file.Attributes);
item.ImageIndex = ShellImageList.GetFileImageIndex(file.FullName, file.Attributes);
Items.Add(item);
}
if (!string.IsNullOrEmpty(path))
{
fileSystemWatcher.Path = path;
fileSystemWatcher.EnableRaisingEvents = true;
}
else
{
fileSystemWatcher.EnableRaisingEvents = false;
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Path", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
EndUpdate();
form.statusLocalCount.Text = String.Format("{0} Items", (Items.Count > 2)?Items.Count - 2:0);
CurrentDirectory = path;
form.LocalPath.Text = path;
CheckPin();
}
//***********************************************************************************************
public XwShellTree()
{
ShellImageList.SetSmallImageList(this);
BeforeExpand += new TreeViewCancelEventHandler(this_BeforeExpand);
AfterSelect += new TreeViewEventHandler(this_AfterSelect);
}
//*************************************************************************************************************
public async Task ProcessQueue()
{
while (Items.Count > 0)
{
Update();
form.TotalQueueText.Text = string.Format("{0} Items in queue", Items.Count);
QueueItem item = new QueueItem();
bool refreshLists = true;
bool alldone = true;
foreach (ListViewItem listitem in Items)
{
if (((QueueItem)listitem.Tag).Status == QueueStatus.Queue)
{
SetSubItemImage(listitem, 0, "Processing...", Resources.play);
item = (QueueItem)listitem.Tag;
listitem.EnsureVisible();
refreshLists = false;
alldone = false;
break;
}
}
if (alldone)
{
QueueRunning = false;
return;
}
if (refreshLists)
{
QueueRunning = false;
RefreshLists();
}
if (item.TransferID != null)
{
try
{
if (item.Download) //Download
{
if (item.SourceIsdir) //Create Directory
{
Directory.CreateDirectory(item.DestinationPath);
DeleteByKey(item.TransferID);
}
else //Get File
{
XwFileAction action = XwFileAction.Overwrite;
if (File.Exists(item.DestinationPath))
{
if (DoToAllFiles == XwFileAction.Ask)
{
Exists exists = new Exists();
exists.SourceFileName.Text = item.SourcePath;
exists.DestinationFileName.Text = item.DestinationPath;
exists.SourceIcon.Image = ShellImageList.GetIcon(item.ImageIndex, false).ToBitmap();
exists.DestinationIcon.Image = ShellImageList.GetIcon(item.ImageIndex, false).ToBitmap();
exists.SourceFileSize.Text = string.Format("{0:#,#}", item.Size);
FileInfo fi = new FileInfo(item.DestinationPath);
exists.DestinationFileSize.Text = string.Format("{0:#,#}", fi.Length);
exists.DestinationFileDate.Text = File.GetLastWriteTime(item.DestinationPath).ToStringUI();
if (exists.ShowDialog(this) == DialogResult.Cancel)
{
DeleteAll();
return;
}
else
{
if (exists.DoToAllFiles != XwFileAction.Ask)
{
DoToAllFiles = exists.DoToAllFiles;
action = exists.DoToAllFiles;
}
else
{
action = exists.DoToFile;
}
}
}
else
{
action = DoToAllFiles;
}
}
if (action == XwFileAction.Skip)
{
DeleteByKey(item.TransferID);
}
else
{
int index = Items.IndexOfKey(item.TransferID);
if (index != -1)
{
item.Transferred = 0;
item.Status = QueueStatus.Progress;
Items.IndexOfKey(item.TransferID);
Items[index].Tag = item;
}
var result = await remoteIO.DownloadFile(item.DestinationPath, item.SourcePath,
item.TransferID, action == XwFileAction.Resume, item.CancelTokenSource.Token);
if (result.Success)
{
DeleteByKey(item.TransferID);
form.TotalQueueText.Text = string.Format("{0} Items in queue", Items.Count);
}
else
{
form.Log(result.Message, Color.Red);
int idx = Items.IndexOfKey(item.TransferID);
if (idx >= 0)
{
ListViewItem litem = Items[index];
QueueItem queue = (QueueItem)litem.Tag;
queue.Status = QueueStatus.Error;
litem.Tag = queue;
litem.ToolTipText = result.Message;
SetSubItemImage(litem, 0, "Error", Resources.error);
}
}
}
}
}
else //Upload
{
if (item.SourceIsdir) // Create Directory
{
if (!SkipExistsValidation.Contains(item.DestinationPath))
{
if (!await remoteIO.Exists(item.DestinationPath))
{
var result = await remoteIO.CreateDirectory(item.DestinationPath);
if (!result.Success)
{
form.Log(result.Message, Color.Red);
}
SkipExistsValidation.Add(item.DestinationPath);
}
}
DeleteByKey(item.TransferID);
}
else //Put File
{
XwFileAction action = XwFileAction.Overwrite;
string dir = item.DestinationPath.Substring(0, item.DestinationPath.LastIndexOf('/'));
if (dir == "")
{
dir = "/";
}
if (await remoteIO.Exists(item.DestinationPath))
{
if (DoToAllFiles == XwFileAction.Ask)
{
Exists exists = new Exists();
exists.SourceFileName.Text = item.SourcePath;
exists.DestinationFileName.Text = item.DestinationPath;
exists.SourceIcon.Image = ShellImageList.GetIcon(item.ImageIndex, false).ToBitmap();
exists.DestinationIcon.Image = ShellImageList.GetIcon(item.ImageIndex, false).ToBitmap();
exists.SourceFileSize.Text = string.Format("{0:#,#}", item.Size);
var result = await remoteIO.GetFileSize(item.DestinationPath);
if (!result.Success)
{
form.Log(result.Message, Color.Red);
}
exists.DestinationFileSize.Text = string.Format("{0:#,#}", result.Size);
exists.SourceFileDate.Text = File.GetLastWriteTime(item.SourcePath).ToStringUI();
result = await remoteIO.GetDateModified(item.DestinationPath);
if (!result.Success)
{
form.Log(result.Message, Color.Red);
}
exists.DestinationFileDate.Text = result.Modified.ToStringUI();
if (exists.ShowDialog(this) == DialogResult.Cancel)
{
DeleteAll();
QueueRunning = false;
DoToAllFiles = XwFileAction.Ask;
RefreshLists();
return;
}
else
{
if (exists.DoToAllFiles != XwFileAction.Ask)
{
DoToAllFiles = exists.DoToAllFiles;
action = exists.DoToAllFiles;
}
else
{
action = exists.DoToFile;
}
}
}
else
{
action = DoToAllFiles;
}
}
if (action == XwFileAction.Skip)
{
DeleteByKey(item.TransferID);
}
else
{
int index = Items.IndexOfKey(item.TransferID);
if (index != -1)
{
item.Transferred = 0;
item.Status = QueueStatus.Progress;
Items.IndexOfKey(item.TransferID);
Items[index].Tag = item;
}
var result = await remoteIO.UploadFile(item.SourcePath, item.DestinationPath,
item.TransferID, action == XwFileAction.Resume, item.CancelTokenSource.Token);
if (result.Success)
{
DeleteByKey(item.TransferID);
form.TotalQueueText.Text = string.Format("{0} Items in queue", Items.Count);
}
else
{
form.Log(result.Message, Color.Red);
int idx = Items.IndexOfKey(item.TransferID);
if (idx >= 0)
{
ListViewItem litem = Items[index];
QueueItem queue = (QueueItem)litem.Tag;
queue.Status = QueueStatus.Error;
litem.Tag = queue;
litem.ToolTipText = result.Message;
SetSubItemImage(litem, 0, "Error", Resources.error);
}
}
}
}
}
}
catch (Exception ex)
{
if (ex.Message.Contains("InnerException"))
{
form.Log(ex.InnerException.Message, Color.Red);
}
else
{
form.Log(ex.Message, Color.Red);
}
int index = Items.IndexOfKey(item.TransferID);
if (index != -1)
{
QueueItem qi = (QueueItem)Items[index].Tag;
qi.Status = QueueStatus.Error;
Items[index].Tag = qi;
SetSubItemImage(Items[index], 0, "Error", Resources.exclamation);
Items[index].ToolTipText = ex.Message;
}
}
}
}
SkipExistsValidation.Clear();
QueueRunning = false;
DoToAllFiles = XwFileAction.Ask;
RefreshLists();
}
/// <summary>
/// Once the handle is created we can assign the image lists to the ListView
/// </summary>
void FileBrowserListView_HandleCreated(object sender, EventArgs e)
{
ShellImageList.SetSmallImageList(this);
ShellImageList.SetLargeImageList(this);
}
//*************************************************************************************************************
public async Task LoadList(string path)
{
Cursor.Current = Cursors.WaitCursor;
BackColor = Color.FromArgb(240, 240, 240);
try
{
if (!remoteIO.IsConnected)
{
await remoteIO.Reconnect();
}
if (path == ".")
{
path = "/";
}
if (path == "..")
{
path = CurrentDirectory.GetUnixParentPath();
}
var result = await remoteIO.ListDirectory(path);
if (result.Success)
{
form.Log(result.Message);
BeginUpdate();
Items.Clear();
ListViewItem item1 = Items.Add(".", ShellImageList.GetFileImageIndex("c:", FileAttributes.Device));
item1.Tag = new DiskItem(true, false, ".", "");
item1.BackColor = Color.FromArgb(240, 240, 240);
ListViewItem item2 = Items.Add("..", ShellImageList.GetFileImageIndex("Folder", FileAttributes.Directory));
item2.Tag = new DiskItem(true, false, "..", "");
item2.BackColor = Color.FromArgb(230, 230, 230);
ListViewItem.ListViewSubItem[] subItems;
ListViewItem item = null;
foreach (XwRemoteIOItem remoteItem in result.Items)
{
if (!remoteItem.IsDirectory)
{
continue;
}
item = new ListViewItem(remoteItem.Name, 0);
subItems = new ListViewItem.ListViewSubItem[]
{
new ListViewItem.ListViewSubItem(item, " - - - "),
new ListViewItem.ListViewSubItem(item,
(remoteItem.Modified == DateTime.MinValue)
? "- - -"
: remoteItem.Modified.ToString("yyyy-MM-dd HH:mm:ss"))
};
item.SubItems.AddRange(subItems);
item.Tag = new DiskItem(remoteItem.IsDirectory,
remoteItem.IsSymlink, remoteItem.FullName, remoteItem.Name);
item.ImageIndex = ShellImageList.GetFileImageIndex(remoteItem.Name,
FileAttributes.Directory | ((remoteItem.IsSymlink) ? FileAttributes.Compressed : 0));
Items.Add(item);
}
foreach (XwRemoteIOItem remoteItem in result.Items)
{
if (remoteItem.IsDirectory)
{
continue;
}
item = new ListViewItem(remoteItem.Name, 0);
subItems = new ListViewItem.ListViewSubItem[]
{
new ListViewItem.ListViewSubItem(item, string.Format("{0:0,0}", remoteItem.Size)),
new ListViewItem.ListViewSubItem(item,
(remoteItem.Modified == DateTime.MinValue)
? "- - -"
: remoteItem.Modified.ToString("yyyy-MM-dd HH:mm:ss"))
};
item.SubItems.AddRange(subItems);
item.Tag = new DiskItem(remoteItem.IsDirectory, remoteItem.IsSymlink,
remoteItem.FullName, remoteItem.Name, remoteItem.Size);
item.ImageIndex = ShellImageList.GetFileImageIndex(remoteItem.Name,
FileAttributes.Normal | ((remoteItem.IsSymlink) ? FileAttributes.Compressed : 0));
Items.Add(item);
}
EndUpdate();
form.statusRemoteCount.Text = string.Format("{0} Items", (Items.Count > 2) ? Items.Count - 2 : 0);
CurrentDirectory = path;
form.RemotePath.Text = CurrentDirectory;
CheckPin();
}
else
{
if (form.splitContainerStatus.Visible) //connecting
{
form.Log($"An error occurred while retrieving the directory list.\nReason: {result.Message}",
Color.Red);
}
else
{
form.loadingCircle1.Active = true;
form.loadingCircle1.Visible = false;
form.SetStatusText(result.Message);
}
}
}
catch (Exception ex)
{
form.Log(ex.Message, Color.Red);
Enabled = true;
}
Cursor.Current = Cursors.Default;
BackColor = SystemColors.Window;
}
