public OverwriteAllRule(OverwriteDialogResult result)
 {
     if (((result == OverwriteDialogResult.None) || (result == OverwriteDialogResult.Abort)) || (result == OverwriteDialogResult.Rename))
     {
         throw new ArgumentException();
     }
     this.OverwriteResult = result;
 }
 public OverwritePropertyRule(int propertyId, Compare compareOperator, OverwriteDialogResult result)
 {
     if (((result == OverwriteDialogResult.None) || (result == OverwriteDialogResult.Abort)) || (result == OverwriteDialogResult.Rename))
     {
         throw new ArgumentException();
     }
     this.PropertyId = propertyId;
     this.CompareOperator = compareOperator;
     this.OverwriteResult = result;
 }
 public OverwritePropertyValueRule(int propertyId, object value, OverwriteDialogResult result)
 {
     if (((result == OverwriteDialogResult.None) || (result == OverwriteDialogResult.Abort)) || (result == OverwriteDialogResult.Rename))
     {
         throw new ArgumentException();
     }
     this.PropertyId = propertyId;
     this.Value = value;
     this.OverwriteResult = result;
 }
        private bool CheckDestFreeSpace(OverwriteDialogResult overwrite, IVirtualFile source, IVirtualFile dest, IVirtualFolder destFolder)
        {
            bool flag;
            long num = -1L;
            IVirtualFolder folderRoot = VirtualItemHelper.GetFolderRoot(destFolder);
            if ((folderRoot != null) && folderRoot.IsPropertyAvailable(0x1b))
            {
                object obj2 = folderRoot[0x1b];
                if (obj2 != null)
                {
                    num = Convert.ToInt64(obj2);
                }
            }
            if (num < 0L)
            {
                return true;
            }
            object obj3 = source[3];
            if (obj3 == null)
            {
                return true;
            }
            uint clusterSize = 0;
            IGetVirtualVolume volume = destFolder as IGetVirtualVolume;
            if (volume != null)
            {
                clusterSize = volume.ClusterSize;
                if (string.Equals(volume.FileSystem, "FAT32", StringComparison.OrdinalIgnoreCase))
                {
                    num = Math.Min(num, 0x100000000L);
                }
            }
            long num3 = Convert.ToInt64(obj3);
            if (clusterSize > 0)
            {
                num3 = (long) (((num3 / ((ulong) clusterSize)) + Math.Sign((long) (num3 % ((ulong) clusterSize)))) * clusterSize);
            }
        Label_00E7:
            flag = num3 <= num;
            if ((!flag && (dest is IPersistVirtualItem)) && ((IPersistVirtualItem) dest).Exists)
            {
                long num4 = Convert.ToInt64(dest[3]);
                if (clusterSize > 0)
                {
                    num4 = (long) (((num4 / ((ulong) clusterSize)) + Math.Sign((long) (num4 % ((ulong) clusterSize)))) * clusterSize);
                }
                switch (overwrite)
                {
                    case OverwriteDialogResult.Overwrite:
                        flag = num3 < (num + num4);
                        break;

                    case OverwriteDialogResult.Resume:
                        flag = (num3 - num4) < num;
                        break;
                }
            }
            if (flag)
            {
                return true;
            }
            Exception error = new WarningException(string.Format(Resources.sNotEnoughSpaceInDest, destFolder.FullName, source.FullName));
            switch (this.ChangeItemError(null, source, dest, AvailableItemActions.CanRetryOrIgnore, error))
            {
                case ChangeItemAction.Retry:
                    goto Label_00E7;

                case ChangeItemAction.Ignore:
                    return true;

                case ChangeItemAction.Skip:
                    return false;

                case ChangeItemAction.Cancel:
                    base.CancelAsync();
                    return false;
            }
            throw error;
        }
 public BeforeCopyItemEventArgs(IVirtualItem source, IVirtualItem dest) : base(source, dest)
 {
     this.NewName = string.Empty;
     this.OverwriteResult = OverwriteDialogResult.Overwrite;
 }
        public bool Execute(IWin32Window owner, IVirtualItem source, IVirtualItem dest)
        {
            this.CurrentName = source.Name;
            this.CurrentExt = (string) source[1];
            if (string.IsNullOrEmpty(this.CurrentExt))
            {
                this.CurrentExt = Path.GetExtension(this.CurrentName);
            }
            this.cmbChoice.Items.Clear();
            this.cmbChoice.Items.Add(new KeyValuePair<int, string>(0, Resources.sOverwriteRuleCurrentFile));
            this.cmbChoice.Items.Add(new KeyValuePair<int, string>(1, Resources.sOverwriteRuleAll + " (Alt+A)"));
            this.cmbChoice.Items.Add(new KeyValuePair<int, string>(2, string.Format(Resources.sOverwriteRuleAllThisName, this.CurrentName)));
            this.cmbChoice.Items.Add(new KeyValuePair<int, string>(3, string.Format(Resources.sOverwriteRuleAllThisExt, this.CurrentExt)));
            this.cmbChoice.SelectedIndex = 0;
            this.lblSourceName.Text = source.FullName;
            long? nullable = (long?) source[3];
            this.imgSourceIcon.Image = VirtualIcon.GetIcon(source, ImageHelper.DefaultLargeIconSize, this.DefaultIconStyle);
            this.lblSourceName.Tag = source;
            this.imgSourceIcon.Tag = source;
            this.lblExistingName.Text = dest.FullName;
            long? nullable2 = (long?) dest[3];
            this.imgDestIcon.Image = VirtualIcon.GetIcon(dest, ImageHelper.DefaultLargeIconSize, this.DefaultIconStyle);
            this.lblExistingName.Tag = dest;
            this.imgDestIcon.Tag = dest;
            CompareResult result = CompareProperties(source, dest, 3);
            switch (result)
            {
                case CompareResult.Less:
                    this.cmbChoice.Items.Add(new KeyValuePair<int, string>(4, Resources.sOverwriteRuleAllDifferentSize));
                    this.cmbChoice.Items.Add(new KeyValuePair<int, string>(7, Resources.sOverwriteRuleAllBigger));
                    break;

                case CompareResult.Greater:
                    this.cmbChoice.Items.Add(new KeyValuePair<int, string>(4, Resources.sOverwriteRuleAllDifferentSize));
                    this.cmbChoice.Items.Add(new KeyValuePair<int, string>(6, Resources.sOverwriteRuleAllSmaller));
                    break;

                case CompareResult.Equal:
                    this.cmbChoice.Items.Add(new KeyValuePair<int, string>(5, Resources.sOverwriteRuleAllSameSize));
                    break;
            }
            CompareResult result2 = CompareProperties(source, dest, 8);
            switch (result2)
            {
                case CompareResult.Less:
                    this.cmbChoice.Items.Add(new KeyValuePair<int, string>(8, Resources.sOverwriteRuleAllDifferentTime));
                    this.cmbChoice.Items.Add(new KeyValuePair<int, string>(11, Resources.sOverwriteRuleAllNewer));
                    break;

                case CompareResult.Greater:
                    this.cmbChoice.Items.Add(new KeyValuePair<int, string>(8, Resources.sOverwriteRuleAllDifferentTime));
                    this.cmbChoice.Items.Add(new KeyValuePair<int, string>(10, Resources.sOverwriteRuleAllOlder));
                    break;

                case CompareResult.Equal:
                    this.cmbChoice.Items.Add(new KeyValuePair<int, string>(9, Resources.sOverwriteRuleAllSameTime));
                    break;
            }
            this.lblSourceLastWriteTime.Text = string.Format(this.ItemLastWriteTimeFormat, source[8] ?? "?", CompareResultToString(result2, Resources.sTimeOlder, Resources.sTimeNewer, Resources.sTimeEqual));
            object[] args = new object[] { nullable ?? "?", CompareResultToString(result, Resources.sSizeSmaller, Resources.sSizeBigger, Resources.sSizeEqual) };
            this.lblSourceSize.Text = PluralInfo.Format(this.ItemSizeFormat, args);
            this.lblExistingLastWriteTime.Text = string.Format(this.ItemLastWriteTimeFormat, dest[8] ?? "?", CompareResultToString(NegateCompareResult(result2), Resources.sTimeOlder, Resources.sTimeNewer, Resources.sTimeEqual));
            args = new object[] { nullable2 ?? "?", CompareResultToString(NegateCompareResult(result), Resources.sSizeSmaller, Resources.sSizeBigger, Resources.sSizeEqual) };
            this.lblExistingSize.Text = PluralInfo.Format(this.ItemSizeFormat, args);
            if (source.Equals(dest))
            {
                this.lblAlreadyExists.Text = string.Format(Resources.sCannotCopyFileToItself, source.Name);
                this.btnOverwrite.Enabled = false;
                this.btnAppend.Enabled = false;
                this.btnResume.Enabled = false;
            }
            else
            {
                this.lblAlreadyExists.Text = string.Format(this.AlreadyExistsFormat, source.Name);
                this.btnResume.Enabled = result == CompareResult.Greater;
            }
            this.FOldName = source.Name;
            this.txtRename.Text = this.FOldName;
            bool flag = base.ShowDialog(owner) == DialogResult.OK;
            if (!flag)
            {
                this.FOverwriteResult = OverwriteDialogResult.Abort;
            }
            return flag;
        }
 private void btnOverwrite_Click(object sender, EventArgs e)
 {
     this.FOverwriteResult = (OverwriteDialogResult) ((Button) sender).Tag;
     base.DialogResult = DialogResult.OK;
 }
        private string Write201_OverwriteDialogResult(OverwriteDialogResult v)
        {
            switch (v)
            {
                case OverwriteDialogResult.None:
                    return "None";

                case OverwriteDialogResult.Overwrite:
                    return "Overwrite";

                case OverwriteDialogResult.Append:
                    return "Append";

                case OverwriteDialogResult.Resume:
                    return "Resume";

                case OverwriteDialogResult.Rename:
                    return "Rename";

                case OverwriteDialogResult.Skip:
                    return "Skip";

                case OverwriteDialogResult.Abort:
                    return "Abort";
            }
            long num = (long) v;
            throw base.CreateInvalidEnumValueException(num.ToString(CultureInfo.InvariantCulture), "Nomad.Workers.OverwriteDialogResult");
        }