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