private void AfterDelete(IVirtualItem item)
{
if (this.OnAfterDelete != null)
{
this.OnAfterDelete(this, new VirtualItemEventArgs(item));
}
}
protected void Changed(WatcherChangeTypes changeType, IVirtualItem item)
{
if (this.OnChanged != null)
{
this.OnChanged(this, new VirtualItemChangedEventArgs(changeType, item));
}
}
public static Image GetThumbnail(IVirtualItem item, Size thumbSize)
{
ExtensiblePropertyProvider provider = item as ExtensiblePropertyProvider;
if (provider != null)
{
foreach (IGetVirtualProperty property in provider.GetProviders(0x15))
{
Image image;
IGetThumbnail thumbnail = property as IGetThumbnail;
if (thumbnail != null)
{
image = thumbnail.GetThumbnail(thumbSize);
}
else
{
image = property[0x15] as Image;
}
if (image != null)
{
return image;
}
}
}
return (item[0x15] as Image);
}
public override bool IsChild(IVirtualItem item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
return item.FullName.StartsWith(PathHelper.IncludeTrailingDirectorySeparator(base.Folder.FullName), StringComparison.OrdinalIgnoreCase);
}
private ChangeItemAction DeleteError(IVirtualItem item, AvailableItemActions available, Exception error)
{
ChangeItemAction none = ChangeItemAction.None;
if (this.OnDeleteError != null)
{
ChangeItemErrorEventArgs e = new ChangeItemErrorEventArgs(item, available, error);
this.OnDeleteError(this, e);
none = e.Action;
}
return none;
}
private DialogResult BeforeDelete(IVirtualItem item)
{
DialogResult yes = DialogResult.Yes;
if (this.OnBeforeDelete != null)
{
BeforeDeleteItemEventArgs e = new BeforeDeleteItemEventArgs(item);
this.OnBeforeDelete(this, e);
yes = e.Action;
}
return yes;
}
public OverwriteDialogResult GetOverwrite(IVirtualItem source, IVirtualItem dest)
{
if (this.CompareOperator == Compare.Always)
{
return this.OverwriteResult;
}
if (((this.CompareOperator != Compare.Never) && (source != null)) && (dest != null))
{
int num;
if (!(source.IsPropertyAvailable(this.PropertyId) && dest.IsPropertyAvailable(this.PropertyId)))
{
return OverwriteDialogResult.None;
}
switch (this.PropertyId)
{
case 7:
case 8:
case 9:
{
DateTime time = (DateTime) source[8];
DateTime time2 = (DateTime) dest[8];
TimeSpan span = (TimeSpan) (time2 - time);
num = Math.Sign((long) (span.Ticks / 0x989680L));
break;
}
default:
num = Comparer.DefaultInvariant.Compare(dest[this.PropertyId], source[this.PropertyId]);
break;
}
switch (this.CompareOperator)
{
case Compare.Equal:
return ((num == 0) ? this.OverwriteResult : OverwriteDialogResult.None);
case Compare.Greater:
return ((num > 0) ? this.OverwriteResult : OverwriteDialogResult.None);
case Compare.GreaterEqual:
return ((num >= 0) ? this.OverwriteResult : OverwriteDialogResult.None);
case Compare.Less:
return ((num < 0) ? this.OverwriteResult : OverwriteDialogResult.None);
case Compare.LessEqual:
return ((num <= 0) ? this.OverwriteResult : OverwriteDialogResult.None);
case Compare.NotEqual:
return ((num != 0) ? this.OverwriteResult : OverwriteDialogResult.None);
}
}
return OverwriteDialogResult.None;
}
public CopyItemEventArgs(IVirtualItem source, IVirtualItem dest)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (dest == null)
{
throw new ArgumentNullException("dest");
}
this.Source = source;
this.Dest = dest;
}
public static Image GetIcon(IVirtualItem item, Size size, IconStyle style)
{
IVirtualItemUI mui = item as IVirtualItemUI;
if (mui != null)
{
if ((mui.Highlighter != null) && (mui.Highlighter.IconType == HighlighterIconType.HighlighterIcon))
{
return mui.Highlighter.GetIcon(size);
}
return mui.GetIcon(size, style);
}
return null;
}
internal VirtualTreeListItem(IVirtualItem item, int index)
{
Item = item;
Index = index;
if (item is TreeListGroup)
{
ItemType = Forms.ItemType.Group;
}
else if (item is TreeListItem)
{
ItemType = Forms.ItemType.Item;
}
}
// Convert command target to selected item
protected IVirtualItem GetTarget(object target)
{
// Target can be item itself
IVirtualItem Result = target as IVirtualItem;
if (Result != null)
{
return(Result);
}
// Or collection of items
var Collection = target as IEnumerable <IVirtualItem>;
foreach (IVirtualItem NextItem in Collection.AsEnumerable())
{
if (Result == null)
{
Result = NextItem;
}
else
{
return(null);
}
}
if (Result == null)
{
// Or panel
IPanel Panel = target as IPanel;
if (Panel != null)
{
return(Panel.FocusedItem);
}
// If none of above, then get FocusedItem of current two panel tab
ITwoPanelTab TwoPanelTab = CurrentTab as ITwoPanelTab;
if (TwoPanelTab != null)
{
Result = TwoPanelTab.CurrentPanel.FocusedItem;
if ((Result != null) && Result.Equals(TwoPanelTab.CurrentPanel.ParentFolder))
{
return(null);
}
}
}
return(Result);
}
public OverwriteDialogResult GetOverwrite(IVirtualItem source, IVirtualItem dest)
{
if ((source != null) && (dest != null))
{
if (!(source.IsPropertyAvailable(this.PropertyId) && dest.IsPropertyAvailable(this.PropertyId)))
{
return OverwriteDialogResult.None;
}
object a = source[this.PropertyId];
if ((Comparer.DefaultInvariant.Compare(a, this.Value) == 0) && (Comparer.DefaultInvariant.Compare(a, dest[this.PropertyId]) == 0))
{
return this.OverwriteResult;
}
}
return OverwriteDialogResult.None;
}
public VirtualItemDataObject(IVirtualItem item, bool move)
{
FileSystemItem item2 = item as FileSystemItem;
if (item2 != null)
{
StringCollection filePaths = new StringCollection();
filePaths.Add(item2.ComparableName);
this.SetFileDropList(filePaths);
}
else
{
this.SetData("Virtual Items", new IVirtualItem[] { item });
}
if (move)
{
this.SetData("Preferred DropEffect", true, 2);
}
}
private static Image ExtractThumbnail(IVirtualItem item, Size iconSize, bool extractThumbnail, bool extractIcon)
{
Image original = null;
if (extractThumbnail)
{
original = VirtualIcon.GetThumbnail(item, Settings.Default.TooltipMaxThumbnailSize);
if (original != null)
{
Size tooltipMaxThumbnailSize = Settings.Default.TooltipMaxThumbnailSize;
if (!(tooltipMaxThumbnailSize.IsEmpty || ((original.Width <= tooltipMaxThumbnailSize.Width) && (original.Height <= tooltipMaxThumbnailSize.Height))))
{
original = new Bitmap(original, ImageHelper.GetThumbnailSize(original.Size, tooltipMaxThumbnailSize));
}
}
}
if ((original == null) && extractIcon)
{
original = VirtualIcon.GetIcon(item, iconSize);
}
return original;
}
protected ResolveShellLink(SerializationInfo info, StreamingContext context)
{
SerializationInfoEnumerator enumerator = info.GetEnumerator();
while (enumerator.MoveNext())
{
SerializationEntry current = enumerator.Current;
string name = current.Name;
if (name != null)
{
if (!(name == "Target"))
{
if (name == "TargetPath")
{
goto Label_0074;
}
if (name == "Description")
{
goto Label_0088;
}
if (name == "Hotkey")
{
goto Label_009C;
}
}
else
{
this.FTarget = (IVirtualItem) current.Value;
}
}
continue;
Label_0074:
this.FTargetPath = (string) current.Value;
continue;
Label_0088:
this.FDescription = (string) current.Value;
continue;
Label_009C:
this.FHotkey = (Keys) current.Value;
}
}
private bool DeleteItem(IVirtualItem item, bool sendToBin)
{
ChangeItemAction action;
AvailableItemActions canRetryOrElevate = AvailableItemActions.CanRetryOrElevate;
Label_0003:;
try
{
IChangeVirtualItem item2 = item as IChangeVirtualItem;
if (item2 == null)
{
throw new ItemChangeNotSupportedException(string.Format(Resources.sErrorDeleteNonChangeableItem, item.FullName));
}
item2.Delete(sendToBin);
this.AfterDelete(item);
return true;
}
catch (UnauthorizedAccessException exception)
{
action = this.DeleteError(item, canRetryOrElevate, exception);
canRetryOrElevate &= ~AvailableItemActions.CanElevate;
}
catch (Exception exception2)
{
action = this.DeleteError(item, canRetryOrElevate, exception2);
}
switch (action)
{
case ChangeItemAction.Retry:
goto Label_0003;
case ChangeItemAction.Skip:
return false;
case ChangeItemAction.Cancel:
base.CancelAsync();
return false;
}
throw new InvalidEnumArgumentException();
}
private ToolStripLabel CreateItemLabel(IVirtualItem item)
{
ToolStripLabel label = new ToolStripLabel {
TextAlign = ContentAlignment.MiddleLeft,
Padding = new Padding(0, 3, 0, 3),
Tag = item
};
label.MouseUp += new MouseEventHandler(VirtualItemToolStripEvents.MouseUp);
label.MouseLeave += new EventHandler(VirtualItemToolStripEvents.MouseLeave);
Color foreColor = VirtualItemHelper.GetForeColor(item, Color.Empty);
if (!foreColor.IsEmpty)
{
label.ForeColor = foreColor;
label.Paint += new PaintEventHandler(VirtualItemToolStripEvents.PaintForeColor);
}
if (Settings.Default.IsShowIcons)
{
label.ImageAlign = ContentAlignment.MiddleLeft;
label.Image = VirtualIcon.GetIcon(item, ImageHelper.DefaultSmallIconSize);
}
return label;
}
public void Add(IVirtualItem item)
{
ToolStripLabel label = this.CreateItemLabel(item);
if (this.Items.Count == 0)
{
base.Renderer = new ItemRenderer();
base.LayoutStyle = ToolStripLayoutStyle.Table;
TableLayoutSettings layoutSettings = (TableLayoutSettings) base.LayoutSettings;
layoutSettings.ColumnCount = 1;
layoutSettings.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100f));
label.Text = PathHelper.ExcludeTrailingDirectorySeparator(item.FullName);
label.AutoSize = false;
label.Dock = DockStyle.Fill;
if (Settings.Default.ShowItemToolTips)
{
label.MouseHover += new EventHandler(this.tslItem_MouseHover);
}
}
else
{
if (this.Items.Count == 1)
{
ToolStripItem item2 = this.Items[0];
item2.AutoSize = true;
item2.Dock = DockStyle.None;
}
base.LayoutStyle = ToolStripLayoutStyle.HorizontalStackWithOverflow;
if (Settings.Default.ShowItemToolTips)
{
label.MouseHover += new EventHandler(this.tslItem_MouseHover);
}
}
this.Items.Add(label);
if (this.components != null)
{
this.components.Add(label);
}
}
public bool Execute(IWin32Window owner, IVirtualItem item)
{
this.tsItem.Add(item);
this.CreateLink = item as ICreateVirtualLink;
if (this.CreateLink == null)
{
this.cmbDestFolder.Enabled = false;
this.btnTree.Enabled = false;
}
else
{
this.cmbDestFolder.Text = Path.Combine(this.cmbDestFolder.Text, this.CreateLink.GetPrefferedLinkName(Nomad.FileSystem.Virtual.LinkType.Default));
}
HistorySettings.PopulateComboBox(this.cmbDestFolder, HistorySettings.Default.MakeLinkName);
if (base.ShowDialog(owner) == DialogResult.OK)
{
HistorySettings.Default.AddStringToMakeLinkName(this.cmbDestFolder.Text.Trim());
return true;
}
return false;
}
public bool Execute(object source, object target)
{
IVirtualItem Item = GetTarget(target);
return((Item != null) && AppendTextToCmdLine(Item.Name));
}
private ChangeItemAction DeleteItemError(IVirtualItem item, AvailableItemActions availableActions, Exception error)
{
return this.ItemError(this.OnDeleteItemError, item, availableActions, error);
}
private bool DeleteItem(IVirtualItem item)
{
ChangeItemAction action;
AvailableItemActions canRetryOrElevate = AvailableItemActions.CanRetryOrElevate;
Label_0003:;
try
{
IChangeVirtualItem item2 = item as IChangeVirtualItem;
if (item2 == null)
{
throw new ItemChangeNotSupportedException(string.Format(Resources.sErrorDeleteNonChangeableItem, item.FullName));
}
item2.Delete(false);
return true;
}
catch (UnauthorizedAccessException exception)
{
action = this.DeleteItemError(item, canRetryOrElevate, exception);
canRetryOrElevate &= ~AvailableItemActions.CanElevate;
}
catch (IOException exception2)
{
if (Marshal.GetHRForException(exception2) == HRESULT.HRESULT_FROM_WIN32(0x91))
{
return false;
}
action = this.DeleteItemError(item, canRetryOrElevate, exception2);
}
catch (Exception exception3)
{
action = this.DeleteItemError(item, canRetryOrElevate, exception3);
}
switch (action)
{
case ChangeItemAction.Retry:
goto Label_0003;
case ChangeItemAction.Skip:
return false;
case ChangeItemAction.Cancel:
base.CancelAsync();
return false;
}
throw new InvalidEnumArgumentException();
}
private string CreateNewName(IVirtualItem item)
{
string name;
if (((this.FRenameFilter != null) && (this.FRenameContent != null)) && this.FRenameContent.ContainsKey(item))
{
name = this.FRenameFilter.CreateNewName(item.Name);
}
else
{
name = item.Name;
}
return PathHelper.NormalizeInvalidFileName(name);
}
private static ProcessedSize CreateFileProcessed(Stream sourceStream, IVirtualItem sourceItem)
{
ProcessedSize size = new ProcessedSize(0L, 0L);
if (sourceStream.CanSeek)
{
size.SetProcessedSize(sourceStream.Position);
size.SetTotalSize(sourceStream.Length);
return size;
}
object obj2 = sourceItem[3];
if (obj2 != null)
{
size.SetTotalSize((long) obj2);
}
return size;
}
private bool CopySystem(IVirtualItem sourceFile, IVirtualItem destFile)
{
long processed;
object obj2;
lock ((obj2 = this.FSnapshotLock))
{
processed = this.FTotalProcessed.Processed;
this.FCopyMode = CopyMode.System;
}
bool pbCancel = false;
CopyProgressRoutine lpProgressRoutine = new CopyProgressRoutine(this.SystemCopyProgress);
if (!System.IO.File.Exists(destFile.FullName))
{
using (System.IO.File.Create(destFile.FullName))
{
LocalFileSystemCreator.RaiseFileChangedEvent(WatcherChangeTypes.Created, destFile.FullName);
}
}
IntPtr ptr = Marshal.AllocHGlobal(8);
try
{
Marshal.WriteInt64(ptr, 0L);
if (!Windows.CopyFileEx(sourceFile.FullName, destFile.FullName, lpProgressRoutine, ptr, ref pbCancel, (COPY_FILE) 0))
{
lock ((obj2 = this.FSnapshotLock))
{
this.FTotalProcessed.SetProcessedSize(processed);
}
int error = Marshal.GetLastWin32Error();
switch (error)
{
case 5:
{
Win32Exception inner = new Win32Exception(error);
throw new UnauthorizedAccessException(inner.Message, inner);
}
case 0x57:
{
IVirtualFolder parent = destFile.Parent;
if (parent != null)
{
throw new WarningException(string.Format(Resources.sNotEnoughSpaceInDest, parent.FullName, sourceFile.FullName));
}
throw new Win32IOException(error);
}
case 0x4d3:
return false;
}
throw new Win32IOException(error);
}
}
finally
{
Marshal.FreeHGlobal(ptr);
}
LocalFileSystemCreator.RaiseFileChangedEvent(WatcherChangeTypes.Changed, destFile.FullName);
return true;
}
private CopyItemAction CopyStreamAsync(Stream sourceStream, Stream destStream, IVirtualItem sourceItem, IVirtualItem destItem)
{
object obj2;
lock ((obj2 = this.FSnapshotLock))
{
this.FCopyMode = CopyMode.Async;
}
if (this.Buffer2 == null)
{
this.Buffer2 = new byte[this.Buffer1.Length];
}
byte[] buffer = this.Buffer1;
byte[] buffer2 = this.Buffer2;
int count = 0;
ProcessedSize processed = CreateFileProcessed(sourceStream, sourceItem);
if (!((processed.Total <= buffer.Length) || this.RaiseFileProgress(ref processed)))
{
return CopyItemAction.SkipUndoDest;
}
IAsyncResult asyncResult = sourceStream.BeginRead(buffer, 0, buffer.Length, null, null);
do
{
count = sourceStream.EndRead(asyncResult);
if (base.CheckCancellationPending())
{
return CopyItemAction.SkipUndoDest;
}
IAsyncResult result2 = destStream.BeginWrite(buffer, 0, count, null, null);
byte[] buffer3 = buffer;
if (count > 0)
{
asyncResult = sourceStream.BeginRead(buffer2, 0, buffer2.Length, null, null);
buffer2 = Interlocked.Exchange<byte[]>(ref buffer, buffer2);
}
try
{
destStream.EndWrite(result2);
}
catch (IOException exception)
{
CopyItemAction action = this.HandleCopyIOException(destItem, sourceItem, destItem, destStream, buffer3, count, exception);
if (action != CopyItemAction.Next)
{
return action;
}
}
lock ((obj2 = this.FSnapshotLock))
{
this.FTotalProcessed.AddProcessedSize((long) count);
}
this.RaiseProgress();
processed.AddProcessedSize((long) count);
if (!this.RaiseFileProgress(ref processed))
{
return CopyItemAction.SkipUndoDest;
}
}
while (count > 0);
return CopyItemAction.Next;
}
private CopyItemAction CopyStream(Stream sourceStream, Stream destStream, IVirtualItem sourceItem, IVirtualItem destItem)
{
object obj2;
lock ((obj2 = this.FSnapshotLock))
{
this.FCopyMode = CopyMode.Sync;
}
int count = 0;
ProcessedSize processed = CreateFileProcessed(sourceStream, sourceItem);
if (!((processed.Total <= this.Buffer1.Length) || this.RaiseFileProgress(ref processed)))
{
return CopyItemAction.SkipUndoDest;
}
do
{
if (base.CheckCancellationPending())
{
return CopyItemAction.SkipUndoDest;
}
count = sourceStream.Read(this.Buffer1, 0, this.Buffer1.Length);
try
{
destStream.Write(this.Buffer1, 0, count);
}
catch (IOException exception)
{
CopyItemAction action = this.HandleCopyIOException(destItem, sourceItem, destItem, destStream, this.Buffer1, count, exception);
if (action != CopyItemAction.Next)
{
return action;
}
}
lock ((obj2 = this.FSnapshotLock))
{
this.FTotalProcessed.AddProcessedSize((long) count);
}
this.RaiseProgress();
processed.AddProcessedSize((long) count);
if (!this.RaiseFileProgress(ref processed))
{
return CopyItemAction.SkipUndoDest;
}
}
while (count > 0);
return CopyItemAction.Next;
}
private CopyItemAction CopyItemError(IVirtualItem item, IVirtualItem source, IVirtualItem dest, AvailableItemActions available, Exception error)
{
ChangeItemAction none = ChangeItemAction.None;
bool undoDest = true;
if (this.OnCopyItemError != null)
{
CopyItemErrorEventArgs e = new CopyItemErrorEventArgs(item, source, dest, available, error);
this.OnCopyItemError(this, e);
none = e.Action;
undoDest = e.UndoDest;
}
switch (none)
{
case ChangeItemAction.Retry:
return CopyItemAction.Next;
case ChangeItemAction.Skip:
return (undoDest ? CopyItemAction.SkipUndoDest : CopyItemAction.Skip);
case ChangeItemAction.Cancel:
base.CancelAsync();
return (undoDest ? CopyItemAction.SkipUndoDest : CopyItemAction.Skip);
}
throw error;
}
private void CopyItem(IVirtualItem sourceItem, IVirtualFolder destFolder, IGetStream getSourceStream, List<IVirtualItem> skippedItems)
{
Exception exception;
object obj2;
CopyItemAction next = CopyItemAction.Next;
IChangeVirtualFile DestFile = null;
try
{
if (!(sourceItem is IChangeVirtualFile))
{
throw new ItemChangeNotSupportedException();
}
ICreateVirtualFile file = destFolder as ICreateVirtualFile;
if (file == null)
{
throw new WarningException(string.Format(Resources.sCannotCopyToBasicFolder, destFolder.FullName));
}
DestFile = file.CreateFile(this.CreateNewName(sourceItem));
OverwriteDialogResult Overwrite = OverwriteDialogResult.Overwrite;
do
{
string str;
Overwrite = this.BeforeCopy((IVirtualFile) sourceItem, DestFile, out str);
switch (Overwrite)
{
case OverwriteDialogResult.Rename:
DestFile = file.CreateFile(str);
break;
case OverwriteDialogResult.Skip:
skippedItems.Add(sourceItem);
lock ((obj2 = this.FSnapshotLock))
{
this.FSkippedCount++;
if (sourceItem.IsPropertyAvailable(3))
{
this.FTotalProcessed.AddProcessedSize(Convert.ToInt64(sourceItem[3]));
}
}
return;
case OverwriteDialogResult.Abort:
base.CancelAsync();
return;
}
}
while (((Overwrite != OverwriteDialogResult.Append) && (Overwrite != OverwriteDialogResult.Resume)) && (Overwrite != OverwriteDialogResult.Overwrite));
if (sourceItem.Equals(DestFile))
{
throw new WarningException(string.Format(Resources.sCannotCopyFileToItself, sourceItem.FullName));
}
IChangeVirtualFile CurrentFile = (IChangeVirtualFile) sourceItem;
IChangeVirtualItem item = sourceItem as IChangeVirtualItem;
IChangeVirtualItem destItem = DestFile as IChangeVirtualItem;
if ((this.CheckOption(CopyWorkerOptions.DeleteSource) && (item != null)) && item.CanMoveTo(destFolder))
{
if (this.MoveItem(item, destFolder) == null)
{
next = CopyItemAction.Skip;
}
lock ((obj2 = this.FSnapshotLock))
{
this.FTotalProcessed.AddProcessedSize(Convert.ToInt64(CurrentFile[3]));
}
}
else
{
if (!(!this.CheckOption(CopyWorkerOptions.CheckFreeSpace) || this.CheckDestFreeSpace(Overwrite, CurrentFile, DestFile, destFolder)))
{
next = CopyItemAction.Skip;
}
if (next == CopyItemAction.Next)
{
long num = 0L;
FileAttributes attributes = 0;
bool flag = false;
long position = 0L;
ISetOwnerWindow window = CurrentFile as ISetOwnerWindow;
if (window != null)
{
window.Owner = this.Owner;
}
try
{
if ((destItem != null) && destItem.Exists)
{
num = Convert.ToInt64(DestFile[3]);
attributes = DestFile.Attributes;
VirtualItemHelper.ResetSystemAttributes(DestFile);
}
else
{
Overwrite = OverwriteDialogResult.Overwrite;
}
bool flag2 = (((this.CheckOption(CopyWorkerOptions.UseSystemCopy) && OS.IsWinNT) && ((Overwrite == OverwriteDialogResult.Overwrite) && (getSourceStream == null))) && (CurrentFile is CustomFileSystemFile)) && (DestFile is CustomFileSystemFile);
if (flag2)
{
try
{
if (this.CopySystem(CurrentFile, DestFile))
{
VirtualItemHelper.ResetSystemAttributes(DestFile);
}
else
{
next = CopyItemAction.Skip;
}
}
catch (UnauthorizedAccessException)
{
IElevatable elevatable = CurrentFile as IElevatable;
bool flag3 = (elevatable != null) && elevatable.CanElevate;
if (!flag3)
{
elevatable = DestFile as IElevatable;
flag3 = (elevatable != null) && elevatable.CanElevate;
}
if (!flag3)
{
throw;
}
flag2 = false;
}
}
if (!flag2)
{
bool asyncCopy = this.CheckOption(CopyWorkerOptions.AsyncCopy);
if (this.CheckOption(CopyWorkerOptions.AutoAsyncCopy))
{
IGetVirtualVolume parent = CurrentFile.Parent as IGetVirtualVolume;
IGetVirtualVolume volume2 = destFolder as IGetVirtualVolume;
asyncCopy = ((volume2 != null) && (parent != null)) && ((volume2.Location != parent.Location) || (volume2.VolumeType != parent.VolumeType));
}
Stream InStream = null;
bool DoAsyncCopy = asyncCopy;
long StartOffset = 0L;
if (Overwrite == OverwriteDialogResult.Resume)
{
StartOffset = num;
}
next = this.OpenItemStream(sourceItem, sourceItem, DestFile, delegate {
if (getSourceStream != null)
{
InStream = getSourceStream.GetStream();
if (StartOffset > 0L)
{
InStream.Seek(StartOffset, SeekOrigin.Begin);
}
}
else
{
InStream = CurrentFile.Open(FileMode.Open, FileAccess.Read, FileShare.Read, FileOptions.SequentialScan | (DoAsyncCopy ? FileOptions.Asynchronous : FileOptions.None), StartOffset);
}
});
using (InStream)
{
if ((InStream != null) && (next == CopyItemAction.Next))
{
DoAsyncCopy = DoAsyncCopy && (!InStream.CanSeek || (InStream.Length > this.Buffer1.Length));
Stream OutStream = null;
next = this.OpenItemStream(DestFile, sourceItem, DestFile, delegate {
OutStream = DestFile.Open((Overwrite == OverwriteDialogResult.Overwrite) ? FileMode.Create : FileMode.Append, FileAccess.Write, FileShare.None, FileOptions.SequentialScan | (DoAsyncCopy ? FileOptions.Asynchronous : FileOptions.None), 0L);
});
using (OutStream)
{
if ((OutStream != null) && (next == CopyItemAction.Next))
{
flag = true;
FileStream stream = InStream as FileStream;
DoAsyncCopy &= ((stream == null) || stream.IsAsync) && (InStream != Stream.Null);
FileStream stream2 = OutStream as FileStream;
DoAsyncCopy &= ((stream2 == null) || stream2.IsAsync) && (OutStream != Stream.Null);
if (DoAsyncCopy)
{
next = this.CopyStreamAsync(InStream, OutStream, CurrentFile, DestFile);
}
else
{
next = this.CopyStream(InStream, OutStream, CurrentFile, DestFile);
}
if (OutStream.CanSeek)
{
if (Overwrite == OverwriteDialogResult.Append)
{
position = OutStream.Position - num;
}
else
{
position = OutStream.Position;
}
}
}
}
}
}
if (!((next != CopyItemAction.Next) || base.CancellationPending))
{
this.CopyAlternateStreams(CurrentFile, DestFile, asyncCopy);
}
}
if ((next == CopyItemAction.Next) && !base.CancellationPending)
{
if (destItem != null)
{
next = this.SetOutFileAttributes(sourceItem, destItem, true, this.CheckOption(CopyWorkerOptions.CopyItemTime));
}
if (((this.CheckOption(CopyWorkerOptions.DeleteSource) && (next == CopyItemAction.Next)) && (item != null)) && !this.DeleteItem(CurrentFile))
{
next = CopyItemAction.Skip;
}
this.RaiseAfterCopy(sourceItem, DestFile);
}
}
catch (AbortException)
{
next = CopyItemAction.SkipUndoDest;
base.CancelAsync();
}
catch (Exception exception3)
{
exception = exception3;
next = this.CopyItemError(null, sourceItem, DestFile, flag ? AvailableItemActions.CanUndoDestination : AvailableItemActions.None, exception);
}
if ((next != CopyItemAction.Next) && CurrentFile.IsPropertyAvailable(3))
{
lock ((obj2 = this.FSnapshotLock))
{
this.FTotalProcessed.AddProcessedSize(Convert.ToInt64(CurrentFile[3]) - position);
}
}
if (flag && (next == CopyItemAction.SkipUndoDest))
{
if (Overwrite != OverwriteDialogResult.Overwrite)
{
using (Stream stream3 = DestFile.Open(FileMode.Open, FileAccess.Write, FileShare.None, FileOptions.None, 0L))
{
if (stream3.CanSeek && stream3.CanWrite)
{
stream3.SetLength(num);
}
}
if ((destItem != null) && destItem.CanSetProperty(6))
{
destItem[6] = attributes;
}
}
else if (destItem != null)
{
destItem.Delete(false);
}
}
}
}
}
catch (Exception exception4)
{
exception = exception4;
next = this.CopyItemError(null, sourceItem, DestFile, AvailableItemActions.None, exception);
}
if (next != CopyItemAction.Next)
{
skippedItems.Add(sourceItem);
lock ((obj2 = this.FSnapshotLock))
{
this.FSkippedCount++;
}
}
else
{
lock ((obj2 = this.FSnapshotLock))
{
this.FProcessedCount++;
}
}
}
private CopyItemAction CopyAlternateStreams(IVirtualItem source, IVirtualItem dest, bool asyncCopy)
{
IVirtualAlternateStreams SourceStreams = source as IVirtualAlternateStreams;
IVirtualAlternateStreams DestStreams = dest as IVirtualAlternateStreams;
if (!((((SourceStreams != null) && (DestStreams != null)) && SourceStreams.HasAlternateStreams) && DestStreams.IsSupported))
{
return CopyItemAction.Next;
}
CopyItemAction next = CopyItemAction.Next;
using (IEnumerator<string> enumerator = SourceStreams.GetStreamNames().GetEnumerator())
{
string NextStreamName;
while (enumerator.MoveNext())
{
NextStreamName = enumerator.Current;
if (next != CopyItemAction.Next)
{
return next;
}
Stream InStream = null;
bool DoAsyncCopy = asyncCopy;
next = this.OpenItemStream(source, source, dest, delegate {
InStream = SourceStreams.Open(NextStreamName, FileMode.Open, FileAccess.Read, FileShare.Read, FileOptions.SequentialScan | (DoAsyncCopy ? FileOptions.Asynchronous : FileOptions.None));
});
using (InStream)
{
if ((InStream != null) && (next == CopyItemAction.Next))
{
DoAsyncCopy = DoAsyncCopy && (!InStream.CanSeek || (InStream.Length > this.Buffer1.Length));
Stream OutStream = null;
next = this.OpenItemStream(dest, source, dest, delegate {
OutStream = DestStreams.Open(NextStreamName, FileMode.Create, FileAccess.Write, FileShare.None, FileOptions.SequentialScan | (DoAsyncCopy ? FileOptions.Asynchronous : FileOptions.None));
});
using (OutStream)
{
if ((OutStream != null) && (next == CopyItemAction.Next))
{
FileStream stream = InStream as FileStream;
DoAsyncCopy &= ((stream == null) || stream.IsAsync) && (InStream != Stream.Null);
FileStream stream2 = OutStream as FileStream;
DoAsyncCopy &= ((stream2 == null) || stream2.IsAsync) && (OutStream != Stream.Null);
if (InStream.CanSeek)
{
lock (this.FSnapshotLock)
{
this.FTotalProcessed.AddTotalSize(InStream.Length);
}
}
if (DoAsyncCopy)
{
next = this.CopyStreamAsync(InStream, OutStream, source, dest);
}
else
{
next = this.CopyStream(InStream, OutStream, source, dest);
}
}
}
}
}
}
}
return next;
}
private static void SetProperty(IVirtualItem sourceItem, IChangeVirtualItem destItem, int property)
{
if (destItem.CanSetProperty(property) && sourceItem.IsPropertyAvailable(property))
{
object obj2 = sourceItem[property];
if (obj2 != null)
{
destItem[property] = obj2;
}
}
}
private CopyItemAction SetOutFileAttributes(IVirtualItem sourceItem, IChangeVirtualItem destItem, bool setAttributes, bool setTime)
{
ChangeItemAction action;
Debug.Assert(setAttributes || setTime);
Label_000F:;
try
{
IUpdateVirtualProperty property = destItem as IUpdateVirtualProperty;
if (property != null)
{
property.BeginUpdate();
}
if (setAttributes)
{
if (destItem.CanSetProperty(6))
{
FileAttributes normal = FileAttributes.Normal;
if (sourceItem.IsPropertyAvailable(6))
{
normal = sourceItem.Attributes & ~(FileAttributes.Encrypted | FileAttributes.Compressed);
if (this.CheckOption(CopyWorkerOptions.ClearROFromCD))
{
IGetVirtualVolume parent = sourceItem.Parent as IGetVirtualVolume;
if ((parent != null) && (parent.VolumeType == DriveType.CDRom))
{
normal &= ~FileAttributes.ReadOnly;
}
}
}
destItem[6] = normal | (destItem.Attributes & (FileAttributes.Encrypted | FileAttributes.Compressed));
}
if (this.CheckOption(CopyWorkerOptions.CopyACL))
{
SetProperty(sourceItem, destItem, 14);
}
}
if (setTime)
{
SetProperty(sourceItem, destItem, 7);
SetProperty(sourceItem, destItem, 9);
SetProperty(sourceItem, destItem, 8);
}
if (property != null)
{
property.EndUpdate();
}
return CopyItemAction.Next;
}
catch (UnauthorizedAccessException exception)
{
action = this.ChangeItemError(destItem, sourceItem, destItem, AvailableItemActions.CanRetryOrIgnore, exception);
}
catch (IOException exception2)
{
action = this.ChangeItemError(destItem, sourceItem, destItem, AvailableItemActions.CanRetryOrIgnore, exception2);
}
switch (action)
{
case ChangeItemAction.Retry:
goto Label_000F;
case ChangeItemAction.Ignore:
return CopyItemAction.Next;
case ChangeItemAction.Skip:
return CopyItemAction.Skip;
case ChangeItemAction.Cancel:
base.CancelAsync();
return CopyItemAction.Skip;
}
throw new InvalidEnumArgumentException();
}
private void RaiseAfterCopy(IVirtualItem source, IVirtualItem dest)
{
if (this.OnAfterCopyItem != null)
{
this.OnAfterCopyItem(this, new CopyItemEventArgs(source, dest));
}
}
