CarotDav_decompile/CarotDAV/CarotDAVDataObject.cs

902 lines
31 KiB
C#

// Decompiled with JetBrains decompiler
// Type: CarotDAV.CarotDAVDataObject
// Assembly: CarotDAV, Version=1.13.2.18337, Culture=neutral, PublicKeyToken=null
// MVID: C31F2651-A4A8-4D09-916A-8C6106F5E7C8
// Assembly location: F:\Eigene Dateien\Dropbox\portable Collection\Progs\CarotDAV\CarotDAV.exe
using Microsoft.VisualBasic.CompilerServices;
using Rei.Com;
using Rei.Fs;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices.ComTypes;
using System.Text;
using System.Threading;
using System.Windows.Forms;
namespace CarotDAV
{
public class CarotDAVDataObject : Rei.Com.DataObject
{
private ConnectionSettingBase pCs;
private FsBase pFs;
private CarotDAVDataObject.CarotDAVDataObjectType pType;
internal DragDropEffects pReturn;
private List<VirtualFileInfo> pFileList;
private List<Uri> pUriList;
private bool pDirty;
private ResourceInfo[] pResources;
private CacheManager pCache;
private bool threadcomp;
private bool pCanCopyInternally;
private bool pCanMoveInternally;
internal int files;
internal long sizes;
internal int folders;
internal int restfolders;
internal ResourceId targetid;
internal object syncobject;
internal Exception ex;
private CarotDAVDataObject.CarotDAVDataObjectState pState;
public ErrorPromptManager pErrorManager;
private EventHandler<ExceptionOccurredEventArgs> pExceptionHandler;
public bool IsInUsebymyself;
private bool pDisposed;
public event CarotDAVDataObject.LogMessageEventHandler LogMessage;
public event CarotDAVDataObject.ReleaseEventHandler Release;
public ResourceInfo[] Resources
{
get
{
return this.pResources;
}
}
public CarotDAVDataObject.CarotDAVDataObjectType Type
{
get
{
return this.pType;
}
}
public bool CanCopyInternally
{
get
{
return this.pCanCopyInternally;
}
}
public bool CanMoveInternally
{
get
{
return this.pCanMoveInternally;
}
}
public CarotDAVDataObject.CarotDAVDataObjectState State
{
get
{
return this.pState;
}
set
{
if (this.pState == value)
return;
if (this.pState == CarotDAVDataObject.CarotDAVDataObjectState.Cancelled)
throw new InvalidOperationException();
switch (value)
{
case CarotDAVDataObject.CarotDAVDataObjectState.WaitTransfer:
this.pState = CarotDAVDataObject.CarotDAVDataObjectState.WaitTransfer;
break;
case CarotDAVDataObject.CarotDAVDataObjectState.Finished:
case CarotDAVDataObject.CarotDAVDataObjectState.Cancelled:
lock (this.pFileList)
{
this.pFileList.Clear();
this.pUriList.Clear();
this.RemoveAll();
this.pDirty = false;
this.pState = value;
break;
}
default:
throw new InvalidOperationException();
}
}
}
public CarotDAVDataObject(ConnectionSettingBase cs, ResourceInfo[] resources, CarotDAVDataObject.CarotDAVDataObjectType type, CacheManager cache)
{
this.AsyncOperationStart += new EventHandler(this.CarotDAVDataObject_AsyncOperationStart);
this.AsyncOperationFinished += new EventHandler<Rei.Com.DataObject.AsyncOperationFinishedEventArgs>(this.CarotDAVDataObject_AsyncOperationFinished);
this.DataQueried += new EventHandler<Rei.Com.DataObject.DataEventArgs>(this.CarotDAVDataObject_DataQueried);
this.DataRequested += new EventHandler<Rei.Com.DataObject.DataEventArgs>(this.CarotDAVDataObject_DataRequested);
this.Release += new CarotDAVDataObject.ReleaseEventHandler(this.CarotDAVDataObject_Release);
this.pFileList = new List<VirtualFileInfo>();
this.pUriList = new List<Uri>();
this.syncobject = RuntimeHelpers.GetObjectValue(new object());
this.pErrorManager = new ErrorPromptManager();
this.pExceptionHandler = new EventHandler<ExceptionOccurredEventArgs>(this.OnExceptionOccurred);
this.pDisposed = false;
this.AsyncSupported = true;
this.IsInUsebymyself = false;
this.pCs = cs;
this.pDirty = true;
this.pFs = cs.GetClient();
this.pFs.GroupName = "OLE" + DateTime.Now.ToString();
this.pResources = resources;
this.pState = CarotDAVDataObject.CarotDAVDataObjectState.WaitListing;
this.pType = type;
this.pCache = cache;
switch (type)
{
case CarotDAVDataObject.CarotDAVDataObjectType.Cut:
this.SetPreferredDropEffect(DragDropEffects.Move);
break;
case CarotDAVDataObject.CarotDAVDataObjectType.Copy:
this.SetPreferredDropEffect(DragDropEffects.Copy);
break;
case CarotDAVDataObject.CarotDAVDataObjectType.DragDrop:
this.SetPreferredDropEffect(DragDropEffects.Copy);
break;
}
if (this.pResources.Length == 1)
this.SetUri(this.pResources[0].Id.Uri);
string[] strs = new string[checked (this.pResources.Length - 1 + 1)];
int num1 = 0;
int num2 = checked (this.pResources.Length - 1);
int index1 = num1;
while (index1 <= num2)
{
strs[index1] = this.pResources[index1].Id.Uri.ToString();
checked { ++index1; }
}
this.SetTexts(strs);
CarotDAVDataObject.InterAppDataStore interAppDataStore = new CarotDAVDataObject.InterAppDataStore();
int num3 = 0;
int num4 = checked (resources.Length - 1);
int index2 = num3;
while (index2 <= num4)
{
interAppDataStore.Files.Add(resources[index2].Id);
checked { ++index2; }
}
interAppDataStore.Type = this.pType;
interAppDataStore.ConnectionSetting = this.pCs;
interAppDataStore.ID = (long) Process.GetCurrentProcess().Id;
this.SetManagedObject((object) interAppDataStore);
this.pCanCopyInternally = true;
this.pCanMoveInternally = true;
int num5 = 0;
int num6 = checked (this.pResources.Length - 1);
int index3 = num5;
while (index3 <= num6)
{
if (!this.pResources[index3].CanCopy)
this.pCanCopyInternally = false;
if (!this.pResources[index3].CanMove)
this.pCanMoveInternally = false;
checked { ++index3; }
}
this.pFs.LogMessage += new EventHandler<LogMessageEventArgs>(this.pFS_LogMessage);
}
protected override void Dispose(bool disposing)
{
try
{
if (!this.pDisposed)
return;
int num = disposing ? 1 : 0;
}
finally
{
base.Dispose(disposing);
}
}
public override FORMATETC[] SupportedFormats()
{
List<FORMATETC> formatetcList = new List<FORMATETC>();
formatetcList.AddRange((IEnumerable<FORMATETC>) base.SupportedFormats());
FORMATETC formatetc=new FORMATETC();
formatetc.dwAspect = DVASPECT.DVASPECT_CONTENT;
formatetc.lindex = -1;
formatetc.tymed = TYMED.TYMED_HGLOBAL;
formatetc.cfFormat = Rei.Com.DataObject.MakecfFormat(ShellClipboardFormats.FileGroupDescriptorW);
formatetcList.Add(formatetc);
formatetc.cfFormat = Rei.Com.DataObject.MakecfFormat(ShellClipboardFormats.FileContents);
formatetc.tymed = TYMED.TYMED_ISTREAM;
formatetcList.Add(formatetc);
formatetc.cfFormat = Rei.Com.DataObject.MakecfFormat(ShellClipboardFormats.ShellIDListArray);
formatetc.tymed = TYMED.TYMED_HGLOBAL;
formatetcList.Add(formatetc);
formatetc.cfFormat = Rei.Com.DataObject.MakecfFormat(ShellClipboardFormats.PasteSucceeded);
formatetc.tymed = TYMED.TYMED_HGLOBAL;
formatetcList.Add(formatetc);
return formatetcList.ToArray();
}
public void Add(ResourceInfo ri, string name)
{
if (this.pCs.DownloadFilenameNormalization != UCSNormalization.None)
name = name.Normalize((NormalizationForm) this.pCs.DownloadFilenameNormalization);
VirtualFileInfo virtualFileInfo = new VirtualFileInfo();
virtualFileInfo.FileName = name;
if (ri.IsCollection)
{
virtualFileInfo.FileAttributes = FileAttributes.Directory;
virtualFileInfo.Flags = virtualFileInfo.Flags | FDFlags.FD_ATTRIBUTES;
}
else
{
virtualFileInfo.FileAttributes = FileAttributes.Normal;
virtualFileInfo.Flags = virtualFileInfo.Flags | FDFlags.FD_ATTRIBUTES;
}
if (DateTime.Compare(ri.CreationTime, DateTime.MinValue) != 0)
{
virtualFileInfo.CreationTime = ri.CreationTime;
virtualFileInfo.Flags = virtualFileInfo.Flags | FDFlags.FD_CREATETIME;
}
if (DateTime.Compare(ri.LastAccessTime, DateTime.MinValue) != 0)
{
virtualFileInfo.LastAccessTime = ri.LastAccessTime;
virtualFileInfo.Flags = virtualFileInfo.Flags | FDFlags.FD_ACCESSTIME;
}
if (DateTime.Compare(ri.LastModifiedTime, DateTime.MinValue) != 0)
{
virtualFileInfo.LastWriteTime = ri.LastModifiedTime;
virtualFileInfo.Flags = virtualFileInfo.Flags | FDFlags.FD_WRITESTIME;
}
if (ri.IsCollection)
{
virtualFileInfo.FileSize = 0UL;
virtualFileInfo.Flags = virtualFileInfo.Flags | FDFlags.FD_FILESIZE;
}
else if (ri.Size >= 0L)
{
virtualFileInfo.FileSize = checked ((ulong) ri.Size);
virtualFileInfo.Flags = virtualFileInfo.Flags | FDFlags.FD_FILESIZE;
}
if (!ri.IsCollection)
{
OleStreamCreator oleStreamCreator = new OleStreamCreator(ri, name, this.pFs, this.pErrorManager);
oleStreamCreator.ExceptionOccurred += this.pExceptionHandler;
virtualFileInfo.IStreamCreator = (IStreamCreator) oleStreamCreator;
}
lock (this.pFileList)
{
this.pFileList.Add(virtualFileInfo);
this.pUriList.Add(ri.Id.Uri);
this.pDirty = true;
}
}
public void Update()
{
lock (this.pFileList)
{
if (!this.pDirty)
return;
string[] strs = new string[checked (this.pUriList.Count - 1 + 1)];
int num1 = 0;
int num2 = checked (this.pUriList.Count - 1);
int index = num1;
while (index <= num2)
{
strs[index] = this.pUriList[index].ToString();
checked { ++index; }
}
this.SetVirtualFiles(this.pFileList.ToArray(), true);
this.SetTexts(strs);
this.pDirty = false;
}
}
public void SetDragDropResult(DragDropEffects r)
{
this.pReturn = r;
if (this.IsInOperation)
return;
this.OnTransferFinish();
}
protected override void OnDataRequested(Rei.Com.DataObject.DataEventArgs e)
{
if (((int) e.Format.cfFormat == (int) Rei.Com.DataObject.MakecfFormat(ShellClipboardFormats.FileGroupDescriptorW) || (int) e.Format.cfFormat == (int) Rei.Com.DataObject.MakecfFormat(ShellClipboardFormats.FileGroupDescriptor) || ((int) e.Format.cfFormat == (int) Rei.Com.DataObject.MakecfFormat(DataFormats.UnicodeText) || (int) e.Format.cfFormat == (int) Rei.Com.DataObject.MakecfFormat(DataFormats.Text))) && this.State == CarotDAVDataObject.CarotDAVDataObjectState.WaitListing)
{
this.threadcomp = false;
Thread thread = new Thread(new ParameterizedThreadStart(this.ThreadStartPoint));
thread.Start((object) this);
DateTime now = DateTime.Now;
DialogResult dialogResult = DialogResult.OK;
while (!thread.Join(100))
{
if (DateTime.Now.Subtract(now).TotalSeconds > 1.0)
{
using (ResouceListingForm resouceListingForm = new ResouceListingForm())
{
resouceListingForm.Thread = thread;
resouceListingForm.pDataObject = this;
dialogResult = resouceListingForm.ShowDialog();
thread.Abort();
break;
}
}
}
thread.Join();
if (this.ex != null)
throw this.ex;
if (dialogResult != DialogResult.OK || !this.threadcomp)
{
this.State = CarotDAVDataObject.CarotDAVDataObjectState.Cancelled;
this.pFs.ResetConnection();
}
else
this.State = CarotDAVDataObject.CarotDAVDataObjectState.WaitTransfer;
}
base.OnDataRequested(e);
}
private void ThreadStartPoint(object param)
{
try
{
ErrorPromptManager pDragErrorManager = new ErrorPromptManager();
LinkedList<KeyValuePair<ResourceInfo, string>> linkedList1 = new LinkedList<KeyValuePair<ResourceInfo, string>>();
Dictionary<ResourceInfo, string> dictionary1 = new Dictionary<ResourceInfo, string>();
this.targetid = this.Resources[0].Id;
ResourceInfo[] resources = this.Resources;
List<string> stringList = new List<string>();
Dictionary<string, List<int>> dictionary2 = new Dictionary<string, List<int>>();
int num1 = 0;
int num2 = checked (resources.Length - 1);
int index1 = num1;
KeyValuePair<ResourceInfo, string> keyValuePair1;
while (index1 <= num2)
{
if (resources[index1].Id.Uri.Segments.Length <= 1)
{
LinkedList<KeyValuePair<ResourceInfo, string>> linkedList2 = linkedList1;
keyValuePair1 = new KeyValuePair<ResourceInfo, string>(resources[index1], "root");
KeyValuePair<ResourceInfo, string> keyValuePair2 = keyValuePair1;
linkedList2.AddFirst(keyValuePair2);
Interlocked.Increment(ref this.folders);
Interlocked.Increment(ref this.restfolders);
}
else
{
string absolutePath = UriUtil.GetParent(resources[index1].Id.Uri).AbsolutePath;
if (!dictionary2.ContainsKey(absolutePath))
{
stringList.Add(absolutePath);
dictionary2.Add(absolutePath, new List<int>());
}
dictionary2[absolutePath].Add(index1);
}
checked { ++index1; }
}
int num3 = 0;
int num4 = checked (stringList.Count - 1);
int index2 = num3;
while (index2 <= num4)
{
string index3 = stringList[index2];
if (dictionary2[index3].Count < 3)
{
int num5 = 0;
int num6 = checked (dictionary2[index3].Count - 1);
int index4 = num5;
while (index4 <= num6)
{
ResourceInfo[] info = this.InnerGetInfo(resources[dictionary2[index3][index4]].Id, pDragErrorManager);
if (info == null)
return;
ResourceInfo key = info[0];
string lastName = UriUtil.GetLastName(key.Id.Uri);
if (!key.IsCollection)
{
dictionary1.Add(key, lastName);
Interlocked.Increment(ref this.files);
Interlocked.Add(ref this.sizes, key.Size);
}
else
{
LinkedList<KeyValuePair<ResourceInfo, string>> linkedList2 = linkedList1;
keyValuePair1 = new KeyValuePair<ResourceInfo, string>(key, lastName);
KeyValuePair<ResourceInfo, string> keyValuePair2 = keyValuePair1;
linkedList2.AddFirst(keyValuePair2);
Interlocked.Increment(ref this.folders);
Interlocked.Increment(ref this.restfolders);
}
checked { ++index4; }
}
}
else
{
ResourceInfo[] parentInfoAndEntries = this.InnerGetParentInfoAndEntries(resources[dictionary2[index3][0]].Id, pDragErrorManager);
if (parentInfoAndEntries == null)
return;
int num5 = 0;
int num6 = checked (dictionary2[index3].Count - 1);
int index4 = num5;
while (index4 <= num6)
{
int num7 = 1;
int num8 = checked (parentInfoAndEntries.Length - 1);
int index5 = num7;
while (index5 <= num8)
{
if (parentInfoAndEntries[index5].Id.Uri == resources[dictionary2[index3][index4]].Id.Uri)
{
ResourceInfo key = parentInfoAndEntries[index5];
string lastName = UriUtil.GetLastName(key.Id.Uri);
if (!key.IsCollection)
{
dictionary1.Add(key, lastName);
Interlocked.Increment(ref this.files);
Interlocked.Add(ref this.sizes, key.Size);
}
else
{
LinkedList<KeyValuePair<ResourceInfo, string>> linkedList2 = linkedList1;
keyValuePair1 = new KeyValuePair<ResourceInfo, string>(key, lastName);
KeyValuePair<ResourceInfo, string> keyValuePair2 = keyValuePair1;
linkedList2.AddFirst(keyValuePair2);
Interlocked.Increment(ref this.folders);
Interlocked.Increment(ref this.restfolders);
}
}
checked { ++index5; }
}
checked { ++index4; }
}
}
checked { ++index2; }
}
while (linkedList1.First != null)
{
KeyValuePair<ResourceInfo, string> keyValuePair2 = linkedList1.First.Value;
linkedList1.RemoveFirst();
ResourceInfo[] entries = this.InnerGetEntries(keyValuePair2.Key.Id, pDragErrorManager);
dictionary1.Add(keyValuePair2.Key, keyValuePair2.Value);
int num5 = 0;
int num6 = checked (entries.Length - 1);
int index3 = num5;
while (index3 <= num6)
{
string str = Path.Combine(keyValuePair2.Value, UriUtil.GetLastName(entries[index3].Id.Uri));
if (!entries[index3].IsCollection)
{
dictionary1.Add(entries[index3], str);
Interlocked.Increment(ref this.files);
Interlocked.Add(ref this.sizes, entries[index3].Size);
}
else
{
LinkedList<KeyValuePair<ResourceInfo, string>> linkedList2 = linkedList1;
keyValuePair1 = new KeyValuePair<ResourceInfo, string>(entries[index3], str);
KeyValuePair<ResourceInfo, string> keyValuePair3 = keyValuePair1;
linkedList2.AddFirst(keyValuePair3);
Interlocked.Increment(ref this.folders);
Interlocked.Increment(ref this.restfolders);
}
checked { ++index3; }
}
Interlocked.Decrement(ref this.restfolders);
}
Dictionary<ResourceInfo, string>.Enumerator enumerator = dictionary1.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
KeyValuePair<ResourceInfo, string> current = enumerator.Current;
this.Add(current.Key, current.Value);
}
}
finally
{
enumerator.Dispose();
}
this.Update();
this.threadcomp = true;
}
catch (Exception ex)
{
ProjectData.SetProjectError(ex);
this.ex = ex;
ProjectData.ClearProjectError();
}
finally
{
}
}
private ResourceInfo[] InnerGetParentInfoAndEntries(ResourceId id, ErrorPromptManager pDragErrorManager)
{
this.targetid = id;
int retryminutes = 1;
ResourceInfo[] resourceInfoArray;
while (true)
{
try
{
return this.pCache.GetParentInfoAndEntries(this.pFs, id, false);
}
catch (ThreadAbortException ex)
{
ProjectData.SetProjectError((Exception) ex);
throw;
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
if (ex2.InnerException is ThreadAbortException)
{
throw;
}
else
{
ErrorAction errorAction;
if (pDragErrorManager.IgnoreAll())
{
errorAction = ErrorAction.Ignore;
}
else
{
ExceptionOccurredEventArgs e = new ExceptionOccurredEventArgs("Error occurred during retrieving properties.", id.ToString(), ErrorPromptType.IgnoreAllIgnoreRetryCancel, ex2, retryminutes);
this.OnExceptionOccurred((object) this, e);
pDragErrorManager.RegisterAction(e.Result);
errorAction = e.Result.Action;
}
switch (errorAction)
{
case ErrorAction.Ignore:
resourceInfoArray = new ResourceInfo[0];
ProjectData.ClearProjectError();
goto label_15;
case ErrorAction.Retry:
ProjectData.ClearProjectError();
continue;
case ErrorAction.AutoRetry:
checked { retryminutes *= 2; }
ProjectData.ClearProjectError();
continue;
case ErrorAction.Cancel:
resourceInfoArray = (ResourceInfo[]) null;
ProjectData.ClearProjectError();
goto label_15;
default:
throw;
}
}
}
}
label_15:
return resourceInfoArray;
}
private ResourceInfo[] InnerGetInfo(ResourceId id, ErrorPromptManager pDragErrorManager)
{
this.targetid = id;
int retryminutes = 1;
ResourceInfo info;
ResourceInfo[] resourceInfoArray;
while (true)
{
try
{
info = this.pCache.GetInfo(this.pFs, id, false);
break;
}
catch (ThreadAbortException ex)
{
ProjectData.SetProjectError((Exception) ex);
throw;
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
if (ex2.InnerException is ThreadAbortException)
{
throw;
}
else
{
ErrorAction errorAction;
if (pDragErrorManager.IgnoreAll())
{
errorAction = ErrorAction.Ignore;
}
else
{
ExceptionOccurredEventArgs e = new ExceptionOccurredEventArgs("Error occurred during retrieving properties.", id.ToString(), ErrorPromptType.IgnoreAllIgnoreRetryCancel, ex2, retryminutes);
this.OnExceptionOccurred((object) this, e);
pDragErrorManager.RegisterAction(e.Result);
errorAction = e.Result.Action;
}
switch (errorAction)
{
case ErrorAction.Ignore:
resourceInfoArray = new ResourceInfo[0];
ProjectData.ClearProjectError();
goto label_16;
case ErrorAction.Retry:
ProjectData.ClearProjectError();
continue;
case ErrorAction.AutoRetry:
checked { retryminutes *= 2; }
ProjectData.ClearProjectError();
continue;
case ErrorAction.Cancel:
resourceInfoArray = (ResourceInfo[]) null;
ProjectData.ClearProjectError();
goto label_16;
default:
throw;
}
}
}
}
return new ResourceInfo[1]{ info };
label_16:
return resourceInfoArray;
}
private ResourceInfo[] InnerGetEntries(ResourceId id, ErrorPromptManager pDragErrorManager)
{
this.targetid = id;
int retryminutes = 1;
ResourceInfo[] resourceInfoArray;
while (true)
{
try
{
return this.pCache.GetEntries(this.pFs, id, false);
}
catch (ThreadAbortException ex)
{
ProjectData.SetProjectError((Exception) ex);
throw;
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
if (ex2.InnerException is ThreadAbortException)
{
throw;
}
else
{
ErrorAction errorAction;
if (pDragErrorManager.IgnoreAll())
{
errorAction = ErrorAction.Ignore;
}
else
{
ExceptionOccurredEventArgs e = new ExceptionOccurredEventArgs("Error occurred during retrieving properties.", id.ToString(), ErrorPromptType.IgnoreAllIgnoreRetryCancel, ex2, retryminutes);
this.OnExceptionOccurred((object) this, e);
pDragErrorManager.RegisterAction(e.Result);
errorAction = e.Result.Action;
}
switch (errorAction)
{
case ErrorAction.Ignore:
Interlocked.Decrement(ref this.restfolders);
resourceInfoArray = new ResourceInfo[0];
ProjectData.ClearProjectError();
goto label_15;
case ErrorAction.Retry:
ProjectData.ClearProjectError();
continue;
case ErrorAction.AutoRetry:
checked { retryminutes *= 2; }
ProjectData.ClearProjectError();
continue;
case ErrorAction.Cancel:
resourceInfoArray = (ResourceInfo[]) null;
ProjectData.ClearProjectError();
goto label_15;
default:
throw;
}
}
}
}
label_15:
return resourceInfoArray;
}
protected override void OnDataStored(Rei.Com.DataObject.DataEventArgs e)
{
base.OnDataStored(e);
if ((int) e.Format.cfFormat != (int) Rei.Com.DataObject.MakecfFormat(ShellClipboardFormats.PasteSucceeded))
return;
this.pReturn = this.GetPasteSucceeded();
if (this.IsInOperation)
return;
this.OnTransferFinish();
}
protected virtual void PerformDeleteOnPaste()
{
if (this.GetPerformedDropEffect() != DragDropEffects.Move)
return;
int num1 = 0;
int num2 = checked (this.Resources.Length - 1);
int index = num1;
while (index <= num2)
{
int retryminutes = 1;
while (true)
{
ResourceId id = this.Resources[index].Id;
try
{
this.pCache.Delete(this.pFs, id);
break;
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
ErrorAction errorAction;
if (this.pErrorManager.IgnoreAll())
{
errorAction = ErrorAction.Ignore;
}
else
{
ExceptionOccurredEventArgs e = new ExceptionOccurredEventArgs("Error occurred during deleting resource.", id.ToString(), ErrorPromptType.IgnoreAllIgnoreRetryCancel, ex2, retryminutes);
this.OnExceptionOccurred((object) this, e);
this.pErrorManager.RegisterAction(e.Result);
errorAction = e.Result.Action;
}
switch (errorAction)
{
case ErrorAction.Retry:
ProjectData.ClearProjectError();
continue;
case ErrorAction.AutoRetry:
checked { retryminutes *= 2; }
ProjectData.ClearProjectError();
continue;
case ErrorAction.Cancel:
ProjectData.ClearProjectError();
return;
default:
ProjectData.ClearProjectError();
goto label_14;
}
}
}
label_14:
checked { ++index; }
}
}
private void OnExceptionOccurred(object sender, ExceptionOccurredEventArgs e)
{
e.Result = ErrorPromptForm.ShowDialog((IWin32Window) null, e.Message, e.Target, e.Exception, e.Type, e.RetryMinutes);
}
private void pFS_LogMessage(object sender, LogMessageEventArgs e)
{
CarotDAVDataObject.LogMessageEventHandler logMessageEvent = this.LogMessage;
if (logMessageEvent == null)
return;
logMessageEvent(RuntimeHelpers.GetObjectValue(sender), e);
}
public void OnTransferFinish()
{
this.PerformDeleteOnPaste();
this.State = CarotDAVDataObject.CarotDAVDataObjectState.Finished;
CarotDAVDataObject.ReleaseEventHandler releaseEvent = this.Release;
if (releaseEvent == null)
return;
releaseEvent((object) this, EventArgs.Empty);
}
private void CarotDAVDataObject_AsyncOperationStart(object sender, EventArgs e)
{
}
private void CarotDAVDataObject_AsyncOperationFinished(object sender, Rei.Com.DataObject.AsyncOperationFinishedEventArgs e)
{
this.OnTransferFinish();
}
private void CarotDAVDataObject_DataQueried(object sender, Rei.Com.DataObject.DataEventArgs e)
{
if (e.Format.ptd != IntPtr.Zero)
return;
FORMATETC format = e.Format;
if (format.dwAspect != DVASPECT.DVASPECT_CONTENT)
return;
format = e.Format;
if (format.lindex != -1)
return;
format = e.Format;
if ((int) format.cfFormat == (int) BitConverter.ToInt16(BitConverter.GetBytes(DataFormats.GetFormat("FileContents").Id), 0) && (e.Format.tymed & TYMED.TYMED_ISTREAM) != TYMED.TYMED_NULL)
{
e.QueryResult = Rei.Com.DataObject.QueryGetDataResultType.Exists;
}
else
{
if ((int) e.Format.cfFormat == (int) BitConverter.ToInt16(BitConverter.GetBytes(DataFormats.GetFormat("FileGroupDescriptorW").Id), 0))
{
format = e.Format;
if ((format.tymed & TYMED.TYMED_HGLOBAL) != TYMED.TYMED_NULL)
{
e.QueryResult = Rei.Com.DataObject.QueryGetDataResultType.Exists;
return;
}
}
if ((int) e.Format.cfFormat != (int) BitConverter.ToInt16(BitConverter.GetBytes(DataFormats.GetFormat("FileGroupDescriptor").Id), 0))
return;
format = e.Format;
if ((format.tymed & TYMED.TYMED_HGLOBAL) == TYMED.TYMED_NULL)
return;
e.QueryResult = Rei.Com.DataObject.QueryGetDataResultType.Exists;
}
}
private void CarotDAVDataObject_DataRequested(object sender, Rei.Com.DataObject.DataEventArgs e)
{
}
private void CarotDAVDataObject_Release(object sender, EventArgs e)
{
}
public enum CarotDAVDataObjectState
{
WaitListing,
WaitTransfer,
Finished,
Cancelled,
}
public enum CarotDAVDataObjectType
{
Cut,
Copy,
DragDrop,
}
public delegate void LogMessageEventHandler(object sender, LogMessageEventArgs e);
public delegate void ReleaseEventHandler(object sender, EventArgs e);
[Serializable]
public class InterAppDataStore
{
public List<ResourceId> Files;
public CarotDAVDataObject.CarotDAVDataObjectType Type;
public ConnectionSettingBase ConnectionSetting;
public long ID;
public InterAppDataStore()
{
this.Files = new List<ResourceId>();
}
}
}
}