// ========================================================================
// Copyright 2006 - Volian Enterprises, Inc. All rights reserved.          
// Volian Enterprises - Proprietary Information - DO NOT COPY OR DISTRIBUTE
// ------------------------------------------------------------------------
// $Workfile: $     $Revision: $                                           
// $Author: $   $Date: $                                                   
//                                                                         
// $History: $                                                             
// ========================================================================

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Text;
using System.IO;
using System.Xml.Serialization;
using System.Xml;
using System.Xml.XPath;
using System.Text.RegularExpressions;
using System.Data;
using System.Data.SqlClient;
using Csla;
using Csla.Data;
using Volian.Base.Library;

namespace VEPROMS.CSLA.Library
{
	public partial class ROFst
	{
		// put in for debug
		//public static int CacheCountPrimaryKey
		//{ get { return _CacheByPrimaryKey.Count; } }
		//public static int CacheCountByRODbID_DTS
		//{ get { return _CacheByRODbID_DTS.Count; } }
		//public static int CacheCountList
		//{ get { return _CacheList.Count; } }

		//[NonSerialized]
		//private ROFSTLookup _ROFSTLookup;
		//public ROFSTLookup ROFSTLookup
		//{
		//  get
		//  {
		//    if (_ROFSTLookup == null)
		//    {
		//      _ROFSTLookup = new ROFSTLookup(this);
		//    }
		//    return _ROFSTLookup;
		//  }
		//}
		public static ROFst GetJustROFst(int rOFstID)
		{
			if (!CanGetObject())
				throw new System.Security.SecurityException("User not authorized to view a ROFst");
			try
			{
				ROFst tmp = GetCachedByPrimaryKey(rOFstID);
				if (tmp == null)
				{
					tmp = DataPortal.Fetch<ROFst>(new PKCriteriaJustROFst(rOFstID));
					AddToCache(tmp);
				}
				if (tmp.ErrorMessage == "No Record Found")
				{
					tmp.Dispose(); // Clean-up ROFst
					tmp = null;
				}
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on ROFst.Get", ex);
			}
		}
		[Serializable()]
		protected class PKCriteriaJustROFst
		{
			private int _ROFstID;
			public int ROFstID
			{ get { return _ROFstID; } }
			public PKCriteriaJustROFst(int rOFstID)
			{
				_ROFstID = rOFstID;
			}
		}
		private void DataPortal_Fetch(PKCriteriaJustROFst criteria)
		{
			if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] ROFst.DataPortal_Fetch", GetHashCode());
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					ApplicationContext.LocalContext["cn"] = cn;
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandText = "getJustROFst";
						cm.Parameters.AddWithValue("@ROFstID", criteria.ROFstID);
						cm.CommandTimeout = Database.DefaultTimeout;
						using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
						{
							if (!dr.Read())
							{
								_ErrorMessage = "No Record Found";
								return;
							}
							ReadData(dr);
							// load child objects
							//dr.NextResult();
							//_ROFstAssociations = ROFstAssociations.Get(dr);
							// load child objects
							//dr.NextResult();
							//_ROFstFigures = ROFstFigures.Get(dr);
						}
					}
					// removing of item only needed for local data portal
					if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client)
						ApplicationContext.LocalContext.Remove("cn");
				}
			}
			catch (Exception ex)
			{
				if (_MyLog.IsErrorEnabled) _MyLog.Error("ROFst.DataPortal_Fetch", ex);
				_ErrorMessage = ex.Message;
				throw new DbCslaException("ROFst.DataPortal_Fetch", ex);
			}
		}

	}
	public delegate List<string> ROFstInfoROTableUpdateEvent(object sender, ROFstInfoROTableUpdateEventArgs args);
	public delegate void ROFstInfoProgressBarRefresh(int value, int max, string text);
	public partial class ROFstInfo
	{
		// put in for debug
		//public static int CacheCountPrimaryKey
		//{ get { return _CacheByPrimaryKey.Count; } }
		//public static int CacheCountList
		//{ get { return _CacheList.Count; } }
		#region Log4Net
        private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
        #endregion
		#region PropertiesAndData
//    private DocVersionInfo _docVer;
//    public DocVersionInfo docVer
//    {
//      get 
//      {
//        if (_docVer == null)
//        {
//          if (ROFstAssociations.Count == 0) return null;
////					_docVer = DocVersion.Get(this.ROFstAssociations[0].MyDocVersion.VersionID);
//          _docVer = this.ROFstAssociations[0].MyDocVersion;
//        }
//        return _docVer;
//      }
//      set
//      {
//        _docVer = value;
				
//      }
//    }
		//[NonSerialized]
		//private ROFSTLookup _ROFSTLookup;
		//public ROFSTLookup ROFSTLookup
		//{
		//  get
		//  {
		//    if (_ROFSTLookup == null)
		//    {
		//      _ROFSTLookup = new ROFSTLookup(this);
		//    }
		//    return _ROFSTLookup;
		//  }
		//}
		private Dictionary<string, ROFSTLookup> dicLookups = new Dictionary<string, ROFSTLookup>();
		public ROFSTLookup GetROFSTLookup(DocVersionInfo dvi)
		{
			//string key = string.Format("{0}.{1}",dvi.DocVersionAssociations[0].ROFstID,dvi.DocVersionConfig.SelectedSlave);
			string key = string.Format("{0}.{1}.{2}", ROFstID, dvi.DocVersionConfig.MaxSlaveIndex,  dvi.DocVersionConfig.SelectedSlave);
			if (!dicLookups.ContainsKey(key))
				dicLookups.Add(key, new ROFSTLookup(this, dvi));
			return dicLookups[key];
		}
		#endregion
		#region AppSupport
		//public static ROImageInfo Get(RODbInfo rodbinfo, string filename)
		//{
		//    if (rodbinfo.RODbROImageCount != 0)
		//    {
		//        foreach (ROImageInfo ri in rodbinfo.RODbROImages)
		//        {
		//            if (ri.FileName == filename) return ri;
		//        }
		//    }
		//    return null;
		//}
		//public string GetDefaultROPrefix()
		//{
		//  if (docVer != null)
		//    return docVer.DocVersionConfig.RODefaults_setpointprefix;
		//  else
		//    return "SP1"; // Not Sure about this...
		//}
		//public string GetDefaultGraphicsPrefix()
		//{
		//  if (docVer != null)
		//    return docVer.DocVersionConfig.RODefaults_graphicsprefix;
		//  else
		//    return "IG1"; // Not Sure about this...
		//}
		#region Add New Ro Fst
		/// <summary>
		/// Adds an ro.fst into a sql database.  
		/// </summary>
		/// <param name="rdi" - the Rodb to use as the path for updating the ro.fst, i.e.
		///              import from there.
		/// <param name="docver" - hook into this doc version></param>
		/// <returns>ROFst: Returns the created rofst object</returns>
		public static ROFst AddRoFst(RODbInfo rdi, DocVersion docver, ROFstInfoProgressBarRefresh myProgressBarRefresh)
		{
			string rofstfilepath = rdi.FolderPath + @"\ro.fst";
			DirectoryInfo di = new DirectoryInfo(rdi.FolderPath);
			if (!di.Exists) return null;
			if (!File.Exists(rofstfilepath)) return null;

			// check if this rofst has been loaded, i.e. dts on file versus dts in db...
			// if so, just make association with docversion.
			ROFst rofst = ROFst.GetByRODbID_DTS(rdi.RODbID, di.LastWriteTimeUtc);
			if (rofst != null)
			{
				docver.DocVersionAssociations.Add(rofst);
				docver.Save();
				return rofst;
			}

			// Next read in the rofst & make the rofst record.
			FileStream fsIn = new FileStream(rofstfilepath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
			// Create an instance of StreamReader that can read characters from the FileStream.
			BinaryReader r = new BinaryReader(fsIn);
			byte[] ab = r.ReadBytes((int)fsIn.Length);
			fsIn.Close();

			using (RODb rodb = RODb.GetJustRoDb(rdi.RODbID))
			{
				using (ROImageInfoList myROImages = ROImageInfoList.GetByRODbID(rdi.RODbID))
				{
					Dictionary<string, int> myExistingROImages = BuildROImagesList(myROImages);
					List<int> myUnChangedROImages = new List<int>();
					List<string> myAddedROImages = new List<string>();
					List<string> MyChangedFigureROIDs = new List<string>();
					rofst = ROFst.MakeROFst(rodb, ab, null, di.LastWriteTimeUtc, rdi.UserID);
					// Hook this into the current docversion by replacing the rofstid field in the doc version
					// association object:
					docver.DocVersionAssociations.Add(rofst);
					docver.Save();
					ROFSTLookup myLookup = ROFstInfo.GetJustROFst(rofst.ROFstID).GetROFSTLookup(DocVersionInfo.Get(docver.VersionID));
					// Now load any images in... type 8 - integrated graphics ro type
					for (int i = 0; i < myLookup.myHdr.myDbs.Length; i++)
					{
						// walk through the rofst 'database' searching for all nodes that are integrated graphics, type 8:
						if (myLookup.myHdr.myDbs[i].children != null)
						{
							using (ROFstInfo rfi = ROFstInfo.Get(rofst.ROFstID))
							{
								int cnt = rfi.CountRoFstGraphics(myLookup.myHdr.myDbs[i].children); // get the total number of RO figures
								int curCnt = 0;
								rfi.MigrateRoFstGraphics(rdi, myLookup.myHdr.myDbs[i].children, rodb, rofst, myExistingROImages, myUnChangedROImages, myAddedROImages, MyChangedFigureROIDs, myProgressBarRefresh, cnt, ref curCnt);// TODO: Need to add MyImages
							}
						}
					}
					if (myUnChangedROImages.Count > 0)
						using (FigureInfoList fil = FigureInfoList.AddByROFstIDImageIDs(rofst.ROFstID, buildImageIDString(myUnChangedROImages))) ;
					return rofst;
				}
			}
		}
		#endregion
		#region Update Ro Values
		public static int RefreshROFst(DocVersionInfo dvi, ROFstInfoProgressBarRefresh myProgressBarRefresh, System.Windows.Forms.TextBox tbStatus)
		{
			int fixedROs = 0;
			if (dvi.DocVersionConfig.SelectedSlave <= 0)
			{
				myProgressBarRefresh(1, 100, "Update MS Word ROs");
				Pdf.DeleteAllDocVersion(dvi.VersionID); // remove word section PDFs to force upate of RO values when printed
				int i = 0;
				foreach (ProcedureInfo proc in dvi.Procedures)
				{
					DateTime start = DateTime.Now;
					ProcedureInfo.ResetROCounters();
					myProgressBarRefresh(++i, dvi.Procedures.Count, string.Format("{0} ({1}/{2} ROs {3})",proc.DisplayNumber,i,dvi.Procedures.Count,fixedROs));
					ProcedureInfo.RefreshReferenceObjects(proc);
					fixedROs += ProcedureInfo.ROFixCount;
					TimeSpan ts = DateTime.Now - start;
					if (tbStatus != null)
						tbStatus.AppendText(string.Format("Procedure:  {1}{0}, Checked {2} Referenced Objects{0}, Fixed {3} Referenced Objects{0}, Elapsed Seconds:{4}{0}{0}", Environment.NewLine, proc.DisplayNumber, ProcedureInfo.ROCheckCount, ProcedureInfo.ROFixCount, ts.TotalSeconds));
			}
			}
			return fixedROs;
		}
		// returns the path and file name with Proc Set Name and the completed date/time (used for all update RO calls except for Amin Tool from the V button)
	public static string ROUpdateResultsPath (DocVersionInfo dvi)
	{
		return Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + @"\VEPROMS\ROUpdateReport_" + dvi.MyFolder.Name.Replace(" ", "_") + "_" + DateTime.Now.ToString("MM-dd-yyyy_HH-mm-ss") +".txt";
	}
		public static ROFst RefreshROFst(RODbInfo rdi, DocVersionAssociation dva, DocVersion docver, ROFstInfo origROFst, ROFstInfoProgressBarRefresh myProgressBarRefresh, System.Windows.Forms.TextBox tbStatus)
		{
			ROFst rofst = null;
			if (docver.ROfstLoadingFigures || docver.NewerRoFst)    // B2017-125 see if loading figures was completed
			{
				// only load the RO.fst
				Volian.Base.Library.VlnSettings.DoUpdateRO = false;
				rofst = ROFstInfo.UpdateRoFst(rdi, dva, docver, origROFst, myProgressBarRefresh);
				Volian.Base.Library.VlnSettings.DoUpdateRO = true;
			}
			else
				rofst = docver.DocVersionAssociations[0].MyROFst;
			DocVersionInfo dvi = DocVersionInfo.Get(docver.VersionID);			
			SetAssociationLastCompleted(docver,string.Empty);
			int fixedROs = RefreshROFst(dvi, myProgressBarRefresh, tbStatus);
			SetAssociationLastCompleted(docver, DateTime.Now.ToString());  // RO Update completed successfully and un-interrupted, save the date/time to the Doc Version Association config
			myProgressBarRefresh(100, 100, "RO Update Complete"); // update the progress bar
			System.Windows.Forms.Application.DoEvents();
			// pop up a message window telling the user the RO Update has completed and now many ROs were updated
			// If we are updating RO from the Admin Tools (from the V button) and we are updating more than on procedure set, then just append the "RO Update Complete" text
			// To the MessageList.  Once completed will all procedure sets, Admin Tools will display one message box with all the results in it.
			if (MessageList == null)
				System.Windows.Forms.MessageBox.Show(fixedROs == 0 ? "No ROs Required Updating" : string.Format("{0} ROs Updated for {1}", fixedROs, dvi.MyFolder.Name), "RO Update Complete");
			else
				MessageList.AppendLine((fixedROs == 0 ? "No ROs Required Updating for " : string.Format("{0} ROs Updated for ", fixedROs)) + dvi.MyFolder.Name);
	
			return rofst;
		}

		// this is used by the frmBatchRefresh which is the Adim Tools so that one message is display for a group of procedure sets processed
		public static StringBuilder MessageList = null;

		// Place the date/time of the completed RO Update in the DocVersion association config
		// this witll tell us if the RO Update was completed, interrupted, or just needs done and whether to make the Update ROs button available
		private static void SetAssociationLastCompleted(DocVersion docver, string value)
		{
			string cfg = docver.DocVersionAssociations[0].Config;
			AssociationConfig ac = new AssociationConfig((cfg== null || cfg.Length == 0) ? "<Config />" : cfg);
			ac.ROUpdate_LastCompleted = value;
			docver.DocVersionAssociations[0].Config = ac.ToString();
			docver.Save();
		}
		// Place the status of loading the RO Figures when updating RO Values
		private static void SetAssociationROFiguresLoading(DocVersion docver, string value)
		{
			string cfg = docver.DocVersionAssociations[0].Config;
			AssociationConfig ac = new AssociationConfig((cfg== null || cfg.Length == 0) ? "<Config />" : cfg);
			ac.ROUpdate_LoadingFigures = value;
			docver.DocVersionAssociations[0].Config = ac.ToString();
			docver.Save();
		}
		/// <summary>
		/// Updates an ro.fst into a sql database.  
		/// </summary>
		/// <param name="rdi" - the Rodb to use as the path for updating the ro.fst, i.e.
		///              import from there.
		/// <param name="dva" - the association record to modify, i.e. make new rofst
		///				  the current one.
		/// <param name="docver" - hook into this doc version></param>
		/// <returns>ROFst: Returns the created rofst object</returns>
		public static ROFst UpdateRoFst(RODbInfo rdi, DocVersionAssociation dva, DocVersion docver, ROFstInfo origROFst, ROFstInfoProgressBarRefresh myProgressBarRefresh)
		{
			if (myProgressBarRefresh != null) myProgressBarRefresh(0, 100, "Starting Update");
			DirectoryInfo di = new DirectoryInfo(rdi.FolderPath);
			string rofstfilepath = rdi.FolderPath + @"\ro.fst";
			FileStream fsIn = new FileStream(rofstfilepath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
			FileInfo rofstFI = new FileInfo(rofstfilepath);
			// check if this rofst has been loaded, i.e. dts on file versus dts in db...
			// if so, just make association to existing with docversion.
			ROFst rofst = ROFst.GetByRODbID_DTS(rdi.RODbID, rofstFI.LastWriteTimeUtc);
			if (rofst != null)
			{
				// Get a list of figures which have changed content (DTS)
				List<string> MyChangedFigureROIDs = null;
				if (docver.ROfstLoadingFigures)    // B2017-125 see if loading figures was completed
				{
					ROFSTLookup myLookup = ROFstInfo.GetJustROFst(rofst.ROFstID).GetROFSTLookup(DocVersionInfo.Get(docver.VersionID));
					MyChangedFigureROIDs = UpdateROFigures(rdi, myProgressBarRefresh, rofst, RODb.GetJustRoDb(rdi.RODbID), myLookup, docver);
				}
				else
					MyChangedFigureROIDs = GetChangedFigureROIDs(origROFst, ROFstInfo.GetJustROFst(rofst.ROFstID), DocVersionInfo.Get(docver.VersionID), myProgressBarRefresh);
				docver.DocVersionAssociations[0].MyROFst = rofst;
				SetAssociationLastCompleted(docver, string.Empty);
				if (!Volian.Base.Library.VlnSettings.GetCommandFlag("NOUPDATERO") && Volian.Base.Library.VlnSettings.DoUpdateRO)
					UpdateROValuesText(origROFst, rofst, DocVersionInfo.Get(docver.VersionID), myProgressBarRefresh, MyChangedFigureROIDs);
				return rofst;
			}
			
			// Read in the rofst & make the rofst record.
			// Create an instance of StreamReader that can read characters from the FileStream.
			BinaryReader r = new BinaryReader(fsIn);
			byte[] ab = r.ReadBytes((int)fsIn.Length);
			fsIn.Close();
			using (RODb rodb = RODb.GetJustRoDb(rdi.RODbID))
			{
				rofst = ROFst.MakeROFst(rodb, ab, null, rofstFI.LastWriteTimeUtc, rdi.UserID);
				// Hook this into the current docversion by replacing the rofstid field in the doc version
				// association object:
				dva.MyROFst = rofst;
				SetAssociationROFiguresLoading(docver, "Started");   // B2017-125 flag was we are loading the RO figures
				//docver.Save();
				ROFSTLookup myLookup = ROFstInfo.GetJustROFst(rofst.ROFstID).GetROFSTLookup(DocVersionInfo.Get(docver.VersionID));
				// Keep a list of ROIDs for Images that have changed.
				List<string> MyChangedFigureROIDs = UpdateROFigures(rdi, myProgressBarRefresh, rofst, rodb, myLookup,docver);
				// Now update the usages: compare old to new rofsts and update usages accordingly, i.e. modified
				// values, deleted ros, etc.
				if (!Volian.Base.Library.VlnSettings.GetCommandFlag("NOUPDATERO") && Volian.Base.Library.VlnSettings.DoUpdateRO)
				UpdateROValuesText(origROFst, rofst, DocVersionInfo.Get(docver.VersionID),myProgressBarRefresh, MyChangedFigureROIDs);
				return rofst;
			}
		}

		private static List<string> UpdateROFigures(RODbInfo rdi, ROFstInfoProgressBarRefresh myProgressBarRefresh, ROFst rofst, RODb rodb, ROFSTLookup myLookup, DocVersion docVer)
		{
			List<string> MyChangedFigureROIDs = new List<string>();
			// Now load any images in... type 8 - integrated graphics ro type
			using (ROImageInfoList myROImages = ROImageInfoList.GetByRODbIDNoData(rdi.RODbID))
			{
				Dictionary<string, int> myExistingROImages = BuildROImagesList(myROImages);
				List<int> myUnChangedROImages = new List<int>();
				List<string> myAddedROImages = new List<string>();
				using (ROFstInfo rfi = ROFstInfo.Get(rofst.ROFstID))
				{
					for (int i = 0; i < myLookup.myHdr.myDbs.Length; i++)
					{
						// walk through the rofst 'database' searching for all nodes that are integrated graphics, type 8:
						if (myLookup.myHdr.myDbs[i].children != null)
						{
							int cnt = rfi.CountRoFstGraphics(myLookup.myHdr.myDbs[i].children); // get the total number of RO figures
							int curCnt = 0;
							rfi.MigrateRoFstGraphics(rdi, myLookup.myHdr.myDbs[i].children, rodb, rofst, myExistingROImages, myUnChangedROImages, myAddedROImages, MyChangedFigureROIDs, myProgressBarRefresh, cnt, ref curCnt);
						}
					}
				}
				// Add references for existing RO Images to the Figure table (Figure table relates ro.fst with its images)
				if (myUnChangedROImages.Count > 0)
					using (FigureInfoList fil = FigureInfoList.AddByROFstIDImageIDs(rofst.ROFstID, buildImageIDString(myUnChangedROImages))) ;
			}
			SetAssociationROFiguresLoading(docVer, string.Empty);   // B2017-125 loading RO Figures is completed
			return MyChangedFigureROIDs;
		}
		/// <summary>
		/// Get a list of ROIDs for figures that have changed content.  This is only used when the contents of a figure
		/// is changed without changing the filename.
		/// </summary>
		/// <param name="origROFst">Original ROFST Object</param>
		/// <param name="rofst">Current ROFST Object</param>
		/// <param name="docver">DocVersion (Working Draft)</param>
		/// <returns>List of ROIDs which can be used to refresh MSWord PDFs</returns>
		private static List<string> GetChangedFigureROIDs(ROFstInfo origROFst, ROFstInfo rofst, DocVersionInfo docver, ROFstInfoProgressBarRefresh myProgressBarRefresh)
		{
			// Need to create a list of ROIDs for figures which have changed
			List<string> ChangedFiles = GetChangedFigures(origROFst, rofst, myProgressBarRefresh);
			// Get ROID associated with FileNames
			List<string> ROIDs = GetROIDsFromLookup(rofst,ChangedFiles,docver);
			return ROIDs;
		}
		/// <summary>
		/// Find all of the ROIDs associated with files that have changed
		/// </summary>
		/// <param name="rofst">Current ROFST Object</param>
		/// <param name="ChangedFiles">List of Changed Files</param>
		/// <param name="docver">DocVersion (Working Draft)</param>
		/// <returns>List of FIleNames with changed content</returns>
		private static List<string> GetROIDsFromLookup(ROFstInfo rofst, List<string> ChangedFiles, DocVersionInfo docver)
		{
			List<string> roids = new List<string>();
			ROFSTLookup myLookup = rofst.GetROFSTLookup(docver);
			for (int i = 0; i < myLookup.myHdr.myDbs.Length; i++)
			{
				if (myLookup.myHdr.myDbs[i].children != null)
				{
					FindChangedFiles(myLookup.myHdr.myDbs[i].children,ChangedFiles,roids);
				}
			}
			return roids;
		}
		/// <summary>
		/// Find the ROIDs in the ROLookup
		/// </summary>
		/// <param name="rochild">an RO or RO Group</param>
		/// <param name="ChangedFiles">List of Files that have changed</param>
		/// <param name="roids">List of ROIDs with changed figures</param>
		private static void FindChangedFiles(ROFSTLookup.rochild[] rochild,List<string> ChangedFiles, List<string> roids)
		{
			if (ChangedFiles != null)
			{
				for (int i = 0; i < rochild.Length; i++)
				{
					if (rochild[i].type == 8 && rochild[i].value != null)
					{
						string filename = rochild[i].value;
						filename = filename.Substring(0, filename.IndexOf('\n'));
						if (ChangedFiles.Contains(filename))
							roids.Add(rochild[i].roid);
					}
					if (rochild[i].children != null) FindChangedFiles(rochild[i].children, ChangedFiles, roids);
				}
			}
		}
		/// <summary>
		/// Get a List of figures which have changed
		/// </summary>
		/// <param name="origROFst">Original ROFST Object</param>
		/// <param name="rofst">Current ROFST Object</param>
		/// <returns>List of Files which have changed (DTS)</returns>
		private static List<string> GetChangedFigures(ROFstInfo origROFst, ROFstInfo rofst, ROFstInfoProgressBarRefresh myProgressBarRefresh)
		{
			if (origROFst.ROFstFigures == null) return null;
			Dictionary<string,int> orig = new Dictionary<string,int>();
			int i = 0;
			foreach (FigureInfo fi in origROFst.ROFstFigures)
			{
				string key = fi.ROImage_FileName ?? fi.MyROImage.FileName;
				myProgressBarRefresh(++i, origROFst.ROFstFigures.Count, "Original " + key);
				if (!orig.ContainsKey(key)) orig.Add(key, fi.ImageID);
			}
			i = 0;
			foreach (FigureInfo fi in rofst.ROFstFigures)
			{
				string key = fi.ROImage_FileName ?? fi.MyROImage.FileName;
				myProgressBarRefresh(++i, rofst.ROFstFigures.Count, "Current " + key);
				if (orig.ContainsKey(key) && orig[key] == fi.ImageID)
					orig.Remove(key);
			}
			List<string> changedFigures = new List<string>();
			i = 0;
			foreach (string key in orig.Keys)
			{
				myProgressBarRefresh(++i, orig.Count, "Compare " + key);
				changedFigures.Add(key);
			}
			return changedFigures;
		}
		private static Dictionary<string,int> BuildROImagesList(ROImageInfoList myROImages)
		{
			Dictionary<string,int> myRoImagesList = new Dictionary<string,int>();
			foreach (ROImageInfo myROImage in myROImages)
				myRoImagesList.Add(ROImageKey(myROImage.FileName, myROImage.DTS),myROImage.ImageID);
			return myRoImagesList;
		}
		private static string ROImageKey(string fileName, DateTime dts)
		{
			return string.Format("{0}:{1}", fileName, dts);
		}
		private static string buildImageIDString(List<int> myROImageIDs)
		{
			StringBuilder sb = new StringBuilder();
			string sep = "";
			foreach (int imageID in myROImageIDs)
			{
				sb.Append(sep + imageID.ToString());
				sep = ",";
			}
			return sb.ToString();
		}
		private static void UpdateROValuesText(ROFstInfo origROFstInfo, ROFst newROFst, DocVersionInfo dvi, ROFstInfoProgressBarRefresh myProgressBarRefresh, List<string> MyChangedFigureROIDs)
		{
			if (myProgressBarRefresh != null) myProgressBarRefresh(0, 100, "Update Ro Values");
			string versionList = dvi.VersionID.ToString();
			//DateTime dtStart = DateTime.Now;
			//DateTime dtLast = DateTime.Now;
			ROFSTLookup origLU = new ROFSTLookup(origROFstInfo, dvi);
			//dtLast = ShowDuration(dtLast, "origLU");
			ROFSTLookup newLU = new ROFSTLookup(newROFst, dvi);
			//dtLast = ShowDuration(dtLast, "newLU");
			List<string> delList = new List<string>();
			List<string> chgList = newLU.GetValueDifferences(origLU, ref delList);
			// Any figures which have been changed will be included in the list of values that have changed.
			if (MyChangedFigureROIDs != null)
			foreach (string roid in MyChangedFigureROIDs)
				if (!chgList.Contains(roid))
					chgList.Add(roid);
			//dtLast = ShowDuration(dtLast, "chgList");
			string RoidList = GetRoidList(newROFst.RODbID, chgList);
			//dtLast = ShowDuration(dtLast, "RoidList");
			if (myProgressBarRefresh != null) myProgressBarRefresh(0, chgList.Count, "Getting List of ROs Used");
			List<string> activeRoids = BuildActiveROIDsForRoUsages12(RoidList, versionList);
			//dtLast = ShowDuration(dtLast, "activeRoids");
			if (myProgressBarRefresh != null) myProgressBarRefresh(0, chgList.Count, "Updating RO Values");
			int iCount = 0;
			if (activeRoids.Count > 0)
			{
				foreach (string chg in chgList)
				{
					if (myProgressBarRefresh != null) myProgressBarRefresh(++iCount, chgList.Count, "Updating RO Values");
					if (activeRoids.Contains(chg.Substring(0, 12)))
					{
						ROFSTLookup.rochild roch = newLU.GetRoChild(chg);
						string desc = string.Format("Change in RO Values: Old value = {0}, New value = {1}", origLU.GetRoValue(chg), roch.value);
						// roid's are stored in database as 16 characters long in the rousages table.  They may be stored 
						// as 12 characters in the ro.fst.
						string padroid = chg.Length <= 12 ? chg + "0000" : chg;
						using (RoUsageInfoList affected = RoUsageInfoList.GetAffected(origROFstInfo.MyRODb.RODbID, padroid, desc, "Changed", versionList))
						{
							foreach (RoUsageInfo roUsg in affected)
							{
								using (Content content = Content.Get(roUsg.MyContent.ContentID))
								{
									foreach (ItemInfo ii in roUsg.MyContent.ContentItems)
									{
										string val = newLU.GetTranslatedRoValue(padroid, ii.ActiveFormat.PlantFormat.FormatData.SectData.ConvertCaretToDelta);
										content.FixContentText(roUsg, val, roch.type, origROFstInfo, true);
										if (content.IsDirty)
										{
											// Update UserID and DTS when RO Value is updated.
											content.UserID = Volian.Base.Library.VlnSettings.UserID;
											content.DTS = DateTime.Now;
											content.Save();
											if (content.MyGrid != null)
												GridInfo.Refresh(content.MyGrid);
										}
									}
								}
							}
						}
					}
				}
			}
			//dtLast = ShowDuration(dtLast, "chg loop");
			if (myProgressBarRefresh != null) myProgressBarRefresh(0, chgList.Count, "Getting List of ROs Used");
			List<string> activeDRoids = BuildActiveROIDsForDRoUsages12(RoidList, versionList);
			//dtLast = ShowDuration(dtLast, "activeRoids Doc");
			iCount = 0;
			if (activeDRoids.Count > 0)
			{
				foreach (string chg in chgList)
				{
					string padroid = chg.Length <= 12 ? chg + "0000" : chg;
					if (myProgressBarRefresh != null) myProgressBarRefresh(++iCount, chgList.Count, "Updating RO Values");
					if (activeDRoids.Contains(chg.Substring(0, 12)))
					{
						ROFSTLookup.rochild roch = newLU.GetRoChild(chg);
						string desc = string.Format("Change in RO Values: Old value = {0}, New value = {1}", origLU.GetRoValue(chg), roch.value);
						// roid's are stored in database as 16 characters long in the rousages table.  They may be stored 
						// as 12 characters in the ro.fst.
						using (DROUsageInfoList affected = DROUsageInfoList.GetAffected(origROFstInfo.MyRODb.RODbID, padroid, desc, "Changed", versionList))
						{
							foreach (DROUsageInfo droUsg in affected)
							{
								Pdf.DeleteAll(droUsg.DocID);
							}
						}
					}
				}
			}
			iCount = 0;
			string RoidDelList = GetRoidList(newROFst.RODbID, delList);
			if (myProgressBarRefresh != null) myProgressBarRefresh(0, chgList.Count, "Getting List of ROs Used");
			activeRoids = BuildActiveROIDsForRoUsages12(RoidDelList, versionList);
			if (activeRoids.Count > 0)
			{
				foreach (string del in delList)
				{
					string padroiddel = del.Length <= 12 ? del + "0000" : del;
					if (myProgressBarRefresh != null) myProgressBarRefresh(++iCount, chgList.Count, "Removing Old RO Values");
					string desc = string.Format("Deleted RO: Value = {0}", origLU.GetRoValue(del));
					if (activeRoids.Contains(del.Substring(0, 12).ToUpper()))
					{
						using (RoUsageInfoList affected = RoUsageInfoList.GetAffected(origROFstInfo.MyRODb.RODbID, padroiddel, desc, "Deleted", versionList))
						{
							foreach (RoUsageInfo roUsg in affected)
							{
								using (Content content = Content.Get(roUsg.MyContent.ContentID))
								{
									content.FixContentText(roUsg, "?", 0, origROFstInfo);
									if (content.IsDirty)
									{
										// Update UserID and DTS when RO Value is updated.
										content.UserID = Volian.Base.Library.VlnSettings.UserID;
										content.DTS = DateTime.Now;
										content.Save();
									}
								}
							}
						}
					}
				}
			}
			if (myProgressBarRefresh != null) myProgressBarRefresh(0, chgList.Count, "Getting List of ROs Used");
			activeDRoids = BuildActiveROIDsForDRoUsages12(RoidDelList, versionList);
			iCount = 0;
			if (activeDRoids.Count > 0)
			{
				foreach (string del in delList)
				{
					string padroiddel = del.Length <= 12 ? del + "0000" : del;
					string desc = string.Format("Deleted RO: Value = {0}", origLU.GetRoValue(del));
					if (activeDRoids.Contains(del.Substring(0, 12).ToUpper()))
					{
						using (DROUsageInfoList Daffected = DROUsageInfoList.GetAffected(origROFstInfo.MyRODb.RODbID, padroiddel, desc, "Deleted", versionList))
						{
							foreach (DROUsageInfo droUsg in Daffected)
							{
								if (myProgressBarRefresh != null) myProgressBarRefresh(++iCount, chgList.Count, "Removing Old RO Values");
								Pdf.DeleteAll(droUsg.DocID);
							}
						}
					}
				}
			}
 			if (myProgressBarRefresh != null) myProgressBarRefresh(100,100, "RO Values Updated");
		}

		private static DateTime ShowDuration(DateTime dtLast, string message)
		{
			DateTime dtNext = DateTime.Now;
			Console.WriteLine("{0,10:#####0.00},'{1}'", TimeSpan.FromTicks(dtNext.Ticks - dtLast.Ticks).TotalSeconds, message);
			return dtNext;
		}
		private static List<string> BuildActiveROIDsForRoUsages(string RoidList)
		{
			List<string> activeRoids = new List<string>();
			using (RoUsageInfoList activeList = RoUsageInfoList.GetROUSagesByROIDs(RoidList))
			{
				foreach (RoUsageInfo roui in activeList)
				{
					string roid = roui.ROID.ToUpper();
					if (roid.EndsWith("0000")) roid = roid.Substring(0, 12);
					if (!activeRoids.Contains(roid))
						activeRoids.Add(roid);
				}
			}
			return activeRoids;
		}
		private static List<string> BuildActiveROIDsForRoUsages(string RoidList,string versions)
		{
			List<string> activeRoids = new List<string>();
			using (RoUsageInfoList activeList = RoUsageInfoList.GetROUSagesByROIDsAndVersions(RoidList,versions))
			{
				foreach (RoUsageInfo roui in activeList)
				{
					string roid = roui.ROID.ToUpper();
					if (roid.EndsWith("0000")) roid = roid.Substring(0, 12);
					if (!activeRoids.Contains(roid))
						activeRoids.Add(roid);
				}
			}
			return activeRoids;
		}
		private static List<string> BuildActiveROIDsForRoUsages12(string RoidList)
		{
			List<string> activeRoids = new List<string>();
			using (RoUsageInfoList activeList = RoUsageInfoList.GetROUSagesByROIDs(RoidList))
			{
				foreach (RoUsageInfo roui in activeList)
				{
					string roid = roui.ROID.ToUpper().Substring(0, 12);
					if (!activeRoids.Contains(roid))
						activeRoids.Add(roid);
				}
			}
			return activeRoids;
		}
		private static List<string> BuildActiveROIDsForRoUsages12(string RoidList, string versions)
		{
			List<string> activeRoids = new List<string>();
			using (RoUsageInfoList activeList = RoUsageInfoList.GetROUSagesByROIDsAndVersions(RoidList, versions))
			{
				foreach (RoUsageInfo roui in activeList)
				{
					string roid = roui.ROID.ToUpper().Substring(0, 12);
					if (!activeRoids.Contains(roid))
						activeRoids.Add(roid);
				}
			}
			return activeRoids;
		}
		private static List<string> BuildActiveROIDsForDRoUsages(string RoidList)
		{
			List<string> activeRoids = new List<string>();
			using (DROUsageInfoList activeList = DROUsageInfoList.GetDROUsagesByROIDs(RoidList))
			{
				foreach (DROUsageInfo roui in activeList)
				{
					string roid = roui.ROID;
					if (roid.EndsWith("0000")) roid = roid.Substring(0, 12);
					if (!activeRoids.Contains(roid))
						activeRoids.Add(roid);
				}
			}
			return activeRoids;
		}
		private static List<string> BuildActiveROIDsForDRoUsages(string RoidList,string versions)
		{
			List<string> activeRoids = new List<string>();
			using (DROUsageInfoList activeList = DROUsageInfoList.GetDROUsagesByROIDsAndVersions(RoidList,versions))
			{
				foreach (DROUsageInfo roui in activeList)
				{
					string roid = roui.ROID;
					if (roid.EndsWith("0000")) roid = roid.Substring(0, 12);
					if (!activeRoids.Contains(roid))
						activeRoids.Add(roid);
				}
			}
			return activeRoids;
		}
		private static List<string> BuildActiveROIDsForDRoUsages12(string RoidList)
		{
			List<string> activeRoids = new List<string>();
			using (DROUsageInfoList activeList = DROUsageInfoList.GetDROUsagesByROIDs(RoidList))
			{
				foreach (DROUsageInfo roui in activeList)
				{
					string roid = roui.ROID.Substring(0, 12);
					if (!activeRoids.Contains(roid))
						activeRoids.Add(roid);
				}
			}
			return activeRoids;
		}
		private static List<string> BuildActiveROIDsForDRoUsages12(string RoidList, string versions)
		{
			List<string> activeRoids = new List<string>();
			using (DROUsageInfoList activeList = DROUsageInfoList.GetDROUsagesByROIDsAndVersions(RoidList, versions))
			{
				foreach (DROUsageInfo roui in activeList)
				{
					string roid = roui.ROID.Substring(0, 12);
					if (!activeRoids.Contains(roid))
						activeRoids.Add(roid);
				}
			}
			return activeRoids;
		}
		private static string GetRoidList(int dbid, List<string> chgList)
		{
			StringBuilder sb = new StringBuilder(string.Format("{0}", dbid));
			string sep=":";
			foreach (string roid in chgList)
			{
				sb.Append(sep + roid);
				sep = ",";
			}
			return sb.ToString();
		}
		private static string NewROName(string roName)
		{
			string retval = roName;
			int iSuffix = -1;
			RODbInfoList rodblist = RODbInfoList.Get();


			foreach (RODbInfo rdi in rodblist)
			{
				if (rdi.ROName.StartsWith(roName))
				{
					if (rdi.ROName == roName)
						iSuffix = 0;
					else if (Regex.IsMatch(rdi.ROName, roName + "[_][0-9]+"))
					{
						int ii = int.Parse(rdi.ROName.Substring(1 + roName.Length));
						if (ii > iSuffix) iSuffix = ii;
					}
				}
			}
			if (iSuffix >= 0)
				retval = string.Format("{0}_{1}", roName, iSuffix + 1);
			return retval;
		}
		private void MigrateRoFstGraphics(RODbInfo rdi, ROFSTLookup.rochild[] rochild, RODb rodb, ROFst rofst, Dictionary<string, int> myExistingROImages, List<int> myUnChangedROImages, List<string> myAddedROImages, List<string> MyChangedFigureROIDs, ROFstInfoProgressBarRefresh myProgressBarRefresh, int cnt, ref int curCnt)
		{
			for (int i = 0; i < rochild.Length; i++)
			{
				if (rochild[i].type == 8)
				{
					this.AddGraphic(rdi, rochild[i], rodb, rofst, myExistingROImages, myUnChangedROImages, myAddedROImages, MyChangedFigureROIDs, myProgressBarRefresh, cnt, curCnt);
					curCnt++;
				}
				if (rochild[i].children != null) this.MigrateRoFstGraphics(rdi, rochild[i].children, rodb, rofst, myExistingROImages, myUnChangedROImages, myAddedROImages, MyChangedFigureROIDs, myProgressBarRefresh, cnt, ref curCnt);
			}
		}
		private int CountRoFstGraphics(ROFSTLookup.rochild[] rochild)
		{
			int cnt = 0;
			for (int i = 0; i < rochild.Length; i++)
			{
				if (rochild[i].type == 8) cnt++;
				if (rochild[i].children != null) cnt += this.CountRoFstGraphics(rochild[i].children);
			}
			return cnt;
		}
		private void AddGraphic(RODbInfo rdi, ROFSTLookup.rochild myRO, RODb rodb, ROFst rofst, Dictionary<string, int> myExistingROImages, List<int> myUnChangedROImages, List<string> myAddedROImages, List<string> MyChangedFigureROIDs, ROFstInfoProgressBarRefresh myProgressBarRefresh, int cnt, int curCnt)
		{
			string p = myRO.value;
			if (p == null) return;
			string imgname = p.Substring(0, p.IndexOf('\n'));
			int thedot = imgname.LastIndexOf('.');
			string fname = imgname;
			if (thedot == -1 || (thedot != (imgname.Length - 4)))
			{
				RODbConfig roDbCfg = new RODbConfig(rdi.Config);
				fname += string.Format(".{0}", roDbCfg.GetDefaultGraphicExtension());
			}

			string imgfile = rdi.FolderPath + @"\" + fname;

			ROImage roImg = null;
			if (File.Exists(imgfile))
			{
				FileInfo fi = new FileInfo(imgfile);
				// if the roimage record exists, don't create a new one...
				string key = ROImageKey(imgname, fi.LastWriteTimeUtc);
				if (myExistingROImages.ContainsKey(key))
				{
					int imageID = myExistingROImages[key];
					if (!myUnChangedROImages.Contains(imageID))
						myUnChangedROImages.Add(imageID);
				}
				else
				{
					if (!myAddedROImages.Contains(key))
					{
						myProgressBarRefresh(curCnt, cnt, "Loading " + imgname); // show progress of loading images
						FileStream fsIn = new FileStream(imgfile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
						BinaryReader r = new BinaryReader(fsIn);
						byte[] ab = r.ReadBytes((int)fsIn.Length);
						r.Close();
						fsIn.Close();
						byte[] cmp = ROImageInfo.Compress(ab);
						int existingImageID = FindExisting(myExistingROImages, imgname, imgfile, cmp, ab);
						if (existingImageID != 0)
						{
							if (!myUnChangedROImages.Contains(existingImageID))
								myUnChangedROImages.Add(existingImageID);
							return;
						}
						ROImageConfig rc = new ROImageConfig();
						rc.Image_Size = ab.Length.ToString();
						using (roImg = ROImage.MakeROImage(rodb, imgname, ROImageInfo.Compress(ab), rc.ToString(), fi.LastWriteTimeUtc, "Migration"))
						{
							using (Figure figure = Figure.GetByROFstID_ImageID(this.ROFstID, roImg.ImageID))
							{
						if (figure != null) return;
								Figure.MakeFigure(rofst, roImg, null).Dispose();
						myAddedROImages.Add(key);
						MyChangedFigureROIDs.Add(myRO.roid); // Save the roid so that the related documents will be refeshed. (PDF will be deleted)
					}
				}
			}
		}
			}
		}

		private int FindExisting(Dictionary<string, int> myExistingROImages, string imgname, string imgfile, byte[] cmpFileContents, byte[] fileContents)
		{
			// the reason the following check is necessary is that the DTS can be off by hours 
			// because of the way windows handles Daylight savings time for file DTS.

			FileInfo fi = new FileInfo(imgfile);
			DateTime dts = fi.LastWriteTimeUtc;

			// loop through myExistingROImages looking for matching name.
			foreach (string key in myExistingROImages.Keys)
			{
				// if found, compare the date/time stamp
				string part1 = Regex.Replace(key, ":.*$", "");
				string part2 = Regex.Replace(key, "^.*?:", "");
				if (part1.ToUpper() == imgname.ToUpper())
				{
					// if date/time stamps matches date, minutes & seconds, compare contents
					string cmp1 = Regex.Replace(dts.ToString(), " [0-9]*:", " x:");
					cmp1 = Regex.Replace(cmp1, " [AP]", " x");
					string cmp2 = Regex.Replace(part2, " [0-9]*:", " x:");
					cmp2 = Regex.Replace(cmp2, " [AP]", " x");
					if (cmp1==cmp2)
					{
						// compare contents
						int imgId = myExistingROImages[key];
						using (ROImageInfo roii = ROImageInfo.Get(imgId))
						{
							ROImageConfig roicfg = new ROImageConfig(roii);
							int size = Convert.ToInt32(roicfg.Image_Size);
							byte[] tmpb = ROImageInfo.Decompress(roii.Content, size);

							if (ByteArrayCompare(roii.Content, cmpFileContents))
								return imgId;
							if (ByteArrayCompare(tmpb, fileContents))
								return imgId;
						}
					}
				}
			}
			return 0;
		}

		private bool ByteArrayCompare(byte[] ba1, byte[] ba2)
		{
			// we wrote our own byte array comparinson because the system's 'equals' did not work!
			if (ba1.Length != ba2.Length) return false;
			for (int i = 0; i < ba1.Length; i++)
				if (ba1[i] != ba2[i]) return false;
			return true;
		}

		private ROImageInfo GetMyImage(Dictionary<string, ROImageInfo> myImages, string imgname, DateTime dts)
		{
			string key = string.Format("{0}:{1}", imgname, dts);
			if(myImages.ContainsKey(key))
				return myImages[key];
			return null;
		}
		#endregion
		#endregion
		public bool IsSetpointDB(int id, DocVersionInfo dvi)
		{
			ROFSTLookup.rodbi[] dbs = GetROFSTLookup(dvi).GetRODatabaseList();
			foreach (ROFSTLookup.rodbi rodbi in dbs)
			{
				if (id == rodbi.dbiID)
					return (rodbi.dbiAP.StartsWith("SP"));
			}
			return false;
		}
		public ROFst GetJustROFst()
		{
			return ROFst.GetJustROFst(ROFstID);
		}
		public event ROFstInfoROTableUpdateEvent ROTableUpdate;
		public List<string> OnROTableUpdate(object sender, ROFstInfoROTableUpdateEventArgs args)
		{
			if (ROTableUpdate != null) return ROTableUpdate(sender, args);
			return null;
		}
		public static ROFstInfo GetJustROFst(int rOFstID)
		{
			//if (!CanGetObject())
			//  throw new System.Security.SecurityException("User not authorized to view a ROFst");
			try
			{
				ROFstInfo tmp = GetCachedByPrimaryKey(rOFstID);
				if (tmp == null)
				{
					tmp = DataPortal.Fetch<ROFstInfo>(new PKCriteriaJustROFst(rOFstID));
					AddToCache(tmp);
				}
				if (tmp.ErrorMessage == "No Record Found")
				{
					tmp.Dispose(); // Clean-up ROFstInfo
					tmp = null;
				}
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on ROFstInfo.Get", ex);
			}
		}
		[Serializable()]
		protected class PKCriteriaJustROFst
		{
			private int _ROFstID;
			public int ROFstID
			{ get { return _ROFstID; } }
			public PKCriteriaJustROFst(int rOFstID)
			{
				_ROFstID = rOFstID;
			}
		}
		private void DataPortal_Fetch(PKCriteriaJustROFst criteria)
		{
			if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] ROFstInfo.DataPortal_Fetch", GetHashCode());
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					ApplicationContext.LocalContext["cn"] = cn;
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandText = "getJustROFst";
						cm.Parameters.AddWithValue("@ROFstID", criteria.ROFstID);
						cm.CommandTimeout = Database.DefaultTimeout;
						using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
						{
							if (!dr.Read())
							{
								_ErrorMessage = "No Record Found";
								return;
							}
							ReadData(dr);
						}
					}
					// removing of item only needed for local data portal
					if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client)
						ApplicationContext.LocalContext.Remove("cn");
				}
			}
			catch (Exception ex)
			{
				if (_MyLog.IsErrorEnabled) _MyLog.Error("ROFstInfo.DataPortal_Fetch", ex);
				_ErrorMessage = ex.Message;
				throw new DbCslaException("ROFstInfo.DataPortal_Fetch", ex);
			}
		}
		public ROImageInfo GetROImageByFilename(string filename, ItemInfo myItemInfo)
		{
			ROImageInfoList images = ROImageInfoList.GetByRODbIDFilename(RODbID, filename);
			if (images == null || images.Count == 0)
			{
				ROWarning(myItemInfo,"Referenced Object Image {0} Missing", filename);
				return null;
			}
			ROImageInfo retval = null;
			foreach (ROImageInfo image in images)
			{
				if (image.DTS > DTS && retval != null) break;
				retval = image;
			}
			if(retval.DTS > DTS)
				ROWarning(myItemInfo, "Referenced Object Image {0} newer {1} than RO.FST {2}", filename, retval.DTS.ToShortDateString(), DTS.ToShortDateString());
			else
				ROWarning(myItemInfo, "Referenced Object Image {0} older {1} then RO.FST {2}", filename, retval.DTS.ToShortDateString(), DTS.ToShortDateString());
			return retval;
		}
		private static List<int> DocVersionsNeedingROUpdate = new List<int>();
		private static void ROWarning(ItemInfo myItemInfo, string format, params object[] args)
		{
			int key = 0;
			if(myItemInfo != null && myItemInfo.MyDocVersion != null) key = myItemInfo.MyDocVersion.VersionID;
			if (!DocVersionsNeedingROUpdate.Contains(key))
			{
				if (myItemInfo == null)
				{
					string prefix = string.Format("\r\nNeed to Update RO Values\r\n");
					_MyLog.WarnFormat(prefix + format, args);
					DocVersionsNeedingROUpdate.Add(key);
				}
				else
				{
					string prefix = string.Format("\r\nNeed to Update RO Values for {0}\r\nProcedure {1}\r\n", myItemInfo.SearchDVPath, myItemInfo.MyProcedure.DisplayNumber);
					_MyLog.WarnFormat(prefix + format, args);
					DocVersionsNeedingROUpdate.Add(key);
				}
			}
		}
	}
	public class ROFstInfoROTableUpdateEventArgs
	{
		private string _ROText;
		public string ROText
		{
			get { return _ROText; }
			set { _ROText = value; }
		}
		private string _OldGridXml;
		public string OldGridXml
		{
			get { return _OldGridXml; }
			set { _OldGridXml = value; }
		}
		public ROFstInfoROTableUpdateEventArgs(string rotext, string oldgridxml)
		{
			_ROText = rotext;
			_OldGridXml = oldgridxml;
		}
	}
	public partial class ROFstInfoList
	{
		[Serializable()]
		private class RoFstSizeCriteria
		{
			public RoFstSizeCriteria(int roDbID, int len)
			{
				_RODbID = roDbID;
				_Len = len;
			}
			private int _RODbID;
			public int RODbID
			{
				get { return _RODbID; }
				set { _RODbID = value; }
			}
			private int _Len;
			public int Len
			{
				get { return _Len; }
				set { _Len = value; }
			}
		}
		public static ROFstInfoList GetBySize(int roDbID, int len)
		{
			try
			{
				ROFstInfoList tmp = DataPortal.Fetch<ROFstInfoList>(new RoFstSizeCriteria(roDbID, len));
				ROFstInfo.AddList(tmp);
				tmp.AddEvents();
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on RoFstInfoList.GetBySize", ex);
			}
		}
		public static bool ROFstDiffBySize(string rofstPath, int roDbID, int len)
		{
			try
			{
				bool isDifferent = false;
				using (ROFstInfoList tmp = GetBySize(roDbID, len))
				{
					if (tmp.Count > 0)
					{
						// B2017-078  WCN users with Read only access to the RO FST file where not able to open the file for reading when
						//            another user was accessing the file. Changed FileShare from Read to ReadWrite
						FileStream fsIn = new FileStream(rofstPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
						// Create an instance of StreamReader that can read characters from the FileStream.
						BinaryReader r = new BinaryReader(fsIn);
						byte[] ab = r.ReadBytes((int)fsIn.Length);
						r.Close();
						fsIn.Close();
						foreach (ROFstInfo irofst in tmp)
						{
							// compare contents by comparing each byte.
							for (int i = 20; i < len; i++) // this skips past RO.FST header which has the FST creation date/time
								if (ab[i] != irofst.ROLookup[i]) isDifferent = true;
							irofst.Dispose();
							if (isDifferent) break;
						}
					}
				}
				GC.Collect();
				return isDifferent;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on RoFstInfoList.ROFstDiffBySize", ex);
			}
		}
		private void DataPortal_Fetch(RoFstSizeCriteria criteria)
		{
			this.RaiseListChangedEvents = false;
			if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] ROFstInfoList.DataPortal_FetchBySize", GetHashCode());
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandText = "getRoFstBySize";
						cm.Parameters.AddWithValue("@RODbID", criteria.RODbID);
						cm.Parameters.AddWithValue("@Len", criteria.Len);

						cm.CommandTimeout = Database.DefaultTimeout;
						using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
						{
							IsReadOnly = false;
							while (dr.Read())
								this.Add(new ROFstInfo(dr));
							IsReadOnly = true;
						}
					}
				}
			}
			catch (Exception ex)
			{
				if (_MyLog.IsErrorEnabled) _MyLog.Error("ROFstInfoList.DataPortal_FetchBySize", ex);
				throw new DbCslaException("ROFstInfoList.DataPortal_FetchBySize", ex);
			}
			this.RaiseListChangedEvents = true;
		}
	}
}