private void InitializeHelperObjects()
{
// DocManager
DocManagerData data = new DocManagerData();
data.FormOwner = this;
data.UpdateTitle = true;
data.FileDialogFilter = "MaBongPal files (*.mbp)|*.mbp|All Files (*.*)|*.*";
data.NewDocName = "Untitled.mbp";
data.RegistryPath = registryPath;
docManager = new DocManager(data);
docManager.RegisterFileType("mbp", "mbpfile", "MaBongPal File");
docManager.SaveEvent += new SaveEventHandler(docManager_SaveEvent);
docManager.LoadEvent += new LoadEventHandler(docManager_LoadEvent);
docManager.OpenEvent += new OpenFileEventHandler(docManager_OpenEvent);
docManager.DocChangedEvent += new EventHandler(docManager_DocChangedEvent);
docManager.ClearEvent += new EventHandler(docManager_ClearEvent);
docManager.NewDocument();
// DragDropManager
dragDropManager = new DragDropManager(this);
dragDropManager.FileDroppedEvent += new FileDroppedEventHandler(this.dragDropManager_FileDroppedEvent);
// MruManager
mruManager = new MruManager();
mruManager.Initialize(this, menuFileRecentFiles, registryPath);
mruManager.MruOpenEvent += new MruFileOpenEventHandler(mruManager_MruOpenEvent);
// ODSExporter
odsExporter = new ODSExporter();
}
/// <summary>
/// Dispose the File Stream.
/// </summary>
public void Dispose()
{
_isDisposed = true;
if (_fileStream == null)
{
return;
}
if (!_unBuffered)
{
_fileStream.Dispose();
InUse = false;
_fileStream = null;
return;
}
MruManager.Remove(Id);
lock (_locker)
{
if (_fileStream == null)
{
return;
}
_fileStream.Dispose();
_fileStream = null;
InUse = false;
}
}
/// <summary>
/// Remove an entry with a given key. Notifies subscriber, if there is any,
/// of the removed item.
/// </summary>
/// <param name="key"></param>
/// <param name="regionName"></param>
/// <returns></returns>
public override object Remove(string key, string regionName = null)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
var cacheKey = new CacheKey(key);
CacheEntry cacheValue = null;
// remove the item, return if not found.
lock (_locker)
{
var mruEntry = MruManager.GetItem(cacheKey);
if (mruEntry == null)
{
return(null);
}
// get the Store's Current Key containing the TimeStamp!
cacheKey = (CacheKey)mruEntry.Key;
cacheValue = mruEntry.Value as CacheEntry;
MruManager.Remove(cacheKey);
}
// Notify the subscriber of the removed item.
if (CacheEntrySetRemovedCallback != null)
{
CacheEntrySetRemovedCallback(new[]
{
new CacheEntryRemovedArguments(this, CacheEntryRemovedReason.Removed, cacheValue.Convert(cacheKey))
});
}
return(cacheValue);
}
private void MaintainOpenedFileCount()
{
if (MruManager.Count <= MaxInstanceCount)
{
return;
}
while (MruManager.Count > MruManager.MinCapacity)
{
Mru.Generic.MruItem <int, FileStream> item = MruManager.PeekInTail();
if (item.Value.InUse)
{
return;
}
lock (item.Value._locker)
{
if (item.Value.InUse || item.Value._fileStream == null)
{
return;
}
MruManager.Remove(item.Value.Id);
//item.Value._streamPosition = item.Value._fileStream.Position;
item.Value._fileStream.Flush();
item.Value._fileStream.Close();
item.Value._fileStream = null;
}
}
}
public override void Set(string key, object value,
CacheItemPolicy policy, string regionName = null)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
if (policy == null)
{
policy = DefaultPolicy;
}
var now = GetCurrentDate(0);
var entry = new CacheEntry(policy, now)
{
Value = value
};
var cacheKey = new CacheKey(key)
{
TimeStamp = now
};
lock (_locker)
{
var e = MruManager.GetItem(cacheKey);
if (e == null)
{
MruManager.Add(cacheKey, entry);
return;
}
entry = e.Value as CacheEntry;
entry.Value = value;
// if priotiry is not removable, just update the store w/ value
if (entry.NonExpiring)
{
return;
}
if (!entry.IsExpired(now))
{
// slide the expire time...
if (entry.SlidingExpiration > 0)
{
entry.ExpirationTime = GetCurrentDate(entry.SlidingExpiration);
}
return;
}
// adjust policy (set to slide every 5 mins) of the expired item to accomodate this update...
if (entry.SlidingExpiration == 0)
{
entry.SlidingExpiration = TimeSpan.TicksPerMinute * 5;
}
entry.ExpirationTime = GetCurrentDate(entry.SlidingExpiration);
}
}
private void DisposeCachedItems()
{
if (AutoDisposeItem)
{
// Dispose any cached objects that are disposable.
MruManager.Dispose();
}
}
/// <summary>
/// Update the data stored at a given Address.
/// </summary>
/// <param name="value"></param>
public virtual void Update(object value)
{
//** Update the Current Entry w/ 'value'
CurrentItem.Data = value;
//** CurrentItem.DataAddress should be the same as DiskBuffer.DataAddress.
WriteToDisk(CurrentItem, false);
MruManager.Add(CurrentItem.DiskBuffer.DataAddress, CurrentItem);
RegisterChange(true);
//IsDirty = true;
}
/// <summary>
/// Remove ObjectToRemove from the Collection if found, else throws an exception
/// </summary>
public void Remove(object item)
{
if (!Contains(item))
{
return;
}
Sop.DataBlock currBlock = this.GetCurrentDataBlock(true);
if (GetId(currBlock) >= 0)
{
MruManager.Remove(GetId(currBlock), true);
}
DataBlockDriver.Remove(this, currBlock);
}
/// <summary>
/// Add 'Value' to the Collection
/// </summary>
public long Add(object value)
{
var o = new LinkedItemOnDisk(this.DataBlockSize)
{
Data = value
};
WriteToDisk(o, false);
UpdateCount(UpdateCountType.Increment);
//*** update Current, Last & First
if (LastItem.DiskBuffer.DataAddress != -1)
{
o.PreviousItemAddress = LastItem.DiskBuffer.DataAddress;
WriteToDisk(o, false);
LinkedItemOnDisk biod = CurrentItem;
biod.NextItemAddress = o.DiskBuffer.DataAddress;
Sop.DataBlock db = DataBlockDriver.ReadBlockFromDisk(this, LastItem.DiskBuffer.DataAddress, true);
if (CurrentItem.DiskBuffer.DataAddress != LastItem.DiskBuffer.DataAddress)
{
biod = (LinkedItemOnDisk)ReadFromBlock(db);
biod.NextItemAddress = o.DiskBuffer.DataAddress;
}
else
{
PurifyMeta(biod, db);
if (db.SizeOccupied > 0)
{
biod.DiskBuffer = db;
}
}
WriteToDisk(biod, false);
}
else
{
FirstItem.DiskBuffer.DataAddress = o.DiskBuffer.DataAddress;
}
currentEntry = null;
CurrentItem = o;
CurrentEntryDataAddress = o.DiskBuffer.DataAddress;
currentDataBlock = o.DiskBuffer;
LastItem.DiskBuffer.DataAddress = o.DiskBuffer.DataAddress;
MruManager.Add(CurrentEntryDataAddress, o);
//** update the header
RegisterChange(true);
//IsDirty = true;
return(o.DiskBuffer.DataAddress);
}
public void Close()
{
if (_isDisposed || _fileStream == null)
{
return;
}
_fileStream.Close();
if (_unBuffered)
{
InUse = false;
MruManager.Remove(Id);
_fileStream = null;
}
}
/// <summary>
/// Returns the Items of the MRU Cache.
/// </summary>
/// <returns></returns>
protected override IEnumerator <KeyValuePair <string, object> > GetEnumerator()
{
lock (_locker)
{
var e = MruManager.GetEnumerator();
List <KeyValuePair <string, object> > items = new List <KeyValuePair <string, object> >();
do
{
items.Add(new KeyValuePair <string, object>(
((CacheKey)e.Current.Key).Key, ((CacheEntry)e.Current.Value).Value));
} while (e.MoveNext());
return(items.GetEnumerator());
}
}
public override CacheItem GetCacheItem(string key, string regionName = null)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
MruItem mruEntry = null;
var cacheKey = new CacheKey(key);
// code block to get item from store and if found, return it if not expired.
Func <bool> block = (() =>
{
lock (_locker)
{
// try to get from the store
mruEntry = MruManager.GetItem(cacheKey);
if (mruEntry != null)
{
cacheKey = (CacheKey)mruEntry.Key;
if (IsNotExpired(cacheKey, (CacheEntry)mruEntry.Value, false))
{
return(true);
}
}
return(false);
}
});
if (block())
{
return(new CacheItem(key, mruEntry.Value));
}
#region try to update the Cache entry if it is expired by calling the Update callback.
if (CacheEntrySetUpdateCallback == null)
{
return(null);
}
CacheEntrySetUpdateCallback(new CacheEntryUpdateArguments[] { new CacheEntryUpdateArguments(this, CacheEntryRemovedReason.Expired, key, null) });
// try to get from the store a 2nd time and see if item got updated & no longer expired...
if (block())
{
return(new CacheItem(key, mruEntry.Value));
}
#endregion
return(null);
}
private void ReuseCacheFromPool()
{
// todo: include InstanceId to the cacheId...
string cacheId = string.Format("{0}{1}", File.Filename, GetId());
ICollectionCache cache = CachePoolManager.GetCache(cacheId);
if (cache == null)
{
CachePoolManager.SetCache(cacheId, this);
}
else
{
MruManager = cache.MruManager;
Blocks = cache.Blocks;
MruManager.SetDataStores(this, DataBlockDriver);
}
}
/// <summary>
/// Loads the given <paramref name="logFileToLoad"/> into a new logger window.
/// </summary>
/// <param name="logFileToLoad">The log file to load into a new logger window.</param>
/// <param name="verbose">[Optional] <c>True</c> to inform the user about any load error, otherwise <c>false</c>. Default is <c>True</c>.</param>
private void LoadFileIntoLogger(string logFileToLoad, bool verbose = true)
{
if (!string.IsNullOrEmpty(logFileToLoad) && File.Exists(logFileToLoad))
{
ReceiverBase[] knownFileReceiver =
{
new Log4NetFileReceiver(logFileToLoad, true)
, new SyslogFileReceiver(logFileToLoad, true)
};
foreach (ReceiverBase receiver in knownFileReceiver)
{
if (receiver.CanHandleLogFile())
{
FrmLogDocument newFileDocument = new FrmLogDocument(receiver);
// Disable continues logging by default.
newFileDocument.Active = false;
// Show the new document.
newFileDocument.Show(mainDockPanel);
// Add the file to the recently used stack.
MruManager.AddFile(logFileToLoad);
// Rebuild the MRU list to ensure the opened file is displayed in the menu.
RebuildMruList();
return;
}
}
if (verbose)
{
// Inform the user about the error.
MessageBox.Show(this, string.Format(
Resources.strOpenLogFileError
, Path.GetFileName(logFileToLoad))
, Application.ProductName
, MessageBoxButtons.OK
, MessageBoxIcon.Error);
}
}
}
public VirtualStore(string name, int mruMinCapacity = 4500, int mruMaxCapacity = 6000)
{
if (mruMinCapacity < 7)
{
mruMinCapacity = 7;
}
if (mruMaxCapacity < 10)
{
mruMaxCapacity = 10;
}
if (mruMinCapacity >= mruMaxCapacity)
{
mruMinCapacity = (int)(mruMaxCapacity * .75);
}
// todo: change to use ConcurrentMruManager ? for concurrency.
MruManager = new MruManager(mruMinCapacity, mruMaxCapacity, new CacheKeyComparer());
MruManager.SetDataStores(this, null);
_name = name;
}
public override bool Contains(string key, string regionName = null)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
var cacheKey = new CacheKey(key);
bool b;
lock (_locker)
{
// try to get from the store
var mruEntry = MruManager.GetItem(cacheKey);
if (mruEntry == null)
{
return(false);
}
cacheKey = (CacheKey)mruEntry.Key;
b = IsNotExpired(cacheKey, (CacheEntry)mruEntry.Value, false);
if (b || CacheEntrySetUpdateCallback == null)
{
return(b);
}
}
// try to update the Cache entry if it is expired by calling the Update callback.
CacheEntrySetUpdateCallback(new CacheEntryUpdateArguments[]
{ new CacheEntryUpdateArguments(this, CacheEntryRemovedReason.Expired, key, null) });
lock (_locker)
{
// try to get from the store a 2nd time and see if item got updated & no longer expired...
var mruEntry = MruManager.GetItem(cacheKey);
if (mruEntry != null)
{
cacheKey = (CacheKey)mruEntry.Key;
b = IsNotExpired(cacheKey, (CacheEntry)mruEntry.Value, false);
}
return(b);
}
}
private void RecentFileClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
string logFileToLoad = ((Control)sender).Tag as string;
if (!File.Exists(logFileToLoad))
{
DialogResult removeRslt = MessageBox.Show(
Resources.strMruFileCouldNotBeFound
, Application.ProductName
, MessageBoxButtons.YesNo
, MessageBoxIcon.Warning);
if (removeRslt == DialogResult.Yes)
{
MruManager.RemoveFile(logFileToLoad);
}
return;
}
mMainForm.LoadFileIntoLogger(logFileToLoad);
}
private void OnMruFileClick(object sender, EventArgs e)
{
string logFileToLoad = ((ToolStripMenuItem)sender).Tag as string;
if (!File.Exists(logFileToLoad))
{
DialogResult removeRslt = MessageBox.Show(
Resources.strMruFileCouldNotBeFound
, Application.ProductName
, MessageBoxButtons.YesNo
, MessageBoxIcon.Warning);
if (removeRslt == DialogResult.Yes)
{
MruManager.RemoveFile(logFileToLoad);
RebuildMruList();
}
return;
}
LoadFileIntoLogger(logFileToLoad);
}
/// <summary>
/// Flush all "modified" data blocks in cache onto Disk.
/// NOTE: cache fault event will also cause modified data blocks
/// to be saved to disk and Save will only save those "modified ones"
/// that didn't get evicted from cache during said event.
/// </summary>
public virtual void Flush()
{
bool saveIt = false;
bool saveDelayed = DelaySaveBlocks;
if (IsOpen && IsDirty)
{
//RegisterChange();
IsDirty = false;
if (FileStream != null)
{
//** save the collection Item(s) in cache
SaveState |= SaveTypes.CollectionSave;
if (!DelaySaveBlocks)
{
DelaySaveBlocks = MruManager.Count < 20;
}
MruManager.Flush();
SaveState ^= SaveTypes.CollectionSave;
//** save the collection's meta data
WriteToDisk(this, !IsPartOfCollection);
saveIt = true;
AddToBlocks(DiskBuffer, Blocks);
}
}
if (deletedBlocks != null)
{
deletedBlocks.Flush();
}
if (!saveIt)
{
return;
}
DelaySaveBlocks = saveDelayed;
SaveBlocks(false);
}
/// <summary>
/// Initialize helper objects from the DocToolkit Library.
///
/// Called from Form1_Load. Initialized all objects except
/// PersistWindowState wich must be initialized in the
/// form constructor.
/// </summary>
private void InitializeHelperObjects()
{
// DocManager
DocManagerData data = new DocManagerData();
data.FormOwner = this;
data.UpdateTitle = true;
data.FileDialogFilter = "DrawTools files (*.dtl)|*.dtl|All Files (*.*)|*.*";
data.NewDocName = "Untitled.dtl";
data.RegistryPath = registryPath;
docManager = new DocManager(data);
docManager.RegisterFileType("dtl", "dtlfile", "DrawTools File");
docManager.SaveEvent += new SaveEventHandler(docManager_SaveEvent);
docManager.LoadEvent += new LoadEventHandler(docManager_LoadEvent);
docManager.OpenEvent += new OpenFileEventHandler(docManager_OpenEvent);
docManager.DocChangedEvent += new EventHandler(docManager_DocChangedEvent);
docManager.ClearEvent += new EventHandler(docManager_ClearEvent);
docManager.NewDocument();
// DragDropManager
dragDropManager = new DragDropManager(this);
dragDropManager.FileDroppedEvent += new FileDroppedEventHandler(this.dragDropManager_FileDroppedEvent);
// MruManager
mruManager = new MruManager();
mruManager.Initialize(
this, // owner form
menuFileRecentFiles, // Recent Files menu item
registryPath); // Registry path to keep MRU list
mruManager.MruOpenEvent += new MruFileOpenEventHandler(mruManager_MruOpenEvent);
}
System.IO.FileStream IFileStream.Open()
{
MruManager.Add(Id, this);
return(SystemAdaptor.Instance.SystemInterface.UnbufferedOpen(_path, _mode, _access, _share,
_sequential, _async, _blockSize));
}
/// <summary>
/// Initialize MRU list
/// </summary>
void InitializeMruList()
{
mruManager = new MruManager(SettingsManager.ApplicationSettings.RecentFilesList, menuFileRecentFiles);
mruManager.FileSelected += new EventHandler <MruFileOpenEventArgs>(mruManager_FileSelected);
}
//internal override bool RemoveInMemory(long DataAddress, Transaction.ITransactionLogger Transaction)
//{
// if (LastItem != null)
// LastItem.Clear();
// if (FirstItem != null)
// FirstItem.Clear();
// CurrentItem = null;
// base.RemoveInMemory(DataAddress, Transaction);
// return true;
//}
private void RemoveAt(long dataAddress, bool willMove)
{
if (willMove && !MoveTo(dataAddress))
{
return;
}
if (IsDeletedBlocksList && Count == 1)
{
return;
}
Sop.DataBlock currBlock = this.GetCurrentDataBlock(true);
if (FirstItem.DiskBuffer.DataAddress == dataAddress)
{
MoveFirst();
if (MoveNext())
{
FirstItem.DiskBuffer.DataAddress = CurrentItem.DiskBuffer.DataAddress;
CurrentItem.PreviousItemAddress = -1;
Sop.DataBlock db = WriteToBlock(CurrentItem, CurrentItem.DiskBuffer);
DataBlockDriver.SetDiskBlock(this, db, false);
}
else
{
long address = FirstItem.DiskBuffer.DataAddress;
FirstItem.DiskBuffer.DataAddress = LastItem.DiskBuffer.DataAddress = -1;
CurrentItem = FirstItem;
Sop.DataBlock db = WriteToBlock(CurrentItem, CurrentItem.DiskBuffer);
db.DataAddress = address;
DataBlockDriver.SetDiskBlock(this, db, false);
db.DataAddress = -1;
}
}
else if (LastItem.DiskBuffer.DataAddress == dataAddress)
{
if (MovePrevious() || FirstItem.DiskBuffer.DataAddress == CurrentItem.DiskBuffer.DataAddress)
{
LastItem.DiskBuffer.DataAddress = CurrentItem.DiskBuffer.DataAddress;
CurrentItem.NextItemAddress = -1;
Sop.DataBlock db = WriteToBlock(CurrentItem, CurrentItem.DiskBuffer);
DataBlockDriver.SetDiskBlock(this, db, false);
}
else
{
throw new InvalidOperationException("Can't go previous but First is not the only item.");
}
}
else
{
LinkedItemOnDisk curr = CurrentItem;
LinkedItemOnDisk prev = null, next = null;
if (MoveTo(curr.PreviousItemAddress))
{
prev = CurrentItem;
}
if (MoveTo(curr.NextItemAddress))
{
next = CurrentItem;
}
if (prev != null && next != null)
{
prev.NextItemAddress = curr.NextItemAddress;
next.PreviousItemAddress = curr.PreviousItemAddress;
Sop.DataBlock db = WriteToBlock(prev, prev.DiskBuffer);
DataBlockDriver.SetDiskBlock(this, db, false);
db = WriteToBlock(next, next.DiskBuffer);
DataBlockDriver.SetDiskBlock(this, db, false);
}
}
if (MruManager.Count > 0)
{
MruManager.Remove(dataAddress, true);
}
DataBlockDriver.Remove(this, currBlock);
}
private System.IO.FileStream Open()
{
MruManager.Add(Id, this);
return(Win32.UnbufferedOpen(_path, _mode, _access, _share,
_sequential, _async, _blockSize));
}
/// <summary>
/// Initialize. NOTE: this function doesn't open the file.
/// </summary>
/// <param name="file"></param>
/// <param name="parameters"> </param>
protected internal virtual void Initialize(File.IFile file, params KeyValuePair <string, object>[] parameters)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
if (transaction == null ||
(transaction is Transaction.Transaction &&
((Transaction.Transaction)transaction).Server != file.Server))
{
Transaction.ITransactionLogger trans = file.Transaction;
if (trans != null)
{
trans = ((Transaction.TransactionBase)trans).GetLeafChild();
}
if (trans == null ||
trans is Transaction.Transaction)
{
transaction = trans;
}
}
if (string.IsNullOrEmpty(this.Name))
{
var f = new FileInfo(file.Filename);
Name = string.Format("{0} Collection {1}", f.Name, ((Sop.OnDisk.File.File)file).GetNewStoreId());
}
if (MruMinCapacity == 0)
{
MruMinCapacity = file.Profile.MruMinCapacity;
}
if (MruMaxCapacity == 0)
{
MruMaxCapacity = file.Profile.MruMaxCapacity;
}
if (File == null)
{
File = file;
}
if (DataBlockSize == DataBlockSize.Unknown)
{
DataBlockSize = file.DataBlockSize;
}
HeaderData hd = null;
if (parameters != null && parameters.Length > 0)
{
foreach (KeyValuePair <string, object> o in parameters)
{
switch (o.Key)
{
case "HasMruSegments":
break;
case "HeaderData":
hd = (HeaderData)o.Value;
break;
default:
if (o.Key == "DataBlockDriver" && o.Value != null)
{
DataBlockDriver = (IDataBlockDriver)o.Value;
}
break;
}
}
}
if (DataBlockDriver == null)
{
DataBlockDriver = new DataBlockDriver(this, hd);
}
else
{
if (DataBlockDriver.HeaderData == null)
{
DataBlockDriver.HeaderData = hd ?? new HeaderData(DataBlockSize);
}
}
if (MruManager == null)
{
int min = MruMinCapacity;
int max = MruMaxCapacity;
//MruManager = new ConcurrentMruManager(min, max);
MruManager = new MruManager(min, max);
MruManager.SetDataStores(this, DataBlockDriver);
}
if (_diskBuffer == null)
{
_diskBuffer = CreateBlock(); //new Sop.DataBlock(DataBlockSize);
}
}
private void OnMruClearItems(object sender, EventArgs e)
{
MruManager.ClearFiles();
RebuildMruList();
}
/// <summary>
/// Initialize helper objects from the DocToolkit Library.
///
/// Called from Form1_Load. Initialized all objects except
/// PersistWindowState wich must be initialized in the
/// form constructor.
/// </summary>
private void InitializeHelperObjects()
{
// DocManager
DocManagerData data = new DocManagerData();
data.FormOwner = this;
data.UpdateTitle = true;
data.FileDialogFilter = "DrawTools files (*.dtl)|*.dtl|All Files (*.*)|*.*";
data.NewDocName = "Untitled.dtl";
data.RegistryPath = registryPath;
docManager = new DocManager(data);
docManager.RegisterFileType("dtl", "dtlfile", "DrawTools File");
// Subscribe to DocManager events.
docManager.SaveEvent += docManager_SaveEvent;
docManager.LoadEvent += docManager_LoadEvent;
// Make "inline subscription" using anonymous methods.
docManager.OpenEvent += delegate(object sender, OpenFileEventArgs e)
{
// Update MRU List
if (e.Succeeded)
{
mruManager.Add(e.FileName);
}
else
{
mruManager.Remove(e.FileName);
}
};
docManager.DocChangedEvent += delegate(object o, EventArgs e)
{
drawArea.Refresh();
drawArea.ClearHistory();
};
docManager.ClearEvent += delegate(object o, EventArgs e)
{
if (drawArea.GraphicsList != null)
{
drawArea.GraphicsList.Clear();
drawArea.ClearHistory();
drawArea.Refresh();
}
};
docManager.NewDocument();
// DragDropManager
dragDropManager = new DragDropManager(this);
dragDropManager.FileDroppedEvent += delegate(object sender, FileDroppedEventArgs e)
{
OpenDocument(e.FileArray.GetValue(0).ToString());
};
// MruManager
mruManager = new MruManager();
mruManager.Initialize(
this, // owner form
recentFilesToolStripMenuItem, // Recent Files menu item
fileToolStripMenuItem, // parent
registryPath); // Registry path to keep MRU list
mruManager.MruOpenEvent += delegate(object sender, MruFileOpenEventArgs e)
{
OpenDocument(e.FileName);
};
}
private static void MaintainOpenedFileCount(bool closeAll = false)
{
if (MruManager.Count <= MaxInstanceCount)
{
return;
}
lock (MruManager)
{
int ctr = 0;
while (closeAll || MruManager.Count > MruManager.MinCapacity)
{
if (ctr++ >= MruManager.MaxCapacity - 10)
{
Log.Logger.Instance.Verbose("MaintainOpenedFileCount FileStream trimming loop reached {0}, ending trimming...", ctr);
break;
}
Mru.Generic.MruItem <int, FileStream> item = MruManager.PeekInTail();
//if (item.Value.InUse) return;
lock (item.Value._locker)
{
if (MruManager.Count <= MruManager.MinCapacity)
{
if (item.Value._fileStream == null)
{
MruManager.Remove(item.Value.Id);
return;
}
if (item.Value.InUse)
{
return;
}
}
if (item.Value.InUse)
{
item.Value.InUse = true;
continue;
}
//item.Value._streamPosition = item.Value._fileStream.Position;
if (item.Value._fileStream != null || !item.Value._isDisposed)
{
item.Value.InUse = true;
if (item.Value._fileStream != null || !item.Value._isDisposed)
{
try
{
item.Value._fileStream.Flush();
if (item.Value._fileStream != null)
{
item.Value._fileStream.Close();
}
}
catch { }
}
item.Value._fileStream = null;
MruManager.Remove(item.Value.Id);
item.Value.InUse = false;
}
else
{
MruManager.Remove(item.Value.Id);
}
}
}
}
}
